@dxos/plugin-deck 0.8.1 → 0.8.2-main.2f9c567

package/src/components/Plank/PlankControls.tsx

@@ -17,7 +17,7 @@ import {
 } from '@dxos/react-ui';
 
 import { DECK_PLUGIN } from '../../meta';
-import { DeckAction } from '../../types';
+import { DeckAction, type LayoutMode } from '../../types';
 
 export type PlankControlHandler = (event: DeckAction.PartAdjustment) => void;
 
@@ -34,7 +34,7 @@ export type PlankControlsProps = Omit<ButtonGroupProps, 'onClick'> & {
   variant?: 'hide-disabled' | 'default';
   close?: boolean | 'minify-start' | 'minify-end';
   capabilities: PlankCapabilities;
-  isSolo?: boolean;
+  layoutMode?: LayoutMode;
   pin?: 'start' | 'end' | 'both';
 };
 
@@ -73,8 +73,7 @@ export const PlankCompanionControls = forwardRef<HTMLDivElement, PlankCompliment
         <PlankControl
           label={t('close companion label')}
           variant='ghost'
-          // icon='ph--minus--regular'
-          icon='ph--caret-left--regular'
+          icon='ph--x--regular'
           onClick={handleCloseCompanion}
           classNames={plankControlSpacing}
         />
@@ -88,35 +87,51 @@ export const PlankCompanionControls = forwardRef<HTMLDivElement, PlankCompliment
 // NOTE(thure): Pinning & unpinning are disabled indefinitely.
 export const PlankControls = forwardRef<HTMLDivElement, PlankControlsProps>(
   (
-    { children, classNames, variant = 'default', capabilities, isSolo, pin, close = false, onClick, ...props },
+    { children, classNames, variant = 'default', capabilities, layoutMode, pin, close = false, onClick, ...props },
     forwardedRef,
   ) => {
     const { t } = useTranslation(DECK_PLUGIN);
     const buttonClassNames =
       variant === 'hide-disabled' ? `disabled:hidden ${plankControlSpacing}` : plankControlSpacing;
 
+    const layoutIsAnySolo = !!layoutMode?.startsWith('solo');
+
     return (
       <ButtonGroup {...props} classNames={['app-no-drag', classNames]} ref={forwardedRef}>
-        {/* {pin && !isSolo && ['both', 'start'].includes(pin) && (
-          <PlankControl
-            label={t('pin start label')}
-            variant='ghost'
-            classNames={buttonClassNames}
-            onClick={() => onClick?.('pin-start')}
-            icon='ph--caret-line-left--regular'
-          />
-        )} */}
-
-        {capabilities.deck && capabilities.solo && (
+        {capabilities.deck && (
           <>
-            <PlankControl
-              label={isSolo ? t('show deck plank label') : t('show solo plank label')}
-              classNames={buttonClassNames}
-              icon={isSolo ? 'ph--corners-in--regular' : 'ph--corners-out--regular'}
-              onClick={() => onClick?.('solo')}
-            />
-
-            {!isSolo && (
+            {capabilities.solo && (
+              <>
+                {layoutMode === 'solo' && (
+                  <PlankControl
+                    label={t('show fullscreen plank label')}
+                    classNames={buttonClassNames}
+                    icon='ph--corners-out--regular'
+                    onClick={() => onClick?.('solo--fullscreen')}
+                  />
+                )}
+                <PlankControl
+                  label={t(
+                    layoutMode === 'solo--fullscreen'
+                      ? 'exit fullscreen label'
+                      : layoutIsAnySolo
+                        ? 'show deck plank label'
+                        : 'show solo plank label',
+                  )}
+                  classNames={buttonClassNames}
+                  icon={
+                    layoutMode === 'solo--fullscreen'
+                      ? 'ph--corners-in--regular'
+                      : layoutIsAnySolo
+                        ? 'ph--arrows-in-line-horizontal--regular'
+                        : 'ph--arrows-out-line-horizontal--regular'
+                  }
+                  onClick={() => onClick?.(layoutMode === 'solo--fullscreen' ? 'solo--fullscreen' : 'solo')}
+                />
+              </>
+            )}
+
+            {!layoutIsAnySolo && (
               <>
                 <PlankControl
                   label={t('increment start label')}
@@ -137,16 +152,7 @@ export const PlankControls = forwardRef<HTMLDivElement, PlankControlsProps>(
           </>
         )}
 
-        {/* {pin && !isSolo && ['both', 'end'].includes(pin) && (
-          <PlankControl
-            label={t('pin end label')}
-            classNames={buttonClassNames}
-            icon='ph--caret-line-right--regular'
-            onClick={() => onClick?.('pin-end')}
-          />
-        )} */}
-
-        {close && !isSolo && (
+        {close && !layoutIsAnySolo && (
           <PlankControl
             label={t(`${typeof close === 'string' ? 'minify' : 'close'} label`)}
             classNames={buttonClassNames}

package/src/components/Plank/PlankError.tsx

@@ -6,7 +6,7 @@ import React, { useEffect, useState } from 'react';
 
 import { type Node } from '@dxos/plugin-graph';
 import { useTranslation } from '@dxos/react-ui';
-import { descriptionText, mx } from '@dxos/react-ui-theme';
+import { descriptionMessage, mx } from '@dxos/react-ui-theme';
 
 import { PlankHeading, type PlankHeadingProps } from './PlankHeading';
 import { PlankLoading } from './PlankLoading';
@@ -19,11 +19,7 @@ export const PlankContentError = ({ error }: { error?: Error }) => {
     <div role='none' className='overflow-auto p-8 attention-surface grid place-items-center'>
       <p
         role='alert'
-        className={mx(
-          descriptionText,
-          'break-words border border-dashed border-separator rounded-lg p-8',
-          errorString.length < 256 && 'text-lg',
-        )}
+        className={mx(descriptionMessage, 'break-words rounded-lg p-8', errorString.length < 256 && 'text-lg')}
       >
         {error ? errorString : t('error fallback message')}
       </p>

package/src/components/Plank/PlankHeading.tsx

@@ -13,13 +13,16 @@ import { TextTooltip } from '@dxos/react-ui-text-tooltip';
 import { PlankCompanionControls, PlankControls } from './PlankControls';
 import { parseEntryId } from '../../layout';
 import { DECK_PLUGIN } from '../../meta';
-import { PLANK_COMPANION_TYPE, DeckAction, type ResolvedPart } from '../../types';
+import { PLANK_COMPANION_TYPE, DeckAction, type ResolvedPart, type LayoutMode } from '../../types';
 import { useBreakpoints } from '../../util';
 import { soloInlinePadding } from '../fragments';
 
+const MAX_COMPANIONS = 5;
+
 export type PlankHeadingProps = {
   id: string;
   part: ResolvedPart;
+  layoutMode?: LayoutMode;
   node?: Node;
   deckEnabled?: boolean;
   canIncrementStart?: boolean;
@@ -45,6 +48,7 @@ export const PlankHeading = memo(
     pending,
     companioned,
     companions,
+    layoutMode,
     actions = [],
   }: PlankHeadingProps) => {
     const { t } = useTranslation(DECK_PLUGIN);
@@ -96,7 +100,7 @@ export const PlankHeading = memo(
 
     const handlePlankAction = useCallback(
       (eventType: DeckAction.PartAdjustment) => {
-        if (eventType === 'solo') {
+        if (eventType.startsWith('solo')) {
           return dispatch(createIntent(DeckAction.Adjust, { type: eventType, id }));
         } else if (eventType === 'close') {
           if (part === 'complementary') {
@@ -139,9 +143,12 @@ export const PlankHeading = memo(
     return (
       <StackItem.Heading
         classNames={[
-          'plb-1 border-be border-separator items-stretch gap-1 sticky inline-start-12 app-drag min-is-0 layout-contain',
+          'plb-1 border-be border-separator items-stretch gap-1 sticky inline-start-12 app-drag min-is-0 contain-layout',
           part === 'solo' ? soloInlinePadding : 'pli-1',
+          layoutMode === 'solo--fullscreen' &&
+            'opacity-0 border-transparent hover:border-separator hover:opacity-100 transition-[border-color,opacity]',
         ]}
+        data-plank-heading
       >
         {companions && isCompanionNode ? (
           <div role='none' className='flex-1 min-is-0 overflow-x-auto scrollbar-thin flex gap-1'>
@@ -150,7 +157,7 @@ export const PlankHeading = memo(
                 key={id}
                 data-id={id}
                 icon={icon}
-                iconOnly={node?.id !== id}
+                iconOnly={companions.length > MAX_COMPANIONS && node?.id !== id}
                 label={toLocalizedString(label, t)}
                 size={5}
                 variant={node?.id === id ? 'primary' : 'default'}
@@ -196,7 +203,7 @@ export const PlankHeading = memo(
         ) : (
           <PlankControls
             capabilities={capabilities}
-            isSolo={part === 'solo'}
+            layoutMode={layoutMode}
             close={part === 'complementary' ? 'minify-end' : true}
             onClick={handlePlankAction}
           />

package/src/components/Sidebar/ComplementarySidebar.tsx

@@ -28,7 +28,7 @@ import { byPosition, type Position } from '@dxos/util';
 import { ToggleComplementarySidebarButton } from './SidebarButton';
 import { DeckCapabilities } from '../../capabilities';
 import { DECK_PLUGIN } from '../../meta';
-import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE } from '../../types';
+import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE, getMode } from '../../types';
 import { layoutAppliesTopbar, useBreakpoints, useHoistStatusbar } from '../../util';
 import { PlankContentError, PlankLoading } from '../Plank';
 
@@ -65,13 +65,14 @@ export const ComplementarySidebar = ({ current }: ComplementarySidebarProps) =>
   const { t } = useTranslation(DECK_PLUGIN);
   const { dispatchPromise: dispatch } = useIntentDispatcher();
   const layout = useCapability(DeckCapabilities.MutableDeckState);
+  const layoutMode = getMode(layout.deck);
   const breakpoint = useBreakpoints();
-  const topbar = layoutAppliesTopbar(breakpoint);
-  const hoistStatusbar = useHoistStatusbar(breakpoint);
+  const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
+  const hoistStatusbar = useHoistStatusbar(breakpoint, layoutMode);
 
   const companions = useDeckCompanions();
-  const activeCompanion = companions.find((companion) => getCompanionId(companion.id) === current) ?? companions.at(0);
-  const activeId = getCompanionId(activeCompanion?.id ?? 'never');
+  const activeCompanion = companions.find((companion) => getCompanionId(companion.id) === current);
+  const activeId = activeCompanion && getCompanionId(activeCompanion.id);
   const [internalValue, setInternalValue] = useState(activeId);
 
   useEffect(() => {
@@ -101,6 +102,14 @@ export const ComplementarySidebar = ({ current }: ComplementarySidebarProps) =>
     [activeCompanion?.id, activeCompanion?.data],
   );
 
+  useEffect(() => {
+    if (!activeId) {
+      void dispatch(
+        createIntent(LayoutAction.UpdateComplementary, { part: 'complementary', options: { state: 'collapsed' } }),
+      );
+    }
+  }, [activeId, dispatch]);
+
   return (
     <Main.ComplementarySidebar
       label={label}
@@ -145,21 +154,22 @@ export const ComplementarySidebar = ({ current }: ComplementarySidebarProps) =>
             <ToggleComplementarySidebarButton />
           </div>
         </div>
-        {companions.map((companion) => (
-          <Tabs.Tabpanel
-            key={getCompanionId(companion.id)}
-            value={getCompanionId(companion.id)}
-            classNames='absolute data-[state="inactive"]:-z-[1] inset-block-0 inline-start-0 is-[calc(100%-var(--r0-size))] lg:is-[--r1-size] grid grid-cols-1 grid-rows-[var(--rail-size)_1fr_min-content] pbs-[env(safe-area-inset-top)]'
-            {...(layout.complementarySidebarState !== 'expanded' && { inert: 'true' })}
-          >
-            <ComplementarySidebarPanel
-              companion={companion}
-              activeId={activeId}
-              data={data}
-              hoistStatusbar={hoistStatusbar}
-            />
-          </Tabs.Tabpanel>
-        ))}
+        {activeId &&
+          companions.map((companion) => (
+            <Tabs.Tabpanel
+              key={getCompanionId(companion.id)}
+              value={getCompanionId(companion.id)}
+              classNames='absolute data-[state="inactive"]:-z-[1] inset-block-0 inline-start-0 is-[calc(100%-var(--r0-size))] lg:is-[--r1-size] grid grid-cols-1 grid-rows-[var(--rail-size)_1fr_min-content] pbs-[env(safe-area-inset-top)]'
+              {...(layout.complementarySidebarState !== 'expanded' && { inert: 'true' })}
+            >
+              <ComplementarySidebarPanel
+                companion={companion}
+                activeId={activeId}
+                data={data}
+                hoistStatusbar={hoistStatusbar}
+              />
+            </Tabs.Tabpanel>
+          ))}
       </Tabs.Root>
     </Main.ComplementarySidebar>
   );

package/src/components/Sidebar/Sidebar.tsx

@@ -9,15 +9,17 @@ import { type Label, Main } from '@dxos/react-ui';
 
 import { DeckCapabilities } from '../../capabilities';
 import { DECK_PLUGIN } from '../../meta';
+import { getMode } from '../../types';
 import { layoutAppliesTopbar, useBreakpoints, useHoistStatusbar } from '../../util';
 
 const label = ['sidebar title', { ns: DECK_PLUGIN }] satisfies Label;
 
 export const Sidebar = () => {
-  const { popoverAnchorId, activeDeck: current } = useCapability(DeckCapabilities.DeckState);
+  const { popoverAnchorId, activeDeck: current, deck } = useCapability(DeckCapabilities.DeckState);
   const breakpoint = useBreakpoints();
-  const topbar = layoutAppliesTopbar(breakpoint);
-  const hoistStatusbar = useHoistStatusbar(breakpoint);
+  const layoutMode = getMode(deck);
+  const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
+  const hoistStatusbar = useHoistStatusbar(breakpoint, layoutMode);
 
   const navigationData = useMemo(
     () => ({ popoverAnchorId, topbar, hoistStatusbar, current }),

package/src/translations.ts

@@ -45,6 +45,8 @@ export default [
         'increment end label': 'Move to the right',
         'show deck plank label': 'Return to deck',
         'show solo plank label': 'Maximize',
+        'exit fullscreen label': 'Exit fullscreen',
+        'show fullscreen plank label': 'Fullscreen',
         'close label': 'Close',
         'minify label': 'Minify',
         'open companion label': 'Open companion',

package/src/types.ts

@@ -2,8 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Schema } from 'effect';
+
 import { LayoutAction } from '@dxos/app-framework';
-import { S } from '@dxos/echo-schema';
+import { type DeepReadonly } from '@dxos/util';
 
 import { DECK_PLUGIN } from './meta';
 
@@ -22,33 +24,33 @@ export type Overscroll = (typeof OverscrollOptions)[number];
 export type Part = 'solo' | 'deck' | 'complementary';
 export type ResolvedPart = Part | 'solo-primary' | 'solo-companion';
 
-export const DeckSettingsSchema = S.Struct({
-  showHints: S.optional(S.Boolean),
-  enableDeck: S.optional(S.Boolean),
-  enableNativeRedirect: S.optional(S.Boolean),
-  enableStatusbar: S.optional(S.Boolean),
-  newPlankPositioning: S.optional(S.Literal(...NewPlankPositions)),
-  overscroll: S.optional(S.Literal(...OverscrollOptions)),
-}).pipe(S.mutable);
-export type DeckSettingsProps = S.Schema.Type<typeof DeckSettingsSchema>;
+export const DeckSettingsSchema = Schema.Struct({
+  showHints: Schema.optional(Schema.Boolean),
+  enableDeck: Schema.optional(Schema.Boolean),
+  enableNativeRedirect: Schema.optional(Schema.Boolean),
+  enableStatusbar: Schema.optional(Schema.Boolean),
+  newPlankPositioning: Schema.optional(Schema.Literal(...NewPlankPositions)),
+  overscroll: Schema.optional(Schema.Literal(...OverscrollOptions)),
+}).pipe(Schema.mutable);
+export type DeckSettingsProps = Schema.Schema.Type<typeof DeckSettingsSchema>;
 
-export const PlankSizing = S.Record({ key: S.String, value: S.Number });
-export type PlankSizing = S.Schema.Type<typeof PlankSizing>;
+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 = S.Struct({
+export const DeckState = Schema.Struct({
   /** If false, the deck has not yet left solo mode and new planks should be soloed. */
-  initialized: S.Boolean,
-  active: S.mutable(S.Array(S.String)),
+  initialized: Schema.Boolean,
+  active: Schema.mutable(Schema.Array(Schema.String)),
   // TODO(wittjosiah): Piping into both mutable and optional caused invalid typescript output.
-  activeCompanions: S.optional(S.mutable(S.Record({ key: S.String, value: S.String }))),
-  inactive: S.mutable(S.Array(S.String)),
-  solo: S.optional(S.String),
-  fullscreen: S.Boolean,
-  plankSizing: S.mutable(PlankSizing),
-  companionFrameSizing: S.mutable(PlankSizing),
+  activeCompanions: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.String }))),
+  inactive: Schema.mutable(Schema.Array(Schema.String)),
+  solo: Schema.optional(Schema.String),
+  fullscreen: Schema.Boolean,
+  plankSizing: Schema.mutable(PlankSizing),
+  companionFrameSizing: Schema.mutable(PlankSizing),
 });
-export type DeckState = S.Schema.Type<typeof DeckState>;
+export type DeckState = Schema.Schema.Type<typeof DeckState>;
 
 export const defaultDeck: DeckState = {
   initialized: false,
@@ -61,84 +63,86 @@ export const defaultDeck: DeckState = {
   companionFrameSizing: {},
 };
 
-const LayoutMode = S.Literal('deck', 'solo', 'fullscreen');
-export type LayoutMode = S.Schema.Type<typeof LayoutMode>;
-export const isLayoutMode = (value: any): value is LayoutMode => S.is(LayoutMode)(value);
+const LayoutMode = Schema.Literal('deck', '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): LayoutMode => {
+export const getMode = (deck: DeckState | DeepReadonly<DeckState>): LayoutMode => {
   if (deck.solo) {
-    return deck.fullscreen ? 'fullscreen' : 'solo';
+    return deck.fullscreen ? 'solo--fullscreen' : 'solo';
   }
 
   return 'deck';
 };
 
 // State of the deck plugin.
-export const DeckPluginState = S.Struct({
-  sidebarState: S.Literal('closed', 'collapsed', 'expanded'),
-  complementarySidebarState: S.Literal('closed', 'collapsed', 'expanded'),
-  complementarySidebarPanel: S.optional(S.String),
-
-  dialogOpen: S.Boolean,
+export const DeckPluginState = Schema.Struct({
+  sidebarState: Schema.Literal('closed', 'collapsed', 'expanded'),
+  complementarySidebarState: Schema.Literal('closed', 'collapsed', 'expanded'),
+  complementarySidebarPanel: Schema.optional(Schema.String),
+
+  dialogOpen: Schema.Boolean,
+  dialogBlockAlign: Schema.optional(Schema.Literal('start', 'center', 'end')),
+  dialogType: Schema.optional(Schema.Literal('default', 'alert')),
   /** Data to be passed to the dialog Surface. */
-  dialogContent: S.optional(S.Any),
-  dialogBlockAlign: S.optional(S.Literal('start', 'center', 'end')),
-  dialogType: S.optional(S.Literal('default', 'alert')),
+  dialogContent: Schema.optional(Schema.Any),
 
-  popoverOpen: S.Boolean,
-  popoverSide: S.optional(S.Literal('top', 'right', 'bottom', 'left')),
+  popoverOpen: Schema.Boolean,
+  popoverSide: Schema.optional(Schema.Literal('top', 'right', 'bottom', 'left')),
+  popoverAnchor: Schema.optional(Schema.Any),
+  popoverAnchorId: Schema.optional(Schema.String),
   /** Data to be passed to the popover Surface. */
-  popoverContent: S.optional(S.Any),
-  popoverAnchorId: S.optional(S.String),
+  popoverContent: Schema.optional(Schema.Any),
 
-  toasts: S.mutable(S.Array(LayoutAction.Toast)),
-  currentUndoId: S.optional(S.String),
+  toasts: Schema.mutable(Schema.Array(LayoutAction.Toast)),
+  currentUndoId: Schema.optional(Schema.String),
 
-  activeDeck: S.String,
-  previousDeck: S.String,
-  decks: S.mutable(S.Record({ key: S.String, value: S.mutable(DeckState) })),
-  previousMode: S.mutable(S.Record({ key: S.String, value: LayoutMode })),
-  deck: S.mutable(DeckState),
+  activeDeck: Schema.String,
+  previousDeck: Schema.String,
+  decks: Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.mutable(DeckState) })),
+  previousMode: Schema.mutable(Schema.Record({ key: Schema.String, value: LayoutMode })),
+  deck: Schema.mutable(DeckState),
 
   /** The identifier of a component to scroll into view when it is mounted. */
-  scrollIntoView: S.optional(S.String),
-}).pipe(S.mutable);
+  scrollIntoView: Schema.optional(Schema.String),
+}).pipe(Schema.mutable);
 
-export type DeckPluginState = S.Schema.Type<typeof DeckPluginState>;
+export type DeckPluginState = Schema.Schema.Type<typeof DeckPluginState>;
 
 export const DECK_ACTION = `${DECK_PLUGIN}/action`;
 
 export namespace DeckAction {
-  const PartAdjustmentSchema = S.Union(
-    S.Literal('close').annotations({ description: 'Close the plank.' }),
-    S.Literal('companion').annotations({ description: 'Open the companion plank.' }),
-    S.Literal('solo').annotations({ description: 'Solo the plank.' }),
-    S.Literal('increment-start').annotations({ description: 'Move the plank towards the start of the deck.' }),
-    S.Literal('increment-end').annotations({ description: 'Move the plank towards the end of the deck.' }),
+  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 = S.Schema.Type<typeof PartAdjustmentSchema>;
-  export const Adjustment = S.mutable(S.Struct({ id: S.String, type: PartAdjustmentSchema }));
-  export type Adjustment = S.Schema.Type<typeof Adjustment>;
+  export type PartAdjustment = Schema.Schema.Type<typeof PartAdjustmentSchema>;
+  export const Adjustment = Schema.mutable(Schema.Struct({ id: Schema.String, type: PartAdjustmentSchema }));
+  export type Adjustment = Schema.Schema.Type<typeof Adjustment>;
 
   // An atomic transaction to apply to the deck, describing which element to move to which location.
-  export class Adjust extends S.TaggedClass<Adjust>()(`${DECK_ACTION}/adjust`, {
+  export class Adjust extends Schema.TaggedClass<Adjust>()(`${DECK_ACTION}/adjust`, {
     input: Adjustment,
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class UpdatePlankSize extends S.TaggedClass<UpdatePlankSize>()(`${DECK_ACTION}/update-plank-size`, {
-    input: S.Struct({
-      id: S.String,
-      size: S.Number,
+  export class UpdatePlankSize extends Schema.TaggedClass<UpdatePlankSize>()(`${DECK_ACTION}/update-plank-size`, {
+    input: Schema.Struct({
+      id: Schema.String,
+      size: Schema.Number,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class ChangeCompanion extends S.TaggedClass<ChangeCompanion>()(`${DECK_ACTION}/change-companion`, {
-    input: S.Struct({
-      primary: S.String,
-      companion: S.Union(S.String, S.Null),
+  export class ChangeCompanion extends Schema.TaggedClass<ChangeCompanion>()(`${DECK_ACTION}/change-companion`, {
+    input: Schema.Struct({
+      primary: Schema.String,
+      companion: Schema.Union(Schema.String, Schema.Null),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 }

package/src/util/layoutAppliesTopbar.ts

@@ -2,6 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-export const layoutAppliesTopbar = (breakpoint: string) => {
-  return document.body.getAttribute('data-platform') === 'win' && breakpoint === 'desktop';
+import { type LayoutMode } from '../types';
+
+export const layoutAppliesTopbar = (breakpoint: string, layoutMode?: LayoutMode) => {
+  return (
+    document.body.getAttribute('data-platform') === 'win' &&
+    breakpoint === 'desktop' &&
+    layoutMode !== 'solo--fullscreen'
+  );
 };

package/src/util/useHoistStatusbar.ts

@@ -8,13 +8,18 @@ import { Capabilities, useCapability } from '@dxos/app-framework';
 import { useThemeContext } from '@dxos/react-ui';
 
 import { DECK_PLUGIN } from '../meta';
-import type { DeckSettingsProps } from '../types';
+import type { DeckSettingsProps, LayoutMode } from '../types';
 
-export const useHoistStatusbar = (breakpoint: string): boolean => {
+export const useHoistStatusbar = (breakpoint: string, layoutMode?: LayoutMode): boolean => {
   const enableStatusbar = useCapability(Capabilities.SettingsStore).getStore<DeckSettingsProps>(DECK_PLUGIN)!.value
     .enableStatusbar;
   const { safeAreaPadding } = useThemeContext();
   return useMemo(() => {
-    return breakpoint === 'desktop' && !!enableStatusbar && safeAreaPadding?.bottom === 0;
-  }, [enableStatusbar, breakpoint, safeAreaPadding?.bottom]);
+    return (
+      breakpoint === 'desktop' &&
+      layoutMode !== 'solo--fullscreen' &&
+      !!enableStatusbar &&
+      safeAreaPadding?.bottom === 0
+    );
+  }, [enableStatusbar, breakpoint, safeAreaPadding?.bottom, layoutMode]);
 };

package/dist/lib/browser/check-app-scheme-SEYECDHI.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/capabilities/check-app-scheme.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';\n\nimport { DECK_PLUGIN } from '../meta';\nimport { type DeckSettingsProps } from '../types';\n\nconst isSocket = !!(globalThis as any).__args;\n\n// TODO(mjamesderocher): Can we get this directly from Socket?\nconst appScheme = 'composer://';\n\n// TODO(mjamesderocher): Factor out as part of NavigationPlugin.\nconst checkAppScheme = (url: string) => {\n  const iframe = document.createElement('iframe');\n  iframe.style.display = 'none';\n  document.body.appendChild(iframe);\n\n  iframe.src = url + window.location.pathname.replace(/^\\/+/, '') + window.location.search;\n\n  const timer = setTimeout(() => {\n    document.body.removeChild(iframe);\n  }, 3000);\n\n  window.addEventListener('pagehide', (event) => {\n    clearTimeout(timer);\n    document.body.removeChild(iframe);\n  });\n};\n\nexport default async (context: PluginsContext) => {\n  const settingsStore = context.requestCapability(Capabilities.SettingsStore);\n  const settings = settingsStore.getStore<DeckSettingsProps>(DECK_PLUGIN)?.value;\n  if (!isSocket && settings?.enableNativeRedirect) {\n    checkAppScheme(appScheme);\n  }\n\n  return contributes(Capabilities.Null, null);\n};\n"],
-  "mappings": ";;;;;AAOA,SAASA,cAAcC,mBAAwC;AAK/D,IAAMC,WAAW,CAAC,CAAEC,WAAmBC;AAGvC,IAAMC,YAAY;AAGlB,IAAMC,iBAAiB,CAACC,QAAAA;AACtB,QAAMC,SAASC,SAASC,cAAc,QAAA;AACtCF,SAAOG,MAAMC,UAAU;AACvBH,WAASI,KAAKC,YAAYN,MAAAA;AAE1BA,SAAOO,MAAMR,MAAMS,OAAOC,SAASC,SAASC,QAAQ,QAAQ,EAAA,IAAMH,OAAOC,SAASG;AAElF,QAAMC,QAAQC,WAAW,MAAA;AACvBb,aAASI,KAAKU,YAAYf,MAAAA;EAC5B,GAAG,GAAA;AAEHQ,SAAOQ,iBAAiB,YAAY,CAACC,UAAAA;AACnCC,iBAAaL,KAAAA;AACbZ,aAASI,KAAKU,YAAYf,MAAAA;EAC5B,CAAA;AACF;AAEA,IAAA,2BAAe,OAAOmB,YAAAA;AACpB,QAAMC,gBAAgBD,QAAQE,kBAAkBC,aAAaC,aAAa;AAC1E,QAAMC,WAAWJ,cAAcK,SAA4BC,WAAAA,GAAcC;AACzE,MAAI,CAACjC,YAAY8B,UAAUI,sBAAsB;AAC/C9B,mBAAeD,SAAAA;EACjB;AAEA,SAAOgC,YAAYP,aAAaQ,MAAM,IAAA;AACxC;",
-  "names": ["Capabilities", "contributes", "isSocket", "globalThis", "__args", "appScheme", "checkAppScheme", "url", "iframe", "document", "createElement", "style", "display", "body", "appendChild", "src", "window", "location", "pathname", "replace", "search", "timer", "setTimeout", "removeChild", "addEventListener", "event", "clearTimeout", "context", "settingsStore", "requestCapability", "Capabilities", "SettingsStore", "settings", "getStore", "DECK_PLUGIN", "value", "enableNativeRedirect", "contributes", "Null"]
-}

package/dist/lib/browser/chunk-B4LOJUWW.mjs

@@ -1,24 +0,0 @@
-// packages/plugins/plugin-deck/src/capabilities/index.ts
-import { lazy } from "@dxos/app-framework";
-var AppGraphBuilder = lazy(() => import("./app-graph-builder-VYZ4IWI3.mjs"));
-var CheckAppScheme = lazy(() => import("./check-app-scheme-SEYECDHI.mjs"));
-var LayoutIntentResolver = lazy(() => import("./intent-resolver-UDYKO2QW.mjs"));
-var ReactRoot = lazy(() => import("./react-root-XLXN2VEW.mjs"));
-var ReactSurface = lazy(() => import("./react-surface-WNGMZL7I.mjs"));
-var DeckSettings = lazy(() => import("./settings-HMDGSBGO.mjs"));
-var DeckState = lazy(() => import("./state-7TN26M42.mjs"));
-var Tools = lazy(() => import("./tools-SC6QEN7R.mjs"));
-var UrlHandler = lazy(() => import("./url-handler-ODG4B6NX.mjs"));
-
-export {
-  AppGraphBuilder,
-  CheckAppScheme,
-  LayoutIntentResolver,
-  ReactRoot,
-  ReactSurface,
-  DeckSettings,
-  DeckState,
-  Tools,
-  UrlHandler
-};
-//# sourceMappingURL=chunk-B4LOJUWW.mjs.map