@signal9/era-ui 3.17.1 → 4.0.0

package/dist/generated-docs/llms-full.txt

@@ -914,7 +914,7 @@ assign to move the pane programmatically (e.g. reset to 0,0). |
 | `size?` | `{ width: number; height: number } \| null` | `null` | bindable — Explicit pixel size once resized (or a preset). `null` = auto. Bindable. |
 | `resizable?` | `boolean` | `false` | Render a corner grip and allow the pane to be resized. |
 | `title?` | `string` | — | Text shown in the handle bar. For richer chrome use `header`. |
-| `icon?` | `Component<IconProps> \| null` | `AppWindow` | Lucide icon rendered left of the title. Pass `null` to omit. |
+| `icon?` | `Component<IconProps> \| null` | `AppPane` | Lucide icon rendered left of the title. Pass `null` to omit. |
 | `disabled?` | `boolean` | `false` | Disables dragging (reactive). |
 | `plugins?` | `(Plugin \| Compartment)[] \| (() => (Plugin \| Compartment)[])` | `[]` | Extra neodrag plugins (axis, bounds, grid, threshold, …) appended
 after the pane's own. Pass Compartments for reactive plugin sets. |

package/dist/generated-docs/manifest.json

@@ -191,7 +191,7 @@
       "slug": "pane",
       "title": "Pane",
       "summary": "A draggable floating window with a handle bar.",
-      "tokenEstimate": 417,
+      "tokenEstimate": 416,
       "sections": [
         "Import",
         "Props"

package/dist/generated-docs/pane.md

@@ -20,7 +20,7 @@ assign to move the pane programmatically (e.g. reset to 0,0). |
 | `size?` | `{ width: number; height: number } \| null` | `null` | bindable — Explicit pixel size once resized (or a preset). `null` = auto. Bindable. |
 | `resizable?` | `boolean` | `false` | Render a corner grip and allow the pane to be resized. |
 | `title?` | `string` | — | Text shown in the handle bar. For richer chrome use `header`. |
-| `icon?` | `Component<IconProps> \| null` | `AppWindow` | Lucide icon rendered left of the title. Pass `null` to omit. |
+| `icon?` | `Component<IconProps> \| null` | `AppPane` | Lucide icon rendered left of the title. Pass `null` to omit. |
 | `disabled?` | `boolean` | `false` | Disables dragging (reactive). |
 | `plugins?` | `(Plugin \| Compartment)[] \| (() => (Plugin \| Compartment)[])` | `[]` | Extra neodrag plugins (axis, bounds, grid, threshold, …) appended
 after the pane's own. Pass Compartments for reactive plugin sets. |

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './ui/index.js';
 export * as OS from './os/index.js';
 export * as AI from './ai/index.js';
-export type { Point, Size, Rect, Insets, Frame, Workspace, WindowState, JsonValue, WindowSnapshot, WorkspaceSnapshot, SnapZone, AppWindow, AppDefinition, AppComponent, AppProps } from './os/index.js';
+export type { Point, Size, Rect, Insets, Frame, Workspace, PaneState, JsonValue, PaneSnapshot, WorkspaceSnapshot, SnapZone, AppPane, AppDefinition, AppComponent, AppProps } from './os/index.js';
+export { PaneManager, SNAPSHOT_VERSION, readSnapshot, persistWorkspace, loadWorkspace, saveWorkspace, clearWorkspace, WORKSPACE_STORAGE_KEY } from './os/index.js';
 export { cn, tv, hotkeys, keys, parseKeybinding, matchKeyBindingPress, createKeybindingsHandler, formatKeybinding, isApplePlatform, modKey, type KeyBindingMap, type KeyBindingPress, type KeyBindingOptions, type PartProps, type VariantProps } from './utils/index.js';

package/dist/index.js

@@ -1,4 +1,9 @@
 export * from './ui/index.js';
 export * as OS from './os/index.js';
 export * as AI from './ai/index.js';
+// The snapshot + persistence API, flat for the same reason: saving and restoring
+// a desktop is a first-class thing consumers do, not an OS-namespace detail.
+// PaneManager comes with them because it is what every one of these functions
+// takes — without it the flat surface cannot type its own arguments.
+export { PaneManager, SNAPSHOT_VERSION, readSnapshot, persistWorkspace, loadWorkspace, saveWorkspace, clearWorkspace, WORKSPACE_STORAGE_KEY } from './os/index.js';
 export { cn, tv, hotkeys, keys, parseKeybinding, matchKeyBindingPress, createKeybindingsHandler, formatKeybinding, isApplePlatform, modKey } from './utils/index.js';

package/dist/os/desktop.svelte

@@ -2,20 +2,20 @@
 	import { untrack, type Snippet } from 'svelte';
 	import type { HTMLAttributes } from 'svelte/elements';
 	import { cn } from '../utils/index.js';
-	import { WindowManager, setWindowManagerContext } from './wm.svelte.js';
+	import { PaneManager, setPaneManagerContext } from './pane-manager.svelte.js';
 	import { NotificationService, setNotificationContext } from './notifications.svelte.js';
-	import Window from './window.svelte';
+	import Pane from './pane.svelte';
 
 	let {
-		wm: wmProp,
+		pm: wmProp,
 		notifications: notifProp,
 		children,
 		class: className,
 		...restProps
 	}: HTMLAttributes<HTMLDivElement> & {
-		/** The window store. Pass your own to drive it from outside, or let the
+		/** The pane store. Pass your own to drive it from outside, or let the
 		 *  Desktop own one. Exposed via context to every descendant. */
-		wm?: WindowManager;
+		pm?: PaneManager;
 		/** The notification service, likewise shared via context. */
 		notifications?: NotificationService;
 		/** Chrome + wallpaper: place <Taskbar>, <Toaster>, <Launcher>,
@@ -25,10 +25,10 @@
 
 	// The stores are stable singletons for this desktop — read the prop once (or
 	// mint a default; untrack makes the one-time read explicit). Set into context
-	// so every window/chrome descendant shares it.
-	const wm = untrack(() => wmProp) ?? new WindowManager();
+	// so every pane/chrome descendant shares it.
+	const pm = untrack(() => wmProp) ?? new PaneManager();
 	const notifications = untrack(() => notifProp) ?? new NotificationService();
-	setWindowManagerContext(wm);
+	setPaneManagerContext(pm);
 	setNotificationContext(notifications);
 
 	// Feed the live viewport size to the store so maximize / snap have real bounds.
@@ -36,17 +36,17 @@
 	let h = $state(0);
 	let ref = $state<HTMLDivElement | null>(null);
 
-	// Selection containment: a text drag that starts in one window must never
+	// Selection containment: a text drag that starts in one pane must never
 	// bleed into its neighbours — while the primary button is down, every
-	// OTHER window goes user-select:none, restored on release. The browser has
+	// OTHER pane goes user-select:none, restored on release. The browser has
 	// no cross-window selection fence (user-select: contain never shipped), so
 	// this is the whole mechanism.
 	function containSelection(e: PointerEvent) {
 		if (e.button !== 0 || !ref) return;
-		const origin = (e.target as Element | null)?.closest?.('[data-window]');
+		const origin = (e.target as Element | null)?.closest?.('[data-pane]');
 		if (!origin) return;
 		const muted: HTMLElement[] = [];
-		for (const el of ref.querySelectorAll<HTMLElement>('[data-window]')) {
+		for (const el of ref.querySelectorAll<HTMLElement>('[data-pane]')) {
 			if (el !== origin) {
 				el.style.userSelect = 'none';
 				muted.push(el);
@@ -59,13 +59,13 @@
 		window.addEventListener('pointercancel', release, { once: true });
 	}
 	$effect(() => {
-		wm.bounds = { width: w, height: h };
+		pm.bounds = { width: w, height: h };
 	});
-	// Viewport/chrome resizes re-fit the windows (untracked: relayout reads
-	// window state we must not subscribe to, or every drag would re-run this).
+	// Viewport/chrome resizes re-fit the panes (untracked: relayout reads
+	// pane state we must not subscribe to, or every drag would re-run this).
 	$effect(() => {
-		void wm.workArea;
-		untrack(() => wm.relayout());
+		void pm.workArea;
+		untrack(() => pm.relayout());
 	});
 
 	// Document scroll lock: the Desktop IS the viewport, so the page itself must
@@ -73,7 +73,7 @@
 	// whole workspace around, which is meaningless for a fixed surface. Lock
 	// <html>/<body> for the Desktop's lifetime and restore their prior inline
 	// values on unmount, so a consumer's ordinary page is untouched before and
-	// after the workspace mounts. Scrolling INSIDE windows and menus is unaffected
+	// after the workspace mounts. Scrolling INSIDE panes and menus is unaffected
 	// — those are their own overflow-auto containers with overscroll-behavior.
 	// overscroll-behavior:none is the specific killer for iOS pull-to-refresh and
 	// the elastic bounce; overflow:hidden + height stop any residual page scroll.
@@ -90,10 +90,10 @@
 
 	// Pinch-zoom fence: the workspace is a native-app-like surface, so a
 	// two-finger pinch must NOT zoom the whole document (which would scale the
-	// chrome away and strand windows). Safari fires non-standard gesture* events
+	// chrome away and strand panes). Safari fires non-standard gesture* events
 	// for pinch/rotate; other engines surface it as a multi-touch touchmove.
 	// Cancel both — non-passive, so preventDefault actually stops the gesture.
-	// (Single-finger window dragging runs on pointer events and is unaffected; the
+	// (Single-finger pane dragging runs on pointer events and is unaffected; the
 	// page can't scroll anyway now, see the scroll lock above.)
 	$effect(() => {
 		const el = ref;
@@ -124,16 +124,16 @@
 	class={cn('relative h-full w-full overflow-hidden overscroll-none bg-(--color-1)', className)}
 	{...restProps}
 >
-	<!-- Window layer: an isolated stacking context. Every window's z-index (handed
-	     out by the WindowManager) is trapped in here, so no window can ever paint
+	<!-- Pane layer: an isolated stacking context. Every pane's z-index (handed
+	     out by the PaneManager) is trapped in here, so no pane can ever paint
 	     over the chrome / menus / toasts / launcher that render below (outside it)
 	     at the document root. This is the whole layer contract in one line. -->
 	<div class="absolute inset-0 isolate">
-		<!-- Only the active workspace paints; other workspaces' windows keep
+		<!-- Only the active workspace paints; other workspaces' panes keep
 		     their state untouched and simply aren't in the tree. Keyed by id, so
 		     switching back remounts them exactly where they were. -->
-		{#each wm.activeWindows as win (win.id)}
-			<Window window={win} />
+		{#each pm.activePanes as pane (pane.id)}
+			<Pane {pane} />
 		{/each}
 	</div>
 	{@render children?.()}

package/dist/os/desktop.svelte.d.ts

@@ -1,11 +1,11 @@
 import { type Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
-import { WindowManager } from './wm.svelte.js';
+import { PaneManager } from './pane-manager.svelte.js';
 import { NotificationService } from './notifications.svelte.js';
 type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
-    /** The window store. Pass your own to drive it from outside, or let the
+    /** The pane store. Pass your own to drive it from outside, or let the
      *  Desktop own one. Exposed via context to every descendant. */
-    wm?: WindowManager;
+    pm?: PaneManager;
     /** The notification service, likewise shared via context. */
     notifications?: NotificationService;
     /** Chrome + wallpaper: place <Taskbar>, <Toaster>, <Launcher>,

package/dist/os/index.d.ts

@@ -1,10 +1,10 @@
-export { WindowManager, getWindowManager, setWindowManagerContext, type Point, type Size, type Rect, type Insets, type Frame, type AppDefinition, type AppWindow, type AppComponent, type AppProps, type WindowState, type JsonValue, type WindowSnapshot, type WorkspaceSnapshot, SNAPSHOT_VERSION, readSnapshot } from './wm.svelte.js';
+export { PaneManager, getPaneManager, setPaneManagerContext, type Point, type Size, type Rect, type Insets, type Frame, type AppDefinition, type AppPane, type AppComponent, type AppProps, type PaneState, type JsonValue, type PaneSnapshot, type WorkspaceSnapshot, SNAPSHOT_VERSION, readSnapshot } from './pane-manager.svelte.js';
 export { persistWorkspace, loadWorkspace, saveWorkspace, clearWorkspace, WORKSPACE_STORAGE_KEY } from './workspace-storage.svelte.js';
-export { type SnapZone, type Workspace } from './wm.svelte.js';
+export { type SnapZone, type Workspace } from './pane-manager.svelte.js';
 export { NotificationService, getNotifications, setNotificationContext, type AppNotification, type NotifyOptions, type NotificationAction, type NotificationTone } from './notifications.svelte.js';
 export { LAYER } from './layers.js';
 export { default as Desktop } from './desktop.svelte';
-export { default as Window } from './window.svelte';
+export { default as Pane } from './pane.svelte';
 export { default as Taskbar } from './taskbar.svelte';
 export { default as Toaster } from './toaster.svelte';
 export { default as Toast } from './toast.svelte';

package/dist/os/index.js

@@ -1,14 +1,14 @@
 // The OS shell layer — stateful orchestration on top of the ui/ widgets.
-// Two stores (window manager + notifications) shared via context, and the
-// components that render them: Desktop host, Window, Taskbar (with its
+// Two stores (pane manager + notifications) shared via context, and the
+// components that render them: Desktop host, Pane, Taskbar (with its
 // built-in command bar), Toaster, NotificationCenter.
-export { WindowManager, getWindowManager, setWindowManagerContext, SNAPSHOT_VERSION, readSnapshot } from './wm.svelte.js';
+export { PaneManager, getPaneManager, setPaneManagerContext, SNAPSHOT_VERSION, readSnapshot } from './pane-manager.svelte.js';
 export { persistWorkspace, loadWorkspace, saveWorkspace, clearWorkspace, WORKSPACE_STORAGE_KEY } from './workspace-storage.svelte.js';
-export {} from './wm.svelte.js';
+export {} from './pane-manager.svelte.js';
 export { NotificationService, getNotifications, setNotificationContext } from './notifications.svelte.js';
 export { LAYER } from './layers.js';
 export { default as Desktop } from './desktop.svelte';
-export { default as Window } from './window.svelte';
+export { default as Pane } from './pane.svelte';
 export { default as Taskbar } from './taskbar.svelte';
 export { default as Toaster } from './toaster.svelte';
 export { default as Toast } from './toast.svelte';

package/dist/os/layers.d.ts

@@ -1,13 +1,13 @@
 /**
  * The layer contract for the OS shell.
  *
- * The hard rule desktop UIs get wrong: a window's z-index must NEVER be able to
+ * The hard rule desktop UIs get wrong: a pane's z-index must NEVER be able to
  * cover a menu, toast, or the taskbar's command dropdown. We guarantee that structurally rather
  * than by juggling numbers — the `Desktop` surface is an isolated stacking
- * context (`isolate`), so every window's z-index (1..N, handed out by the
- * WindowManager) is *contained* within it. OS chrome and portalled overlays
+ * context (`isolate`), so every pane's z-index (1..N, handed out by the
+ * PaneManager) is *contained* within it. OS chrome and portalled overlays
  * render OUTSIDE that context, at the document root, so they always paint above
- * the entire desktop no matter how high a window's z climbs.
+ * the entire desktop no matter how high a pane's z climbs.
  *
  * These are the root-level tiers (all above the isolated desktop). bits-ui
  * dialogs/menus/tooltips portal to <body> at z-50; the tiers below are chosen

package/dist/os/layers.js

@@ -1,13 +1,13 @@
 /**
  * The layer contract for the OS shell.
  *
- * The hard rule desktop UIs get wrong: a window's z-index must NEVER be able to
+ * The hard rule desktop UIs get wrong: a pane's z-index must NEVER be able to
  * cover a menu, toast, or the taskbar's command dropdown. We guarantee that structurally rather
  * than by juggling numbers — the `Desktop` surface is an isolated stacking
- * context (`isolate`), so every window's z-index (1..N, handed out by the
- * WindowManager) is *contained* within it. OS chrome and portalled overlays
+ * context (`isolate`), so every pane's z-index (1..N, handed out by the
+ * PaneManager) is *contained* within it. OS chrome and portalled overlays
  * render OUTSIDE that context, at the document root, so they always paint above
- * the entire desktop no matter how high a window's z climbs.
+ * the entire desktop no matter how high a pane's z climbs.
  *
  * These are the root-level tiers (all above the isolated desktop). bits-ui
  * dialogs/menus/tooltips portal to <body> at z-50; the tiers below are chosen

package/dist/os/notification-center.svelte

@@ -5,12 +5,12 @@
 	import BellOff from '@lucide/svelte/icons/bell-off';
 	import { cn } from '../utils/index.js';
 	import { getNotifications, type AppNotification } from './notifications.svelte.js';
-	import { getWindowManager } from './wm.svelte.js';
+	import { getPaneManager } from './pane-manager.svelte.js';
 	import { LAYER } from './layers.js';
 
 	let { open = $bindable(false) }: { open?: boolean } = $props();
 	const notif = getNotifications();
-	const wm = getWindowManager();
+	const pm = getPaneManager();
 
 	const accent: Record<AppNotification['tone'], string> = {
 		default: 'bg-(--era-highlight)',
@@ -46,8 +46,8 @@
 		     it down, a bottom one stops it short — so it never slides under a bar. -->
 		<aside
 			transition:eraFly={{ x: 320, duration: 200 }}
-			style:top="{wm.insets.top}px"
-			style:bottom="{wm.insets.bottom}px"
+			style:top="{pm.insets.top}px"
+			style:bottom="{pm.insets.bottom}px"
 			class="absolute right-0 flex w-80 flex-col border-l border-divider-faded bg-(--era-surface-bg) shadow-(--era-shadow-lg) glass-blur"
 		>
 			<header

package/dist/os/{wm.svelte.d.ts → pane-manager.svelte.d.ts}

@@ -20,8 +20,8 @@ export interface Insets {
     bottom: number;
     left: number;
 }
-/** A window's placement: where it sits, and its explicit size once one has
- *  been set (`null` = auto — the window is content-sized until the user or a
+/** A pane's placement: where it sits, and its explicit size once one has
+ *  been set (`null` = auto — the pane is content-sized until the user or a
  *  preset gives it real dimensions, so we never invent numbers). */
 export interface Frame {
     pos: Point;
@@ -50,26 +50,26 @@ export type JsonValue = string | number | boolean | null | JsonValue[] | {
  */
 export declare const SNAPSHOT_VERSION = 1;
 /**
- * One window, reduced to what a reload cannot reconstruct.
+ * One pane, reduced to what a reload cannot reconstruct.
  *
- * Deliberately NOT a partial AppWindow. A live window holds a `component` and an
+ * Deliberately NOT a partial AppPane. A live pane holds a `component` and an
  * `icon`, which are functions; those come from the app registry and are looked
  * up again on restore by `appId`. Storing an id instead of a reference is also
  * what lets a snapshot outlive a refactor of the app itself.
  */
-export interface WindowSnapshot {
-    /** The registered app this window rehydrates from. */
+export interface PaneSnapshot {
+    /** The registered app this pane rehydrates from. */
     appId: string;
     /** The workspace it belongs to. */
     workspaceId: string;
     /** Placement when `state` is 'normal'. */
     frame: Frame;
-    state: WindowState;
+    state: PaneState;
     /** Where to land on un-maximize / un-snap; null if it was never moved. */
     restore: Frame | null;
     /** Stacking order within its workspace. */
     z: number;
-    /** Only when the window was retitled away from its app's default. */
+    /** Only when the pane was retitled away from its app's default. */
     title?: string;
     /**
      * App-specific state — the note being edited, a scroll offset, a filter.
@@ -92,7 +92,7 @@ export interface WorkspaceSnapshot {
     savedAt: number;
     activeWorkspaceId: string;
     workspaces: Workspace[];
-    windows: WindowSnapshot[];
+    panes: PaneSnapshot[];
 }
 /**
  * Parse untrusted JSON into a snapshot, or return null.
@@ -103,28 +103,28 @@ export interface WorkspaceSnapshot {
  * trusting `as`, and refuses an unknown `version` outright — silently importing
  * a layout you only half understand is worse than declining it.
  *
- * Individual windows are filtered, not fatal: one malformed entry should not
+ * Individual panes are filtered, not fatal: one malformed entry should not
  * cost the user the rest of the layout. applySnapshot() drops unknown appIds the
  * same way, for the same reason.
  */
 export declare function readSnapshot(json: string): WorkspaceSnapshot | null;
-export type WindowState = 'normal' | 'minimized' | 'maximized';
+export type PaneState = 'normal' | 'minimized' | 'maximized';
 /** Snap targets: the four edges (halves) or four corners (quadrants). */
 export type SnapZone = 'left' | 'right' | 'top' | 'bottom' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
-/** Props every app body receives — its own window record and the manager, so it
+/** Props every app body receives — its own pane record and the manager, so it
  *  can read its state and drive the desktop (close itself, spawn more…). */
 export type AppProps = {
-    window: AppWindow;
-    wm: WindowManager;
+    pane: AppPane;
+    pm: PaneManager;
 };
-/** What a window renders as its body. */
+/** What a pane renders as its body. */
 export type AppComponent = Component<AppProps>;
-/** A registered "app": the template every window of that app is spawned from. */
+/** A registered "app": the template every pane of that app is spawned from. */
 export interface AppDefinition {
     id: string;
     title: string;
     icon?: Component<IconProps> | null;
-    /** Body renderer. Omit for a chromeless/placeholder window. */
+    /** Body renderer. Omit for a chromeless/placeholder pane. */
     component?: AppComponent;
     defaultSize?: Size;
     /** Only one live instance; opening again focuses the existing one. */
@@ -135,27 +135,27 @@ export interface AppDefinition {
      *  × gesture won't arm it and taskbar tabs only focus — minimize() and
      *  toggleMinimize() become focus-only no-ops. */
     minimizable?: boolean;
-    /** Extra classes for the window body (Pane.Content) — e.g. `p-(--era-gap)`
+    /** Extra classes for the pane body (Pane.Content) — e.g. `p-(--era-gap)`
      *  for a body of controls, or `p-0` for a full-bleed app. */
     bodyClass?: string;
     /**
-     * Starting app state for every window spawned from this app — the value a
-     * window carries in its snapshot's `props`. An app reads it back off
+     * Starting app state for every pane spawned from this app — the value a
+     * pane carries in its snapshot's `props`. An app reads it back off
      * `window.props` (AppProps hands the whole record over).
      */
     props?: JsonValue;
     /** Extra title-bar controls, rendered immediately LEFT of the close button.
      *  For per-window affordances that belong on the chrome rather than in the
      *  body — a help/usage launcher, a pin, a view toggle. Assignable on the
-     *  live AppWindow too, so a host can swap it as the window's content
+     *  live AppPane too, so a host can swap it as the pane's content
      *  changes. */
     actions?: Snippet;
 }
-/** A live window instance in the registry. */
-export interface AppWindow {
+/** A live pane instance in the registry. */
+export interface AppPane {
     id: string;
     appId: string;
-    /** The workspace this window lives on. */
+    /** The workspace this pane lives on. */
     workspaceId: string;
     title: string;
     icon?: Component<IconProps> | null;
@@ -165,7 +165,7 @@ export interface AppWindow {
     size: Size | null;
     /** Stacking order within the desktop (higher = nearer the front). */
     z: number;
-    state: WindowState;
+    state: PaneState;
     /** Frame snapshot to restore to after un-maximize / un-snap. */
     restore: Frame | null;
     component?: AppComponent;
@@ -176,24 +176,24 @@ export interface AppWindow {
     /** App-specific state, carried verbatim through a snapshot. */
     props?: JsonValue;
 }
-/** A named virtual desktop. Every window belongs to exactly one; only the
- *  active workspace's windows are shown, the rest keep their geometry and
+/** A named virtual desktop. Every pane belongs to exactly one; only the
+ *  active workspace's panes are shown, the rest keep their geometry and
  *  stacking untouched until switched back to. */
 export interface Workspace {
     id: string;
     name: string;
 }
 /**
- * The source of truth for the desktop: which workspaces and windows exist,
+ * The source of truth for the desktop: which workspaces and panes exist,
  * their geometry, and their stacking / focus order. Everything visual
- * (Desktop, Window, Taskbar, Launcher, …) is a pure view of this. Runes-based,
+ * (Desktop, Pane, Taskbar, Launcher, …) is a pure view of this. Runes-based,
  * shared via context.
  */
-export declare class WindowManager {
+export declare class PaneManager {
     #private;
-    /** Every live window, across all workspaces. Order is spawn order; paint
+    /** Every live pane, across all workspaces. Order is spawn order; paint
      *  order is by `z`; visibility is by workspace. */
-    windows: AppWindow[];
+    panes: AppPane[];
     /** Registered app templates, keyed by id. */
     apps: Record<string, AppDefinition>;
     /** The virtual desktops. Always at least one. */
@@ -206,42 +206,42 @@ export declare class WindowManager {
      *  The work area = bounds − insets; maximize, snap and drag containment
      *  honour it. */
     insets: Insets;
-    /** Drag containment: a window's bar may never leave the top of the work
+    /** Drag containment: a pane's bar may never leave the top of the work
      *  area, and at least this many px of it must stay reachable on every
      *  other side. */
     dragKeep: number;
     /** The usable desktop: bounds minus reserved chrome. Everything that places
-     *  a window against "the screen" (maximize, snap, containment) uses this,
+     *  a pane against "the screen" (maximize, snap, containment) uses this,
      *  never raw bounds — a strip hidden behind chrome is as lost as one
      *  off-screen. */
     workArea: Rect;
-    /** The active workspace's windows — what the Desktop paints and the
+    /** The active workspace's panes — what the Desktop paints and the
      *  Taskbar lists. */
-    activeWindows: AppWindow[];
-    /** The focused window = the top-most non-minimized one on the active
+    activePanes: AppPane[];
+    /** The focused pane = the top-most non-minimized one on the active
      *  workspace. */
     focusedId: string | null;
     register(app: AppDefinition): void;
     registerMany(apps: AppDefinition[]): void;
-    /** Spawn a window for an app (or focus the existing one if it's a
+    /** Spawn a pane for an app (or focus the existing one if it's a
      *  singleton — from any workspace; it is brought to the active one). */
-    open(appId: string, overrides?: Partial<Pick<AppWindow, 'title' | 'pos' | 'size' | 'resizable' | 'workspaceId'>>): string | null;
+    open(appId: string, overrides?: Partial<Pick<AppPane, 'title' | 'pos' | 'size' | 'resizable' | 'workspaceId'>>): string | null;
     close(id: string): void;
-    /** Make a window the frontmost VISIBLE one: switch to its workspace,
+    /** Make a pane the frontmost VISIBLE one: switch to its workspace,
      *  un-minimize it, and bring it to the front. Focus means reveal at every
      *  level — never a silent off-screen z bump. */
     focus(id: string): void;
     minimize(id: string): void;
     /** Taskbar behaviour: focus if not focused, else minimize; restore if minimized. */
     toggleMinimize(id: string): void;
-    /** Fill the work area (middle-click on the window's ×). Keeps the first
+    /** Fill the work area (middle-click on the pane's ×). Keeps the first
      *  pre-maximize/pre-snap frame so restore returns to the true origin. */
     maximize(id: string): void;
     toggleMaximize(id: string): void;
     /** Un-maximize / un-snap back to the pre-change frame (or just un-minimize). */
     restore(id: string): void;
-    /** Re-fit windows after the desktop or its chrome resizes: maximized
-     *  windows re-fill the work area; normal windows re-clamp so the bar stays
+    /** Re-fit panes after the desktop or its chrome resizes: maximized
+     *  panes re-fill the work area; normal panes re-clamp so the bar stays
      *  below the top and at least dragKeep px stays reachable on every other
      *  side — the same fence the drag containment enforces, applied at rest.
      *  The Desktop calls this whenever the work area changes; chrome itself
@@ -250,7 +250,7 @@ export declare class WindowManager {
     /**
      * The whole desktop as one JSON-safe document.
      *
-     * Reads every workspace and every window across ALL of them, not just the
+     * Reads every workspace and every pane across ALL of them, not just the
      * active one — a snapshot that only captured what was on screen would quietly
      * drop the other workspaces the moment it was restored.
      */
@@ -259,11 +259,11 @@ export declare class WindowManager {
      * Replace the desktop with a snapshot.
      *
      * Named applySnapshot, not restore: `restore(id)` already means "un-maximize
-     * this window", and one verb cannot mean both.
+     * this pane", and one verb cannot mean both.
      *
      * Windows whose `appId` is no longer registered are SKIPPED rather than
      * failing the whole restore: an app can be removed between export and import,
-     * and losing one window beats losing the layout. Same for a window pointing at
+     * and losing one pane beats losing the layout. Same for a pane pointing at
      * a workspace the snapshot does not contain.
      */
     applySnapshot(snapshot: WorkspaceSnapshot): void;
@@ -275,12 +275,12 @@ export declare class WindowManager {
     }): string;
     /** Show a workspace. Windows on others keep their geometry and stacking. */
     switchWorkspace(id: string): void;
-    /** Remove a workspace. Its windows migrate to the fallback (the active
+    /** Remove a workspace. Its panes migrate to the fallback (the active
      *  workspace, or the first remaining one) — closing a desktop never
      *  silently closes the work on it. The last workspace can't be removed. */
     removeWorkspace(id: string): void;
-    /** Send a window to another workspace (it stays where it was on screen). */
+    /** Send a pane to another workspace (it stays where it was on screen). */
     moveToWorkspace(windowId: string, workspaceId: string): void;
 }
-export declare function setWindowManagerContext(wm: WindowManager): WindowManager;
-export declare function getWindowManager(): WindowManager;
+export declare function setPaneManagerContext(pm: PaneManager): PaneManager;
+export declare function getPaneManager(): PaneManager;