@signal9/era-ui 3.17.0 → 4.0.0

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

@@ -14,7 +14,7 @@ export const SNAPSHOT_VERSION = 1;
  * 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.
  */
@@ -33,7 +33,7 @@ export function readSnapshot(json) {
         return null;
     if (typeof o.activeWorkspaceId !== 'string')
         return null;
-    if (!Array.isArray(o.workspaces) || !Array.isArray(o.windows))
+    if (!Array.isArray(o.workspaces) || !Array.isArray(o.panes))
         return null;
     const isPoint = (v) => typeof v === 'object' &&
         v !== null &&
@@ -56,7 +56,7 @@ export function readSnapshot(json) {
     if (workspaces.length === 0)
         return null;
     const states = ['normal', 'minimized', 'maximized'];
-    const windows = o.windows.filter((w) => {
+    const panes = o.panes.filter((w) => {
         if (typeof w !== 'object' || w === null)
             return false;
         const x = w;
@@ -72,20 +72,20 @@ export function readSnapshot(json) {
         savedAt: typeof o.savedAt === 'number' ? o.savedAt : 0,
         activeWorkspaceId: o.activeWorkspaceId,
         workspaces,
-        windows
+        panes
     };
 }
 const DEFAULT_SIZE = { width: 480, height: 320 };
 /**
- * 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 class WindowManager {
-    /** Every live window, across all workspaces. Order is spawn order; paint
+export class PaneManager {
+    /** Every live pane, across all workspaces. Order is spawn order; paint
      *  order is by `z`; visibility is by workspace. */
-    windows = $state([]);
+    panes = $state([]);
     /** Registered app templates, keyed by id. */
     apps = $state.raw({});
     /** The virtual desktops. Always at least one. */
@@ -98,7 +98,7 @@ export class WindowManager {
      *  The work area = bounds − insets; maximize, snap and drag containment
      *  honour it. */
     insets = $state({ top: 0, right: 0, bottom: 0, left: 0 });
-    /** 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 = 25;
@@ -106,7 +106,7 @@ export class WindowManager {
     #seq = 0;
     #wsSeq = 0;
     /** 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 = $derived.by(() => {
@@ -118,14 +118,14 @@ export class WindowManager {
             height: Math.max(0, this.bounds.height - top - bottom)
         };
     });
-    /** 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 = $derived.by(() => this.windows.filter((w) => w.workspaceId === this.activeWorkspaceId));
-    /** The focused window = the top-most non-minimized one on the active
+    activePanes = $derived.by(() => this.panes.filter((w) => w.workspaceId === this.activeWorkspaceId));
+    /** The focused pane = the top-most non-minimized one on the active
      *  workspace. */
     focusedId = $derived.by(() => {
         let top = null;
-        for (const w of this.activeWindows) {
+        for (const w of this.activePanes) {
             if (w.state === 'minimized')
                 continue;
             if (!top || w.z > top.z)
@@ -141,20 +141,20 @@ export class WindowManager {
         this.apps = { ...this.apps, ...Object.fromEntries(apps.map((a) => [a.id, a])) };
     }
     #find(id) {
-        return this.windows.find((w) => w.id === id);
+        return this.panes.find((w) => w.id === id);
     }
-    /* ---------------- windows ---------------- */
-    /** Spawn a window for an app (or focus the existing one if it's a
+    /* ---------------- panes ---------------- */
+    /** 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, overrides) {
         const app = this.apps[appId];
         if (!app)
             return null;
         if (app.singleton) {
-            const existing = this.windows.find((w) => w.appId === appId);
+            const existing = this.panes.find((w) => w.appId === appId);
             if (existing) {
                 // Reveal, don't relocate: restore() → focus() switches to the
-                // workspace the window already lives on, the way every virtual
+                // workspace the pane already lives on, the way every virtual
                 // desktop behaves. An explicit override still moves it.
                 if (overrides?.workspaceId)
                     existing.workspaceId = overrides.workspaceId;
@@ -165,7 +165,7 @@ export class WindowManager {
         const id = `${appId}#${++this.#seq}`;
         // Cascade from the work area's origin so stacked spawns don't land
         // exactly on top of each other (or under top chrome).
-        const n = this.windows.length % 8;
+        const n = this.panes.length % 8;
         const { x, y } = this.workArea;
         const win = {
             id,
@@ -185,13 +185,13 @@ export class WindowManager {
             actions: app.actions,
             props: app.props
         };
-        this.windows.push(win);
+        this.panes.push(win);
         return id;
     }
     close(id) {
-        this.windows = this.windows.filter((w) => w.id !== id);
+        this.panes = this.panes.filter((w) => w.id !== id);
     }
-    /** 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) {
@@ -222,7 +222,7 @@ export class WindowManager {
         else
             this.focus(id);
     }
-    /** 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) {
         const w = this.#find(id);
@@ -258,8 +258,8 @@ export class WindowManager {
         w.state = 'normal';
         this.focus(id);
     }
-    /** 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
@@ -268,7 +268,7 @@ export class WindowManager {
         const { x, y, width, height } = this.workArea;
         if (!width || !height)
             return;
-        for (const w of this.windows) {
+        for (const w of this.panes) {
             if (w.state === 'maximized') {
                 w.pos = { x, y };
                 w.size = { width, height };
@@ -288,7 +288,7 @@ export 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.
      */
@@ -298,7 +298,7 @@ export class WindowManager {
             savedAt: Date.now(),
             activeWorkspaceId: this.activeWorkspaceId,
             workspaces: this.workspaces.map((w) => ({ ...w })),
-            windows: this.windows.map((w) => {
+            panes: this.panes.map((w) => {
                 const app = this.apps[w.appId];
                 const snap = {
                     appId: w.appId,
@@ -312,7 +312,7 @@ export class WindowManager {
                 };
                 // Only record a title the user changed. Storing the app's own default
                 // would pin it, so renaming the app in code would not reach any
-                // window restored from an older snapshot.
+                // pane restored from an older snapshot.
                 if (app && w.title !== app.title)
                     snap.title = w.title;
                 if (w.props !== undefined)
@@ -325,15 +325,15 @@ export 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) {
-        this.windows = [];
+        this.panes = [];
         this.workspaces = snapshot.workspaces.map((w) => ({ ...w }));
         if (this.workspaces.length === 0)
             this.workspaces = [{ id: 'w1', name: '1' }];
@@ -344,11 +344,11 @@ export class WindowManager {
             ? snapshot.activeWorkspaceId
             : this.workspaces[0].id;
         let z = 0;
-        for (const s of snapshot.windows) {
+        for (const s of snapshot.panes) {
             const app = this.apps[s.appId];
             if (!app || !known.includes(s.workspaceId))
                 continue;
-            this.windows.push({
+            this.panes.push({
                 id: `${s.appId}#${++this.#seq}`,
                 appId: s.appId,
                 workspaceId: s.workspaceId,
@@ -368,7 +368,7 @@ export class WindowManager {
             });
         }
         this.#z = z;
-        this.focusedId = this.activeWindows.at(-1)?.id ?? null;
+        this.focusedId = this.activePanes.at(-1)?.id ?? null;
     }
     /** Half / quadrant tiling against the work area. */
     snap(id, zone) {
@@ -411,7 +411,7 @@ export class WindowManager {
         if (this.workspaces.some((ws) => ws.id === id))
             this.activeWorkspaceId = id;
     }
-    /** 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) {
@@ -420,12 +420,12 @@ export class WindowManager {
         this.workspaces = this.workspaces.filter((ws) => ws.id !== id);
         if (this.activeWorkspaceId === id)
             this.activeWorkspaceId = this.workspaces[0].id;
-        for (const w of this.windows) {
+        for (const w of this.panes) {
             if (w.workspaceId === id)
                 w.workspaceId = this.activeWorkspaceId;
         }
     }
-    /** 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, workspaceId) {
         const w = this.#find(windowId);
         if (!w || !this.workspaces.some((ws) => ws.id === workspaceId))
@@ -433,14 +433,14 @@ export class WindowManager {
         w.workspaceId = workspaceId;
     }
 }
-const WM_KEY = Symbol('era-wm');
-export function setWindowManagerContext(wm) {
-    setContext(WM_KEY, wm);
-    return wm;
+const PM_KEY = Symbol('era-pm');
+export function setPaneManagerContext(pm) {
+    setContext(PM_KEY, pm);
+    return pm;
 }
-export function getWindowManager() {
-    const wm = getContext(WM_KEY);
-    if (!wm)
-        throw new Error('getWindowManager() must be used inside a <Desktop>.');
-    return wm;
+export function getPaneManager() {
+    const pm = getContext(PM_KEY);
+    if (!pm)
+        throw new Error('getPaneManager() must be used inside a <Desktop>.');
+    return pm;
 }

package/dist/os/{window.svelte → pane.svelte}

@@ -6,16 +6,16 @@
 	import X from '@lucide/svelte/icons/x';
 	import type { Plugin } from '@neodrag/svelte';
 	import { cn } from '../utils/index.js';
-	import { getWindowManager, type AppWindow } from './wm.svelte.js';
+	import { getPaneManager, type AppPane } from './pane-manager.svelte.js';
 
-	let { window: win }: { window: AppWindow } = $props();
+	let { pane }: { pane: AppPane } = $props();
 
-	const wm = getWindowManager();
-	const focused = $derived(wm.focusedId === win.id);
+	const pm = getPaneManager();
+	const focused = $derived(pm.focusedId === pane.id);
 
-	// Shell containment: a window can never become unrecoverable. The bar may
+	// Shell containment: a pane can never become unrecoverable. The bar may
 	// not leave the TOP of the work area at all (y ≥ workArea.y), and on every
-	// other side at least wm.dragKeep px of the window must stay inside the
+	// other side at least pm.dragKeep px of the pane must stay inside the
 	// work area (which excludes chrome — a strip hidden behind the taskbar
 	// would be just as lost). Clamped mid-drag the way neodrag's own bounds
 	// plugin does it: offset + proposed delta → clamp → re-propose the delta,
@@ -26,9 +26,9 @@
 	const shellClamp: Plugin = {
 		name: 'era:shell-clamp',
 		drag(ctx) {
-			const area = wm.workArea;
+			const area = pm.workArea;
 			if (!area.width || !area.height) return;
-			const keep = wm.dragKeep;
+			const keep = pm.dragKeep;
 			const width = (ctx.rootNode as HTMLElement).offsetWidth;
 			const px = ctx.offset.x + (ctx.proposed.x ?? 0);
 			const py = ctx.offset.y + (ctx.proposed.y ?? 0);
@@ -37,9 +37,9 @@
 			ctx.propose(cx - ctx.offset.x, cy - ctx.offset.y);
 		}
 	};
-	const windowPlugins = [shellClamp];
+	const panePlugins = [shellClamp];
 
-	// The window's single control: left-click CLOSES, right-click MINIMIZES (the
+	// The pane's single control: left-click CLOSES, right-click MINIMIZES (the
 	// taskbar restores it), middle-click toggles MAXIMIZE — no dedicated buttons.
 	// While a non-primary button is held the glyph previews its action (minus /
 	// square); a left press keeps the ×, so holding never implies another action
@@ -53,43 +53,44 @@
 	// clobber that on every reorder. A directive-style single-property write is safe.
 	let ref = $state<HTMLDivElement | null>(null);
 	$effect(() => {
-		if (ref) ref.style.zIndex = String(win.z);
+		if (ref) ref.style.zIndex = String(pane.z);
 	});
 </script>
 
 <Pane.Root
 	bind:ref
-	data-window
-	bind:position={win.pos}
-	bind:size={win.size}
-	resizable={win.resizable}
-	plugins={windowPlugins}
-	onpointerdowncapture={() => wm.focus(win.id)}
+	data-pane
+	bind:position={pane.pos}
+	bind:size={pane.size}
+	resizable={pane.resizable}
+	plugins={panePlugins}
+	onpointerdowncapture={() => pm.focus(pane.id)}
 	class={cn(
 		'transition-[box-shadow,opacity]',
-		// Focused window reads forward; the rest recede (dimmer, flatter).
+		// Focused pane reads forward; the rest recede (dimmer, flatter).
 		focused ? 'outline -outline-offset-1 outline-primary/70' : 'opacity-95 shadow-(--era-shadow)',
-		win.state === 'minimized' && 'hidden'
+		pane.state === 'minimized' && 'hidden'
 	)}
 >
 	<Pane.Handle class="gap-(--era-gap)">
-		{#if win.icon}
-			{@const Icon = win.icon}
+		{#if pane.icon}
+			{@const Icon = pane.icon}
 			<Icon class="size-(--era-h-xs) shrink-0 text-muted" />
 		{/if}
-		<span class={cn('truncate text-body', focused ? 'text-bright' : 'text-muted')}>{win.title}</span
+		<span class={cn('truncate text-body', focused ? 'text-bright' : 'text-muted')}
+			>{pane.title}</span
 		>
 		<!-- Close / minimize / maximize. Deliberately NOT data-pane-control (same as
-		     the raw Pane.Close): a left press-and-HOLD drags the window — neodrag only
+		     the raw Pane.Close): a left press-and-HOLD drags the pane — neodrag only
 		     drags the primary button and suppresses the trailing click after a real
 		     drag, so a clean click still closes, and right/middle arming is a
 		     different button entirely. -->
-		<!-- Window actions sit LEFT of the close button, on the same --era-gap
+		<!-- Pane actions sit LEFT of the close button, on the same --era-gap
 		     rhythm as the rest of the handle. Like the close button they carry no
 		     data-pane-control, so a press-and-hold anywhere on the bar still drags
-		     the window and only a clean click activates them. -->
+		     the pane and only a clean click activates them. -->
 		<div class="ml-auto flex shrink-0 items-center gap-(--era-gap)">
-			{@render win.actions?.()}
+			{@render pane.actions?.()}
 			<!-- The macOS traffic lights, one button: red = close at rest, and the
 			     held preview recolours to the action it will commit — yellow for
 			     minimize, green for maximize — so the tone and glyph agree on what
@@ -116,18 +117,18 @@
 					armed === 'maximize' ? '[&_svg]:size-(--era-icon-xs)' : '[&_svg]:size-(--era-icon-xxs)'
 				)}
 				aria-label="Close (right-click minimizes, middle-click maximizes)"
-				onclick={() => wm.close(win.id)}
+				onclick={() => pm.close(pane.id)}
 				oncontextmenu={(e: MouseEvent) => e.preventDefault()}
 				onpointerdown={(e: PointerEvent) => {
 					// Cancelling the middle pointerdown suppresses its compatibility
 					// mouse events, so the browser's autoscroll never engages.
 					if (e.button === 1) e.preventDefault();
 					armed =
-						e.button === 2 && win.minimizable ? 'minimize' : e.button === 1 ? 'maximize' : null;
+						e.button === 2 && pane.minimizable ? 'minimize' : e.button === 1 ? 'maximize' : null;
 				}}
 				onpointerup={(e: PointerEvent) => {
-					if (e.button === 2 && armed === 'minimize') wm.minimize(win.id);
-					else if (e.button === 1 && armed === 'maximize') wm.toggleMaximize(win.id);
+					if (e.button === 2 && armed === 'minimize') pm.minimize(pane.id);
+					else if (e.button === 1 && armed === 'maximize') pm.toggleMaximize(pane.id);
 					armed = null;
 				}}
 				onpointerleave={() => (armed = null)}
@@ -144,10 +145,10 @@
 		</div>
 	</Pane.Handle>
 
-	<Pane.Content class={win.bodyClass}>
-		{#if win.component}
-			{@const Body = win.component}
-			<Body window={win} {wm} />
+	<Pane.Content class={pane.bodyClass}>
+		{#if pane.component}
+			{@const Body = pane.component}
+			<Body {pane} {pm} />
 		{/if}
 	</Pane.Content>
 </Pane.Root>

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

@@ -0,0 +1,8 @@
+import * as Pane from '../ui/pane';
+import { type AppPane } from './pane-manager.svelte.js';
+type $$ComponentProps = {
+    pane: AppPane;
+};
+declare const Pane: import("svelte").Component<$$ComponentProps, {}, "">;
+type Pane = ReturnType<typeof Pane>;
+export default Pane;

package/dist/os/taskbar.svelte

@@ -9,7 +9,7 @@
 	import Bell from '@lucide/svelte/icons/bell';
 	import Terminal from '@lucide/svelte/icons/terminal';
 	import { cn } from '../utils/index.js';
-	import { getWindowManager } from './wm.svelte.js';
+	import { getPaneManager } from './pane-manager.svelte.js';
 	import { getNotifications } from './notifications.svelte.js';
 	import { LAYER } from './layers.js';
 
@@ -36,16 +36,16 @@
 		position?: 'top' | 'bottom';
 		/** Float the bar on the desktop with a uniform --era-gap gutter (fully
 		 *  rounded, borderless — a Bar tile) instead of running flush edge to
-		 *  edge. The registered inset covers gutter + bar + gutter, so windows
+		 *  edge. The registered inset covers gutter + bar + gutter, so panes
 		 *  keep the same even gap to the bar that the bar keeps to the shell. */
 		floating?: boolean;
 		/** Pinned launchers — click spawns that app even when it isn't running. */
 		pinned?: { appId: string; title: string; icon?: Component<IconProps> | null }[];
-		/** Show the open/minimized window tabs (default true). Hidden, windows
-		 *  stay reachable through the command bar's `windows` view. */
+		/** Show the open/minimized pane tabs (default true). Hidden, panes
+		 *  stay reachable through the command bar's `panes` view. */
 		showWindows?: boolean;
-		/** Include the built-in `windows` command in the command bar (default
-		 *  true) — the palette view that focuses/restores an open window. Distinct
+		/** Include the built-in `panes` command in the command bar (default
+		 *  true) — the palette view that focuses/restores an open pane. Distinct
 		 *  from `showWindows`, which gates the tab strip and deliberately keeps
 		 *  this view as the tabs' recovery path. Set false alongside
 		 *  `showWorkspaces={false}` for a single-purpose shell whose palette shows
@@ -53,7 +53,7 @@
 		showWindowsCommand?: boolean;
 		/** Show the multi-workspace UI (default true). Hidden, both the numbered
 		 *  switcher and the command bar's `workspace` view go away — a
-		 *  single-workspace shell. `wm.addWorkspace()` still works for consumers
+		 *  single-workspace shell. `pm.addWorkspace()` still works for consumers
 		 *  who drive workspaces themselves. */
 		showWorkspaces?: boolean;
 		/** Extra root commands appended to the built-in ones. */
@@ -78,11 +78,11 @@
 		end?: Snippet;
 	} = $props();
 
-	const wm = getWindowManager();
+	const pm = getPaneManager();
 	const notif = getNotifications();
 
 	// Register our reserved chrome on whichever edge we dock to: maximize stops
-	// at the bar, and drag containment keeps window bars reachable beside it
+	// at the bar, and drag containment keeps pane bars reachable beside it
 	// (not hidden behind). Floating bars reserve their gutter on BOTH sides —
 	// measured from the rendered offset, so it tracks the live --era-gap value
 	// across density changes (barHeight moves with it, re-running this).
@@ -99,43 +99,43 @@
 					: (host?.clientHeight ?? 0) - ref.offsetTop - ref.offsetHeight;
 			inset = barHeight + Math.max(0, gutter) * 2;
 		}
-		wm.insets[edge] = inset;
+		pm.insets[edge] = inset;
 		return () => {
-			wm.insets[edge] = 0;
+			pm.insets[edge] = 0;
 		};
 	});
 
 	// The command bar owns everything the old spotlight overlay did, and more:
-	// every registered app launches from the root view, `windows` drills into
-	// the open windows (focus/restore — the recovery path when the window tabs
+	// every registered app launches from the root view, `panes` drills into
+	// the open panes (focus/restore — the recovery path when the pane tabs
 	// are hidden), and `workspace` drills into numbered workspaces + `new`.
 	// Consumer `commands` append after the built-ins (merged in a thin outer
-	// derived, so a consumer-commands change doesn't rebuild the wm closures
+	// derived, so a consumer-commands change doesn't rebuild the pm closures
 	// and vice-versa).
 	const builtinItems = $derived.by((): CommandBarItem[] => {
-		const items: CommandBarItem[] = Object.values(wm.apps).map((app) => ({
+		const items: CommandBarItem[] = Object.values(pm.apps).map((app) => ({
 			value: `app:${app.id}`,
 			label: app.title,
 			icon: app.icon ?? undefined,
 			keywords: [app.id],
 			sublabel: 'launch',
-			onSelect: () => void wm.open(app.id)
+			onSelect: () => void pm.open(app.id)
 		}));
 		// Each built-in view is assembled only when shown, so a hidden view costs
-		// nothing and takes no reactive dependency on its wm slice.
+		// nothing and takes no reactive dependency on its pm slice.
 		if (showWindowsCommand) {
 			items.push({
-				value: 'windows',
-				label: 'windows',
+				value: 'panes',
+				label: 'panes',
 				icon: AppWindowIcon,
-				sublabel: 'focus an open window',
-				placeholder: 'which window?',
-				items: wm.windows.map((w) => ({
+				sublabel: 'focus an open pane',
+				placeholder: 'which pane?',
+				items: pm.panes.map((w) => ({
 					value: `win:${w.id}`,
 					label: w.title,
 					icon: w.icon ?? undefined,
 					sublabel: w.state === 'minimized' ? 'minimized' : undefined,
-					onSelect: () => wm.focus(w.id)
+					onSelect: () => pm.focus(w.id)
 				}))
 			});
 		}
@@ -147,17 +147,17 @@
 				sublabel: 'switch / create',
 				placeholder: 'which workspace?',
 				items: [
-					...wm.workspaces.map((ws, i) => ({
+					...pm.workspaces.map((ws, i) => ({
 						value: `ws:${ws.id}`,
 						label: `${i + 1} ${ws.name}`,
 						keywords: [String(i + 1)],
-						onSelect: () => wm.switchWorkspace(ws.id)
+						onSelect: () => pm.switchWorkspace(ws.id)
 					})),
 					{
 						value: 'ws:new',
 						label: 'new',
 						sublabel: 'create a workspace',
-						onSelect: () => void wm.addWorkspace()
+						onSelect: () => void pm.addWorkspace()
 					}
 				]
 			});
@@ -212,27 +212,27 @@
 	{#if pinned.length}
 		<div class="flex shrink-0 items-center gap-(--era-gap)">
 			{#each pinned as p (p.appId)}
-				<Button icon size="default" aria-label={p.title} onclick={() => wm.open(p.appId)}>
+				<Button icon size="default" aria-label={p.title} onclick={() => pm.open(p.appId)}>
 					{#if p.icon}{@const Icon = p.icon}<Icon class="size-(--era-h-xs)" />{/if}
 				</Button>
 			{/each}
 		</div>
 	{/if}
 
-	<!-- Running windows on the active workspace: real Buttons — `active` latches
-	     the focused window's pressed face (surface-aware for free), click
+	<!-- Running panes on the active workspace: real Buttons — `active` latches
+	     the focused pane's pressed face (surface-aware for free), click
 	     focuses / minimises. Optional: hide them and use the command bar's
-	     `windows` view instead. -->
+	     `panes` view instead. -->
 	{#if showWindows}
 		<div
 			class="scrollbar-none flex max-w-[40%] min-w-0 shrink-0 items-center gap-(--era-gap) overflow-x-auto"
 		>
-			{#each wm.activeWindows as win (win.id)}
+			{#each pm.activePanes as win (win.id)}
 				<Button
-					active={wm.focusedId === win.id && win.state !== 'minimized'}
-					onclick={() => wm.toggleMinimize(win.id)}
+					active={pm.focusedId === win.id && win.state !== 'minimized'}
+					onclick={() => pm.toggleMinimize(win.id)}
 					onauxclick={(e: MouseEvent) => {
-						if (e.button === 1) wm.close(win.id);
+						if (e.button === 1) pm.close(win.id);
 					}}
 					onpointerdown={(e: PointerEvent) => {
 						// Cancel middle pointerdown so autoscroll never engages.
@@ -250,16 +250,16 @@
 	<!-- Numbered workspace switcher, term-style on the right — appears only
 	     once there's something to switch between (and only when the bar exposes
 	     workspaces at all). -->
-	{#if showWorkspaces && wm.workspaces.length > 1}
+	{#if showWorkspaces && pm.workspaces.length > 1}
 		<div class="flex shrink-0 items-center gap-(--era-gap)">
-			{#each wm.workspaces as ws, i (ws.id)}
+			{#each pm.workspaces as ws, i (ws.id)}
 				<Button
 					icon
 					size="default"
-					active={wm.activeWorkspaceId === ws.id}
+					active={pm.activeWorkspaceId === ws.id}
 					title={ws.name}
 					aria-label="Switch to workspace {i + 1} ({ws.name})"
-					onclick={() => wm.switchWorkspace(ws.id)}
+					onclick={() => pm.switchWorkspace(ws.id)}
 				>
 					{i + 1}
 				</Button>

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

@@ -8,7 +8,7 @@ type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
     position?: 'top' | 'bottom';
     /** Float the bar on the desktop with a uniform --era-gap gutter (fully
      *  rounded, borderless — a Bar tile) instead of running flush edge to
-     *  edge. The registered inset covers gutter + bar + gutter, so windows
+     *  edge. The registered inset covers gutter + bar + gutter, so panes
      *  keep the same even gap to the bar that the bar keeps to the shell. */
     floating?: boolean;
     /** Pinned launchers — click spawns that app even when it isn't running. */
@@ -17,11 +17,11 @@ type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
         title: string;
         icon?: Component<IconProps> | null;
     }[];
-    /** Show the open/minimized window tabs (default true). Hidden, windows
-     *  stay reachable through the command bar's `windows` view. */
+    /** Show the open/minimized pane tabs (default true). Hidden, panes
+     *  stay reachable through the command bar's `panes` view. */
     showWindows?: boolean;
-    /** Include the built-in `windows` command in the command bar (default
-     *  true) — the palette view that focuses/restores an open window. Distinct
+    /** Include the built-in `panes` command in the command bar (default
+     *  true) — the palette view that focuses/restores an open pane. Distinct
      *  from `showWindows`, which gates the tab strip and deliberately keeps
      *  this view as the tabs' recovery path. Set false alongside
      *  `showWorkspaces={false}` for a single-purpose shell whose palette shows
@@ -29,7 +29,7 @@ type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
     showWindowsCommand?: boolean;
     /** Show the multi-workspace UI (default true). Hidden, both the numbered
      *  switcher and the command bar's `workspace` view go away — a
-     *  single-workspace shell. `wm.addWorkspace()` still works for consumers
+     *  single-workspace shell. `pm.addWorkspace()` still works for consumers
      *  who drive workspaces themselves. */
     showWorkspaces?: boolean;
     /** Extra root commands appended to the built-in ones. */