sh3-core 0.15.0 → 0.15.2

package/dist/{app-appearance/AppAppearanceModal.svelte → overlays/EntityAppearanceModal.svelte}

@@ -1,58 +1,65 @@
 <script lang="ts">
   /*
-   * Customize — pick an icon and color override for a single app.
-   * Reads the existing override on mount via untrack (Svelte 5 idiom for
-   * one-shot prop reads), so editing the form doesn't subscribe to the
-   * shard's reactive state. Save/Reset/Cancel are mutually exclusive.
+   * EntityAppearanceModal — generalization of the per-entity Customize
+   * modal. Used by __app-appearance__ for apps and __layouts__ for saved
+   * layouts. Purely presentational: callers pass an
+   * onSave({ label, icon, color }) callback and decide what an empty
+   * label means (apps treat empty as "use manifest"; layouts mark the
+   * input required via requireLabel: true).
    */
 
   import { untrack } from 'svelte';
   import IconPicker from '../primitives/widgets/IconPicker.svelte';
   import ColorSwatch from '../primitives/widgets/ColorSwatch.svelte';
   import iconsUrl from '../assets/icons.svg';
-  import { listRegisteredApps } from '../api';
-  import { getAppearance, setAppearance } from './appearanceState.svelte';
 
   interface Props {
-    appId: string;
-    appLabel: string;
+    entityLabel: string;
+    initialAppearance?: { icon?: string; color?: string };
+    defaultIcon: string;
+    requireLabel: boolean;
+    onSave(next: { label: string; icon?: string; color?: string }): void;
+    onReset(): void;
     close: () => void;
   }
 
-  let { appId, appLabel, close }: Props = $props();
+  let {
+    entityLabel,
+    initialAppearance,
+    defaultIcon,
+    requireLabel,
+    onSave,
+    onReset,
+    close,
+  }: Props = $props();
 
-  const initial = untrack(() => getAppearance(appId));
-  const manifestIcon = untrack(
-    () => listRegisteredApps().find((m) => m.id === appId)?.icon,
-  );
+  const initial = untrack(() => initialAppearance);
 
   let icon = $state<string | undefined>(initial?.icon);
   let color = $state<string | undefined>(initial?.color);
-  let label = $state<string>(initial?.label ?? '');
+  let label = $state<string>(untrack(() => entityLabel));
   let pickerOpen = $state<boolean>(initial?.icon !== undefined);
 
+  const trimmed = $derived(label.trim());
+  const saveDisabled = $derived(requireLabel && trimmed === '');
+  const effectiveLabel = $derived(trimmed === '' ? entityLabel : trimmed);
+  const effectiveIcon = $derived(icon ?? defaultIcon);
   const hasOverride = $derived(initial !== undefined);
-  const effectiveLabel = $derived(label.trim() === '' ? appLabel : label.trim());
-  const effectiveIcon = $derived(icon ?? manifestIcon ?? 'box');
 
   function save() {
-    const trimmed = label.trim();
-    setAppearance(appId, {
-      icon,
-      color,
-      label: trimmed === '' ? undefined : trimmed,
-    });
+    if (saveDisabled) return;
+    onSave({ label: trimmed, icon, color });
     close();
   }
 
   function reset() {
-    setAppearance(appId, undefined);
+    onReset();
     close();
   }
 </script>
 
 <div class="app-appearance">
-  <h2>Customize {appLabel}</h2>
+  <h2>Customize {entityLabel}</h2>
 
   <div class="preview">
     <div
@@ -67,11 +74,11 @@
     </div>
   </div>
 
-  <label class="row"><span>Name <em>(empty = default)</em></span>
+  <label class="row"><span>Name {#if !requireLabel}<em>(empty = default)</em>{/if}</span>
     <input
       type="text"
       bind:value={label}
-      placeholder={appLabel}
+      placeholder={entityLabel}
       class="name-input"
     />
   </label>
@@ -95,9 +102,9 @@
   </label>
 
   <div class="actions">
-    <button type="button" class="primary" onclick={save}>Save</button>
-    <button type="button" onclick={reset} disabled={!hasOverride}>Reset</button>
-    <button type="button" onclick={close}>Cancel</button>
+    <button type="button" class="primary" onclick={save} disabled={saveDisabled}>Save</button>
+    <button type="button" data-role="reset" onclick={reset} disabled={!hasOverride}>Reset</button>
+    <button type="button" onclick={() => close()}>Cancel</button>
   </div>
 </div>
 
@@ -158,8 +165,6 @@
     -webkit-line-clamp: 2;
     line-clamp: 2;
   }
-  .preview-card-icon { width: 24px; height: 24px; color: var(--shell-fg); }
-  .preview-card-label { font-weight: 600; padding: 0 4px; line-height: 1.2; }
   .actions { display: flex; gap: 8px; margin-top: 16px; }
   .actions button {
     background: var(--shell-bg-elevated);

package/dist/overlays/EntityAppearanceModal.svelte.d.ts

@@ -0,0 +1,19 @@
+interface Props {
+    entityLabel: string;
+    initialAppearance?: {
+        icon?: string;
+        color?: string;
+    };
+    defaultIcon: string;
+    requireLabel: boolean;
+    onSave(next: {
+        label: string;
+        icon?: string;
+        color?: string;
+    }): void;
+    onReset(): void;
+    close: () => void;
+}
+declare const EntityAppearanceModal: import("svelte").Component<Props, {}, "">;
+type EntityAppearanceModal = ReturnType<typeof EntityAppearanceModal>;
+export default EntityAppearanceModal;

package/dist/overlays/EntityAppearanceModal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/overlays/EntityAppearanceModal.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mount, flushSync } from 'svelte';
+import EntityAppearanceModal from './EntityAppearanceModal.svelte';
+function mountModal(props = {}) {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    const onSave = vi.fn();
+    const onReset = vi.fn();
+    const close = vi.fn();
+    const instance = mount(EntityAppearanceModal, {
+        target,
+        props: Object.assign({ entityLabel: 'My App', defaultIcon: 'box', requireLabel: false, onSave,
+            onReset,
+            close }, props),
+    });
+    return { target, onSave, onReset, close, instance };
+}
+describe('EntityAppearanceModal', () => {
+    it('renders the entityLabel as title placeholder', () => {
+        const { target } = mountModal();
+        const input = target.querySelector('input.name-input');
+        expect(input.placeholder).toBe('My App');
+    });
+    it('shows the "(empty = default)" hint when requireLabel is false', () => {
+        const { target } = mountModal({ requireLabel: false });
+        expect(target.textContent).toContain('(empty = default)');
+    });
+    it('hides the "(empty = default)" hint when requireLabel is true', () => {
+        const { target } = mountModal({ requireLabel: true });
+        expect(target.textContent).not.toContain('(empty = default)');
+    });
+    it('disables Save when requireLabel is true and the input is empty', async () => {
+        const { target } = mountModal({ requireLabel: true, entityLabel: '' });
+        flushSync();
+        const save = target.querySelector('button.primary');
+        expect(save.disabled).toBe(true);
+    });
+    it('calls onSave with the trimmed label, icon, color', async () => {
+        const { target, onSave } = mountModal({
+            initialAppearance: { icon: 'cog', color: '#ff0000' },
+        });
+        const input = target.querySelector('input.name-input');
+        input.value = '  Renamed  ';
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+        flushSync();
+        target.querySelector('button.primary').click();
+        expect(onSave).toHaveBeenCalledWith({ label: 'Renamed', icon: 'cog', color: '#ff0000' });
+    });
+    it('calls onReset and close when Reset is clicked', async () => {
+        const { target, onReset, close } = mountModal({
+            initialAppearance: { icon: 'cog' },
+        });
+        target.querySelector('button[data-role="reset"]').click();
+        expect(onReset).toHaveBeenCalled();
+        expect(close).toHaveBeenCalled();
+    });
+});

package/dist/overlays/FloatFrame.svelte

@@ -2,34 +2,69 @@
   Single floating panel frame.
 
   Renders:
-    - Header bar (title + close button, receives pointerdown for drag).
+    - Header bar (title + maximize/close buttons, receives pointerdown for drag).
     - Body that mounts the float's content subtree via LayoutRenderer
       using rootRef={{ kind: 'float', floatId: entry.id }} so the
       renderer reads from layoutStore.tree.floats[...].content instead
       of layoutStore.root.
+    - Bottom-right resize grip (always rendered, including on dismissable
+      pickers — its pointerdown is inside the frame so the dismiss listener
+      doesn't fire).
 
   Behavior:
     - Pointer drag on header mutates entry.position in place. The entry
       is a live reference from layoutStore.tree.floats, so mutation
       reactivity flows through the workspace-zone proxy.
+    - Pointer drag on the resize grip mutates entry.size, clamped at
+      computeMinSize(entry.content).
     - Click anywhere on the frame raises it (calls floatManager.focus).
-    - Close button calls floatManager.close.
+    - Close button calls floatManager.close. Maximize button toggles.
+    - Header double-click toggles maximize (excluding clicks on the close /
+      maximize buttons).
+    - Drag or resize while maximized implicitly un-maximizes (forgets the
+      saved prev rect; keeps the current rect and proceeds). See spec
+      docs/superpowers/specs/2026-05-07-float-resize-maximize-design.md.
 -->
 <script lang="ts">
   import LayoutRenderer from '../layout/LayoutRenderer.svelte';
   import { floatManager, getFloatParentHost } from './float';
   import { registerDismissableFrame, unregisterDismissableFrame } from './floatDismiss';
+  import { computeMinSize } from '../layout/floats';
   import type { FloatEntry } from '../layout/types';
+  import { shell } from '../shellRuntime.svelte';
+  import { makeSelectionApi } from '../actions/selection.svelte';
+
+  const floatHeaderSelection = makeSelectionApi('__layouts__');
+
+  function openHeaderContextMenu(e: MouseEvent): void {
+    e.preventDefault();
+    floatHeaderSelection.set({ type: 'float-header', ref: { floatId: entry.id } });
+    shell.actions.openContextMenu({
+      x: e.clientX,
+      y: e.clientY,
+      scope: { element: 'float-header' },
+    });
+  }
 
   interface Props {
     entry: FloatEntry;
   }
-  const { entry }: Props = $props();
+  // `entry` is the live workspace-zone proxy from `layoutStore.floats`; the
+  // drag/resize/dismiss-listener paths mutate `entry.position` and
+  // `entry.size` in place, which is the canonical reactive flow. Marking
+  // it `$bindable()` opts into that mutation so Svelte 5 doesn't emit the
+  // ownership_invalid_mutation warning. The parent (FloatLayer) uses
+  // `bind:entry` to acknowledge the contract.
+  let { entry = $bindable() }: Props = $props();
 
   let dragging = $state(false);
   let dragOffset = { x: 0, y: 0 };
+  let resizing = $state(false);
+  let resizeStart = { pointer: { x: 0, y: 0 }, size: { w: 0, h: 0 }, min: { w: 0, h: 0 } };
   let frameEl: HTMLDivElement | undefined = $state();
 
+  const isMaximized = $derived(floatManager.isMaximized(entry.id));
+
   $effect(() => {
     if (!entry.dismissable) return;
     if (!frameEl) return;
@@ -62,8 +97,9 @@
   function onHeaderPointerDown(e: PointerEvent): void {
     if (e.button !== 0) return;
     if ((e.target as HTMLElement).closest('.sh3-float-close')) return;
+    if ((e.target as HTMLElement).closest('.sh3-float-maximize')) return;
     const target = e.currentTarget as HTMLElement;
-    target.setPointerCapture(e.pointerId);
+    target.setPointerCapture?.(e.pointerId);
     dragging = true;
     dragOffset = { x: e.clientX - entry.position.x, y: e.clientY - entry.position.y };
     floatManager.focus(entry.id);
@@ -71,6 +107,11 @@
 
   function onHeaderPointerMove(e: PointerEvent): void {
     if (!dragging) return;
+    // Implicit un-maximize on first drag movement (no-op if not maximized).
+    // We unmaximize on move rather than pointerdown so a casual click —
+    // which precedes a dblclick — does not destroy the saved prev rect
+    // and break the dblclick toggle.
+    floatManager.unmaximize(entry.id);
     entry.position.x = e.clientX - dragOffset.x;
     entry.position.y = e.clientY - dragOffset.y;
   }
@@ -79,7 +120,45 @@
     if (!dragging) return;
     dragging = false;
     const target = e.currentTarget as HTMLElement;
-    if (target.hasPointerCapture(e.pointerId)) {
+    if (target.hasPointerCapture?.(e.pointerId)) {
+      target.releasePointerCapture(e.pointerId);
+    }
+  }
+
+  function onHeaderDblClick(e: MouseEvent): void {
+    if ((e.target as HTMLElement).closest('.sh3-float-close')) return;
+    if ((e.target as HTMLElement).closest('.sh3-float-maximize')) return;
+    floatManager.toggleMaximize(entry.id);
+  }
+
+  function onGripPointerDown(e: PointerEvent): void {
+    if (e.button !== 0) return;
+    e.stopPropagation();
+    const target = e.currentTarget as HTMLElement;
+    target.setPointerCapture?.(e.pointerId);
+    resizing = true;
+    resizeStart = {
+      pointer: { x: e.clientX, y: e.clientY },
+      size: { w: entry.size.w, h: entry.size.h },
+      min: computeMinSize(entry.content),
+    };
+    floatManager.focus(entry.id);
+  }
+
+  function onGripPointerMove(e: PointerEvent): void {
+    if (!resizing) return;
+    floatManager.unmaximize(entry.id);
+    const dx = e.clientX - resizeStart.pointer.x;
+    const dy = e.clientY - resizeStart.pointer.y;
+    entry.size.w = Math.max(resizeStart.min.w, resizeStart.size.w + dx);
+    entry.size.h = Math.max(resizeStart.min.h, resizeStart.size.h + dy);
+  }
+
+  function onGripPointerUp(e: PointerEvent): void {
+    if (!resizing) return;
+    resizing = false;
+    const target = e.currentTarget as HTMLElement;
+    if (target.hasPointerCapture?.(e.pointerId)) {
       target.releasePointerCapture(e.pointerId);
     }
   }
@@ -88,6 +167,11 @@
     floatManager.focus(entry.id);
   }
 
+  function onMaximize(e: MouseEvent): void {
+    e.stopPropagation();
+    floatManager.toggleMaximize(entry.id);
+  }
+
   function onClose(e: MouseEvent): void {
     e.stopPropagation();
     floatManager.close(entry.id);
@@ -113,18 +197,40 @@
     <!-- svelte-ignore a11y_no_static_element_interactions -->
     <header
       class="sh3-float-header"
+      data-sh3-scope="element:float-header"
+      data-float-id={entry.id}
       onpointerdown={onHeaderPointerDown}
       onpointermove={onHeaderPointerMove}
       onpointerup={onHeaderPointerUp}
       onpointercancel={onHeaderPointerUp}
+      ondblclick={onHeaderDblClick}
+      oncontextmenu={openHeaderContextMenu}
     >
       <span class="sh3-float-title">{entry.title}</span>
-      <button class="sh3-float-close" onclick={onClose} aria-label="Close float">×</button>
+      <span class="sh3-float-header-actions">
+        <button
+          class="sh3-float-maximize"
+          onclick={onMaximize}
+          aria-label={isMaximized ? 'Restore float' : 'Maximize float'}
+          aria-pressed={isMaximized}
+        >{isMaximized ? '\u{1F5D7}' : '\u{1F5D6}'}</button>
+        <button class="sh3-float-close" onclick={onClose} aria-label="Close float">×</button>
+      </span>
     </header>
   {/if}
   <div class="sh3-float-body">
     <LayoutRenderer rootRef={{ kind: 'float', floatId: entry.id }} path={[]} />
   </div>
+  <!-- svelte-ignore a11y_no_static_element_interactions -->
+  <div
+    class="sh3-float-resize-grip"
+    role="presentation"
+    aria-hidden="true"
+    onpointerdown={onGripPointerDown}
+    onpointermove={onGripPointerMove}
+    onpointerup={onGripPointerUp}
+    onpointercancel={onGripPointerUp}
+  ></div>
 </div>
 
 <style>
@@ -159,15 +265,26 @@
     text-overflow: ellipsis;
     white-space: nowrap;
   }
+  .sh3-float-header-actions {
+    display: inline-flex;
+    align-items: center;
+    gap: 2px;
+    flex-shrink: 0;
+  }
+  .sh3-float-maximize,
   .sh3-float-close {
     background: transparent;
     border: none;
     color: var(--shell-fg);
-    font-size: 16px;
     line-height: 1;
     cursor: pointer;
     padding: 0 4px;
-    flex-shrink: 0;
+  }
+  .sh3-float-maximize {
+    font-size: 12px;
+  }
+  .sh3-float-close {
+    font-size: 16px;
   }
   .sh3-float-body {
     flex: 1;
@@ -175,4 +292,28 @@
     overflow: hidden;
     min-height: 0;
   }
+  .sh3-float-resize-grip {
+    position: absolute;
+    right: 0;
+    bottom: 0;
+    width: 16px;
+    height: 16px;
+    cursor: nwse-resize;
+    /* Subtle visual hint without being obtrusive — two diagonal lines made
+       from a CSS gradient stripe. */
+    background:
+      linear-gradient(
+        135deg,
+        transparent 0,
+        transparent 6px,
+        var(--shell-border-strong) 6px,
+        var(--shell-border-strong) 7px,
+        transparent 7px,
+        transparent 10px,
+        var(--shell-border-strong) 10px,
+        var(--shell-border-strong) 11px,
+        transparent 11px
+      );
+    border-bottom-right-radius: var(--shell-radius);
+  }
 </style>

package/dist/overlays/FloatFrame.svelte.d.ts

@@ -2,6 +2,6 @@ import type { FloatEntry } from '../layout/types';
 interface Props {
     entry: FloatEntry;
 }
-declare const FloatFrame: import("svelte").Component<Props, {}, "">;
+declare const FloatFrame: import("svelte").Component<Props, {}, "entry">;
 type FloatFrame = ReturnType<typeof FloatFrame>;
 export default FloatFrame;

package/dist/overlays/FloatLayer.svelte

@@ -13,8 +13,8 @@
 </script>
 
 <div class="sh3-float-layer">
-  {#each floats as entry (entry.id)}
-    <FloatFrame {entry} />
+  {#each floats as entry, i (entry.id)}
+    <FloatFrame bind:entry={floats[i]} />
   {/each}
 </div>
 

package/dist/overlays/float.d.ts

@@ -1,4 +1,4 @@
-import type { FloatEntry } from '../layout/types';
+import type { LayoutNode, FloatEntry } from '../layout/types';
 import type { Size } from '../layout/floats';
 export interface FloatOptions {
     title?: string;
@@ -29,9 +29,46 @@ export interface FloatOptions {
 }
 export interface FloatManager {
     open(viewId: string, options?: FloatOptions): string;
+    /**
+     * Open a float with a pre-built content tree. Used by save/restore flows
+     * (e.g. saved layouts) where the caller has already arranged the
+     * structure rather than starting from a single view id. The `content`
+     * tree is stored verbatim — the caller is responsible for cloning if it
+     * shouldn't be aliased to a source.
+     */
+    openWithContent(options: {
+        content: LayoutNode;
+        size: Size;
+        title?: string;
+        position?: {
+            x: number;
+            y: number;
+        };
+    }): string;
     close(floatId: string): void;
     list(): FloatEntry[];
     focus(floatId: string): void;
+    /**
+     * Snapshot the current rect, override with the float layer bounds, and
+     * raise. No-op if the float is already maximized or unknown. Bounds are
+     * frozen at maximize time — shell resize while maximized does not refit.
+     */
+    maximize(floatId: string): void;
+    /**
+     * Roll the rect back to the snapshot taken at maximize time. No-op if
+     * the float was not maximized.
+     */
+    restore(floatId: string): void;
+    /** `isMaximized(id) ? restore(id) : maximize(id)`. */
+    toggleMaximize(floatId: string): void;
+    /**
+     * Forget the saved rect snapshot without rolling back. Used by drag /
+     * resize handlers to "exit maximize but keep the current rect" — distinct
+     * from `restore`, which would snap back. Safe no-op when the float was
+     * not maximized.
+     */
+    unmaximize(floatId: string): void;
+    isMaximized(floatId: string): boolean;
 }
 /**
  * Bind the manager to the active LayoutTree's `floats` array. Called

package/dist/overlays/float.js

@@ -28,6 +28,7 @@
  */
 import { computeMinSize, cascadePosition, generateFloatId } from '../layout/floats';
 import { findEnclosingOverlayHost } from './parentHost';
+import { setMaximizedReactive, readMaximizedReactive, __resetMaximizedReactiveForTest, } from './floatMaximized.svelte';
 // ----- storage binding ---------------------------------------------------
 let fallbackFloats = [];
 let boundFloats = null;
@@ -51,6 +52,8 @@ export function __resetFloatManagerForTest() {
     boundFloats = null;
     getTreeBounds = () => ({ w: 1600, h: 900 });
     parentHosts.clear();
+    maximizedRects.clear();
+    __resetMaximizedReactiveForTest();
 }
 function activeStore() {
     return boundFloats !== null && boundFloats !== void 0 ? boundFloats : fallbackFloats;
@@ -63,6 +66,12 @@ const parentHosts = new Map();
 export function getFloatParentHost(id) {
     return parentHosts.get(id);
 }
+// ----- maximize sidecar --------------------------------------------------
+// Presence in this map ⇒ the float is currently maximized; the value is the
+// rect to restore to. Lives outside FloatEntry so the layout schema doesn't
+// need to bump for an in-memory, non-persisted concern. Reactivity is mirrored
+// into floatMaximized.svelte.ts so Svelte components observe state changes.
+const maximizedRects = new Map();
 // ----- slot id minting ---------------------------------------------------
 let floatSlotCounter = 0;
 function mintFloatSlotId(viewId) {
@@ -128,6 +137,21 @@ function openFloat(viewId, options = {}) {
     store.push(entry);
     return id;
 }
+function openFloatWithContent(options) {
+    var _a;
+    const store = activeStore();
+    const id = generateFloatId();
+    const position = (_a = options.position) !== null && _a !== void 0 ? _a : cascadePosition(store, getTreeBounds());
+    const entry = {
+        id,
+        content: options.content,
+        position,
+        size: options.size,
+        title: options.title,
+    };
+    store.push(entry);
+    return id;
+}
 function closeFloat(floatId) {
     const store = activeStore();
     const idx = store.findIndex((f) => f.id === floatId);
@@ -135,6 +159,8 @@ function closeFloat(floatId) {
         return;
     store.splice(idx, 1);
     parentHosts.delete(floatId);
+    maximizedRects.delete(floatId);
+    setMaximizedReactive(floatId, false);
 }
 function listFloats() {
     // Return a snapshot so callers can iterate without racing mutations.
@@ -148,9 +174,65 @@ function focusFloat(floatId) {
     const [entry] = store.splice(idx, 1);
     store.push(entry);
 }
+function maximizeFloat(id) {
+    if (maximizedRects.has(id))
+        return;
+    const entry = activeStore().find((f) => f.id === id);
+    if (!entry)
+        return;
+    maximizedRects.set(id, {
+        position: { x: entry.position.x, y: entry.position.y },
+        size: { w: entry.size.w, h: entry.size.h },
+    });
+    setMaximizedReactive(id, true);
+    const bounds = getTreeBounds();
+    entry.position.x = 0;
+    entry.position.y = 0;
+    entry.size.w = bounds.w;
+    entry.size.h = bounds.h;
+    focusFloat(id);
+}
+function restoreFloat(id) {
+    const prev = maximizedRects.get(id);
+    if (!prev)
+        return;
+    const entry = activeStore().find((f) => f.id === id);
+    if (!entry) {
+        maximizedRects.delete(id);
+        setMaximizedReactive(id, false);
+        return;
+    }
+    entry.position.x = prev.position.x;
+    entry.position.y = prev.position.y;
+    entry.size.w = prev.size.w;
+    entry.size.h = prev.size.h;
+    maximizedRects.delete(id);
+    setMaximizedReactive(id, false);
+}
+function toggleMaximizeFloat(id) {
+    if (maximizedRects.has(id))
+        restoreFloat(id);
+    else
+        maximizeFloat(id);
+}
+function unmaximizeFloat(id) {
+    if (!maximizedRects.has(id))
+        return;
+    maximizedRects.delete(id);
+    setMaximizedReactive(id, false);
+}
+function isMaximizedFloat(id) {
+    return readMaximizedReactive(id);
+}
 export const floatManager = {
     open: openFloat,
+    openWithContent: openFloatWithContent,
     close: closeFloat,
     list: listFloats,
     focus: focusFloat,
+    maximize: maximizeFloat,
+    restore: restoreFloat,
+    toggleMaximize: toggleMaximizeFloat,
+    unmaximize: unmaximizeFloat,
+    isMaximized: isMaximizedFloat,
 };