@dxos/plugin-deck 0.8.2-main.36232bc → 0.8.2-main.5ca3450

package/src/capabilities/intent-resolver.ts

@@ -3,7 +3,7 @@
 //
 
 import { batch } from '@preact/signals-core';
-import { Effect, pipe } from 'effect';
+import { Schema, Effect, pipe } from 'effect';
 
 import {
   Capabilities,
@@ -15,7 +15,7 @@ import {
   createIntent,
   chain,
 } from '@dxos/app-framework';
-import { getTypename, S } from '@dxos/echo-schema';
+import { getTypename } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { isLiveObject } from '@dxos/live-object';
 import { log } from '@dxos/log';
@@ -67,10 +67,10 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateSidebar.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.UpdateSidebar.fields.input)`
       //  but the filter is not being applied correctly.
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdateSidebar.fields.input> =>
-        S.is(LayoutAction.UpdateSidebar.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.UpdateSidebar.fields.input> =>
+        Schema.is(LayoutAction.UpdateSidebar.fields.input)(data),
       resolve: ({ options }) => {
         const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         const next = options?.state ?? layout.sidebarState;
@@ -81,10 +81,10 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateComplementary.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.UpdateComplementary.fields.input)`
       //  but the filter is not being applied correctly.
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdateComplementary.fields.input> =>
-        S.is(LayoutAction.UpdateComplementary.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.UpdateComplementary.fields.input> =>
+        Schema.is(LayoutAction.UpdateComplementary.fields.input)(data),
       resolve: ({ subject, options }) => {
         const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
 
@@ -100,10 +100,10 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateDialog.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.UpdateDialog.fields.input)`
       //  but the filter is not being applied correctly.
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdateDialog.fields.input> =>
-        S.is(LayoutAction.UpdateDialog.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.UpdateDialog.fields.input> =>
+        Schema.is(LayoutAction.UpdateDialog.fields.input)(data),
       resolve: ({ subject, options }) => {
         const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         layout.dialogOpen = options.state ?? Boolean(subject);
@@ -114,10 +114,10 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdatePopover.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.UpdatePopover.fields.input)`
       //  but the filter is not being applied correctly.
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdatePopover.fields.input> =>
-        S.is(LayoutAction.UpdatePopover.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.UpdatePopover.fields.input> =>
+        Schema.is(LayoutAction.UpdatePopover.fields.input)(data),
       resolve: ({ subject, options }) => {
         const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         layout.popoverOpen = options.state ?? Boolean(subject);
@@ -133,10 +133,10 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.AddToast.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.AddToast.fields.input)`
       //  but the filter is not being applied correctly.
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.AddToast.fields.input> =>
-        S.is(LayoutAction.AddToast.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.AddToast.fields.input> =>
+        Schema.is(LayoutAction.AddToast.fields.input)(data),
       resolve: ({ subject }) => {
         const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         layout.toasts.push(subject);
@@ -144,10 +144,10 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.SetLayoutMode.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.SetLayoutMode.fields.input)`
       //  but the filter is not being applied correctly.
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.SetLayoutMode.fields.input> => {
-        if (!S.is(LayoutAction.SetLayoutMode.fields.input)(data)) {
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.SetLayoutMode.fields.input> => {
+        if (!Schema.is(LayoutAction.SetLayoutMode.fields.input)(data)) {
           return false;
         }
 
@@ -202,8 +202,8 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.SwitchWorkspace.fields.input> =>
-        S.is(LayoutAction.SwitchWorkspace.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.SwitchWorkspace.fields.input> =>
+        Schema.is(LayoutAction.SwitchWorkspace.fields.input)(data),
       resolve: ({ subject }) => {
         const state = context.requestCapability(DeckCapabilities.MutableDeckState);
         batch(() => {
@@ -228,8 +228,8 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.RevertWorkspace.fields.input> =>
-        S.is(LayoutAction.RevertWorkspace.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.RevertWorkspace.fields.input> =>
+        Schema.is(LayoutAction.RevertWorkspace.fields.input)(data),
       resolve: () => {
         const state = context.requestCapability(DeckCapabilities.MutableDeckState);
         return {
@@ -239,8 +239,8 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.Open.fields.input> =>
-        S.is(LayoutAction.Open.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.Open.fields.input> =>
+        Schema.is(LayoutAction.Open.fields.input)(data),
       resolve: ({ subject, options }) =>
         Effect.gen(function* () {
           const { graph } = context.requestCapability(Capabilities.AppGraph);
@@ -301,8 +301,8 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.Close.fields.input> =>
-        S.is(LayoutAction.Close.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.Close.fields.input> =>
+        Schema.is(LayoutAction.Close.fields.input)(data),
       resolve: ({ subject }) => {
         const state = context.requestCapability(DeckCapabilities.MutableDeckState);
         const attention = context.requestCapability(AttentionCapabilities.Attention);
@@ -324,8 +324,8 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.Set.fields.input> =>
-        S.is(LayoutAction.Set.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.Set.fields.input> =>
+        Schema.is(LayoutAction.Set.fields.input)(data),
       resolve: ({ subject }) => {
         const state = context.requestCapability(DeckCapabilities.MutableDeckState);
         const attention = context.requestCapability(AttentionCapabilities.Attention);
@@ -337,8 +337,8 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.ScrollIntoView.fields.input> =>
-        S.is(LayoutAction.ScrollIntoView.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.ScrollIntoView.fields.input> =>
+        Schema.is(LayoutAction.ScrollIntoView.fields.input)(data),
       resolve: ({ subject }) => {
         const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         layout.scrollIntoView = subject;

package/src/capabilities/tools.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema } from 'effect';
+
 import {
   contributes,
   createIntent,
@@ -10,7 +12,6 @@ import {
   type PromiseIntentDispatcher,
 } from '@dxos/app-framework';
 import { defineTool, ToolResult } from '@dxos/artifact';
-import { S } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 
 import { meta } from '../meta';
@@ -35,8 +36,8 @@ export default () =>
       `,
       caption: 'Showing item...',
       // TODO(wittjosiah): Refactor Layout/Navigation/Deck actions so that they can be used directly.
-      schema: S.Struct({
-        id: S.String.annotations({
+      schema: Schema.Struct({
+        id: Schema.String.annotations({
           description: 'The ID of the item to show.',
         }),
       }),

package/src/components/DeckLayout/Popover.tsx

@@ -3,7 +3,7 @@
 //
 
 import { createContext } from '@radix-ui/react-context';
-import React, { type PropsWithChildren, useCallback, useEffect, useRef, useState } from 'react';
+import React, { type PropsWithChildren, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import { Surface, useCapability } from '@dxos/app-framework';
 import { Popover, type PopoverContentInteractOutsideEvent } from '@dxos/react-ui';
@@ -45,7 +45,7 @@ export const PopoverRoot = ({ children }: DeckPopoverRootProps) => {
 
   return (
     <DeckPopoverProvider setOpen={setOpen}>
-      <Popover.Root modal open={open}>
+      <Popover.Root modal={false} open={open}>
         {layout.popoverAnchor && <Popover.VirtualTrigger key={virtualIter} virtualRef={virtualRef} />}
         {children}
       </Popover.Root>
@@ -76,9 +76,24 @@ export const PopoverContent = () => {
     [setOpen],
   );
 
+  const collisionBoundaries: HTMLElement[] = useMemo(() => {
+    const closest = layout.popoverAnchor?.closest('[data-popover-collision-boundary]') as
+      | HTMLElement
+      | null
+      | undefined;
+    return closest ? [closest] : [];
+  }, [layout.popoverAnchor]);
+
   return (
     <Popover.Portal>
-      <Popover.Content side={layout.popoverSide} onInteractOutside={handleClose} onEscapeKeyDown={handleClose}>
+      <Popover.Content
+        side={layout.popoverSide}
+        onInteractOutside={handleClose}
+        onEscapeKeyDown={handleClose}
+        collisionBoundary={collisionBoundaries}
+        sticky='always'
+        hideWhenDetached
+      >
         <Popover.Viewport>
           <Surface role='popover' data={layout.popoverContent} limit={1} />
         </Popover.Viewport>

package/src/components/Plank/Plank.tsx

@@ -116,7 +116,7 @@ const PlankImpl = memo(
           path,
           popoverAnchorId,
         },
-      [node, node?.data, path, popoverAnchorId, primary?.data],
+      [node, node?.data, path, popoverAnchorId, primary?.data, variant],
     );
 
     // TODO(wittjosiah): Change prop to accept a component.
@@ -131,6 +131,8 @@ const PlankImpl = memo(
       part === 'deck' && (companioned === 'companion' ? '!border-separator border-ie' : '!border-separator border-li'),
       part.startsWith('solo-') && 'row-span-2 grid-rows-subgrid min-is-0',
       part === 'solo-companion' && '!border-separator border-is',
+      layoutMode === 'solo--fullscreen' &&
+        '!transition-[margin-block-start,inline-size] -mbs-[--rail-action] has-[[data-plank-heading]:hover]:mbs-0',
     );
 
     return (

package/src/components/Plank/PlankHeading.tsx

@@ -145,7 +145,10 @@ export const PlankHeading = memo(
         classNames={[
           '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'>

package/src/types.ts

@@ -2,8 +2,9 @@
 // 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';
@@ -23,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,
@@ -62,9 +63,9 @@ export const defaultDeck: DeckState = {
   companionFrameSizing: {},
 };
 
-const LayoutMode = S.Literal('deck', 'solo', '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 | DeepReadonly<DeckState>): LayoutMode => {
   if (deck.solo) {
@@ -75,73 +76,73 @@ export const getMode = (deck: DeckState | DeepReadonly<DeckState>): LayoutMode =
 };
 
 // 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,
-  dialogBlockAlign: S.optional(S.Literal('start', 'center', 'end')),
-  dialogType: S.optional(S.Literal('default', 'alert')),
+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),
+  dialogContent: Schema.optional(Schema.Any),
 
-  popoverOpen: S.Boolean,
-  popoverSide: S.optional(S.Literal('top', 'right', 'bottom', 'left')),
-  popoverAnchor: S.optional(S.Any),
-  popoverAnchorId: S.optional(S.String),
+  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),
+  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('solo--fullscreen').annotations({ description: 'Fullscreen 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,
   }) {}
 }