vintage-frames 0.13.0 → 0.14.1

package/dist/shell/shell.js

@@ -0,0 +1,213 @@
+import { onScaleChange as e } from "../scale.js";
+import { VfWindow as t } from "../components/vf-window.js";
+import "../index.js";
+import { createCatalog as n } from "./catalog.js";
+import { createWindowManager as r, deepActiveElement as i } from "./windows.js";
+import { openWindowsOf as a } from "./state.js";
+import { startClock as o } from "./clock.js";
+import { showAlert as s } from "./alert.js";
+//#region src/shell/shell.ts
+function c(e) {
+	return e;
+}
+var l = "app", u = (e) => e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement || e?.isContentEditable === !0;
+function d(c, l) {
+	let d = l.apps, p = d.find((e) => e.catalog), m = l.defaultApp ?? p?.id ?? d[0]?.id ?? "", h = l.state ?? null, g = l.services ?? {}, _ = [], v = c.querySelector(":scope > vf-menu-bar");
+	if (!v) throw Error("vintage-frames/shell: the desktop has no vf-menu-bar");
+	let y = v.querySelector(":scope > vf-menu");
+	if (!y) throw Error("vintage-frames/shell: the menu bar has no system menu");
+	v.shortcuts = !0;
+	let b = h?.saved?.pattern;
+	b && (c.pattern = b);
+	let x = null;
+	if (l.fit === "viewport") {
+		let t = () => {
+			let e = {
+				width: c.width,
+				height: c.height
+			};
+			c.fitWithin(document.documentElement.clientWidth, document.documentElement.clientHeight), x?.resized(e);
+		};
+		t(), window.addEventListener("resize", t);
+		let n = e(t);
+		_.push(() => {
+			window.removeEventListener("resize", t), n();
+		});
+	}
+	let S = r(c, {
+		defaultApp: m,
+		savedPin: (e) => h?.pin(e) ?? null
+	});
+	x = S;
+	let C = (e) => {
+		e.target === c && c.clearActive();
+	};
+	c.addEventListener("pointerdown", C), _.push(() => c.removeEventListener("pointerdown", C));
+	let w = {}, T = /* @__PURE__ */ new Map();
+	T.set("app", {
+		art: (e) => d.find((t) => t.id === f(e))?.icon ?? "",
+		open: (e, t) => void w[f(e) ?? ""]?.open?.({ from: t }),
+		editable: !1
+	});
+	for (let e of d) for (let [t, n] of Object.entries(e.kinds ?? {})) T.set(t, n);
+	let E = p?.catalog ? n({
+		storage: p.catalog.storage,
+		volumes: p.catalog.volumes,
+		listed: (e) => T.has(e),
+		hooks: (e) => T.get(e)
+	}) : null, D = () => !!document.querySelector("vf-dialog[open]"), O = () => u(i()), k = /* @__PURE__ */ new Map(), A = () => {
+		for (let [e, t] of k) {
+			let n = !t();
+			e.disabled !== n && (e.disabled = n);
+		}
+	};
+	document.addEventListener("pointerdown", A, !0), document.addEventListener("keydown", A, !0), c.addEventListener("vf-select", A), c.addEventListener("vf-activate", A), _.push(() => document.removeEventListener("pointerdown", A, !0), () => document.removeEventListener("keydown", A, !0), () => c.removeEventListener("vf-select", A), () => c.removeEventListener("vf-activate", A), S.onWindows(A), S.onLayout(A)), E && _.push(E.subscribe(A));
+	let j = (e, t = {}) => s(c, e, {
+		art: l.caution ?? null,
+		...t
+	}), M = (e) => {
+		if (!e) return [];
+		let t = document.createElement("div");
+		t.innerHTML = e, customElements.upgrade(t);
+		let n = [...t.children].filter((e) => e.localName === "vf-menu");
+		for (let e of n) e.remove();
+		return n;
+	}, N = d.map((e) => ({
+		def: e,
+		menus: M(e.menus)
+	})), P = [];
+	for (let { def: e, menus: t } of N) {
+		let n = [], r = `vintage-frames/shell (${e.id})`, i = {
+			desktop: c,
+			windows: S,
+			menus: t,
+			systemMenu: y,
+			apps: w,
+			catalog: E,
+			services: g,
+			state: h,
+			kinds: T,
+			kind: (e) => T.get(e),
+			app: (e) => d.find((t) => t.id === e),
+			menu(e) {
+				let n = t.find((t) => t.dataset.menu === e);
+				if (!n) throw Error(`${r}: missing menu ${e}`);
+				return n;
+			},
+			item(e) {
+				for (let n of t) {
+					let t = n.querySelector(`vf-menu-item[value="${CSS.escape(e)}"]`);
+					if (t) return t;
+				}
+				throw Error(`${r}: missing menu item ${e}`);
+			},
+			onMenu(e) {
+				for (let n of t) i.on(n, "vf-menu-select", (t) => {
+					if (D()) return;
+					let { value: n, item: r } = t.detail;
+					e(n, r);
+				});
+			},
+			systemItem(e, t, r) {
+				let a = document.createElement("vf-menu-item");
+				return a.setAttribute("value", e), a.textContent = t, y.append(a), i.on(y, "vf-menu-select", (t) => {
+					!D() && t.detail.value === e && r();
+				}), n.push(() => a.remove()), a;
+			},
+			alert: j,
+			gate(e, t) {
+				k.set(e, t), n.push(() => k.delete(e));
+				let r = !t();
+				e.disabled !== r && (e.disabled = r);
+			},
+			typing: O,
+			modalOpen: D,
+			onFront(t) {
+				t(S.front === e.id), n.push(S.onFront((n) => t(n === e.id)));
+			},
+			on(e, t, r, i) {
+				e.addEventListener(t, r, i), n.push(() => e.removeEventListener(t, r, i));
+			},
+			onDispose(e) {
+				n.push(e);
+			}
+		}, a = e.init(i);
+		a && (w[e.id] = a), P.push(() => {
+			for (let e of n.splice(0).reverse()) e();
+		});
+	}
+	let F = null, I = () => {
+		let e = N.find((e) => e.def.id === S.front) ?? N.find((e) => e.def.id === m) ?? null;
+		if (!(!e || e === F)) {
+			if (F) for (let e of F.menus) e.remove();
+			y.after(...e.menus), v.label = e.def.name, F = e, A();
+		}
+	};
+	if (_.push(S.onFront(I)), I(), l.clock !== !1) {
+		let e = v.querySelector(":scope > [slot=\"end\"]"), t = !e;
+		e || (e = document.createElement("vf-label"), e.slot = "end", v.append(e));
+		let n = o(e);
+		_.push(() => {
+			n(), t && e.remove();
+		});
+	}
+	let L = /* @__PURE__ */ new WeakSet(), R = () => {
+		if (E) for (let e of c.stackingOrder) {
+			if (!(e instanceof t)) continue;
+			let n = S.itemOf(e);
+			if (n == null) continue;
+			let r = E.item(n);
+			r ? (L.add(e), e.heading !== r.name && (e.heading = r.name)) : L.has(e) && E.get().available && S.close(e, { to: null });
+		}
+	};
+	return E && _.push(E.subscribe(R), S.onWindows(R)), h?.hold(), {
+		desktop: c,
+		windows: S,
+		catalog: E,
+		apps: w,
+		ready: (async () => {
+			try {
+				E && (await E.refresh(), p?.catalog?.seed && await E.seed(p.catalog.seed));
+				for (let { item: e, app: t } of a(h?.saved ?? null)) await w[t]?.open?.({ item: e });
+				let e = h?.saved?.active;
+				if (e) {
+					let t = S.windowFor(e);
+					t && c.bringToFront(t);
+				}
+			} finally {
+				if (h) {
+					let e = h.start(() => ({
+						windows: S.snapshot(),
+						active: S.itemOf(c.activeWindow),
+						pattern: c.pattern ?? null
+					}), (e) => {
+						let t = [
+							S.onLayout(e),
+							S.onWindows(e),
+							...E ? [E.subscribe(e)] : []
+						];
+						return c.addEventListener("vf-activate", e), () => {
+							for (let e of t) e();
+							c.removeEventListener("vf-activate", e);
+						};
+					});
+					_.push(e), h.release();
+				}
+			}
+		})(),
+		alert: j,
+		dispose() {
+			for (let e of P.splice(0).reverse()) e();
+			if (F) for (let e of F.menus) e.remove();
+			F = null;
+			for (let e of _.splice(0)) e();
+			S.dispose(), E?.dispose();
+		}
+	};
+}
+function f(e) {
+	let t = e.data;
+	return typeof t?.app == "string" ? t.app : null;
+}
+//#endregion
+export { l as APP_KIND, f as appIdOf, d as createShell, c as defineApp };

package/dist/shell/state.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The saved session: one versioned localStorage key holding each window's
+ * box as a nine-slice pin and its depth, the active window's item, the
+ * desktop pattern, and the site's own keys.
+ *
+ * - A window entry with a depth (`z`) was open at the write. One without is a
+ *   box alone — a palette, or a window closed this session — which a reload
+ *   never reopens and an open() still lands in.
+ * - Writes wait a moment and are held until the boot has reopened the
+ *   session: a write while windows are still reopening would drop the depth
+ *   of the ones not reached yet. Hiding or leaving the page writes at once.
+ * - `?fresh=1` neither reads nor writes.
+ *
+ * The parsing is pure, so it is tested under Node; the storage is the page's
+ * localStorage, reached only when a state is made.
+ */
+import type { Pin } from './geometry.js';
+/** One saved window. */
+export interface SavedWindow {
+    /** The application that owns it, which reopens it. */
+    app: string;
+    pin: Pin;
+    /** Its depth when saved, 0 the bottom; unset for a box alone. */
+    z?: number;
+}
+/** What the session holds. */
+export interface SavedSession {
+    v: number;
+    /** Windows by the item they show. */
+    windows: Record<string, SavedWindow>;
+    /** The active window's item, or null. */
+    active: string | null;
+    /** The desktop pattern, or null for the desktop's own. */
+    pattern: string | null;
+    /** The site's own keys. */
+    extra: Record<string, unknown>;
+}
+/**
+ * A parsed blob as a session, its bad entries dropped, or null for anything
+ * that isn't one of this version.
+ */
+export declare function readSession(parsed: unknown): SavedSession | null;
+/** The windows that were open, deepest first: the order a boot reopens them in. */
+export declare function openWindowsOf(session: SavedSession | null): {
+    item: string;
+    app: string;
+    pin: Pin;
+}[];
+/** What the shell reports at a write: the windows it knows and the active one. */
+export interface SessionSnapshot {
+    windows: Record<string, SavedWindow>;
+    active: string | null;
+    pattern: string | null;
+}
+/**
+ * The session to write: every window known before keeps its box and loses
+ * its depth, and the snapshot's windows — the open ones with theirs — go
+ * over them.
+ */
+export declare function mergeSession(known: Record<string, SavedWindow>, snapshot: SessionSnapshot, extra: Record<string, unknown>): SavedSession;
+/** A saved session the shell reads at boot and writes as the desktop changes. */
+export interface ShellState {
+    /** The session read at boot, or null. */
+    readonly saved: SavedSession | null;
+    /** A saved window's pin, by item, or null. */
+    pin(item: string): Pin | null;
+    /** A site key's saved value, else its default. */
+    get<T = unknown>(key: string): T;
+    /** Set a site key and write at once, so an immediate reload still finds it. */
+    set(key: string, value: unknown): void;
+    /** Hold every write until {@link release}. */
+    hold(): void;
+    /** Release the hold and write what is on screen. */
+    release(): void;
+    /**
+     * Start writing: `snapshot` is read at each write, after `subscribe`'s
+     * signal settles. Returns the stop function.
+     */
+    start(snapshot: () => SessionSnapshot, subscribe: (fn: () => void) => () => void): () => void;
+}
+export interface LocalStorageStateOptions {
+    /** The site's own keys and their defaults: `{ greet: true, seeded: false }`. */
+    extra?: Record<string, unknown>;
+    /** Neither read nor write. Default: `?fresh=1` in the address. */
+    fresh?: boolean;
+}
+/** A session kept under one localStorage `key`. */
+export declare function localStorageState(key: string, options?: LocalStorageStateOptions): ShellState;

package/dist/shell/state.js

@@ -0,0 +1,103 @@
+import { isPin as e } from "./geometry.js";
+//#region src/shell/state.ts
+var t = 1, n = 400;
+function r(t) {
+	let n = t;
+	return !n || typeof n != "object" || typeof n.app != "string" || !n.app || !e(n.pin) ? null : Number.isInteger(n.z) ? {
+		app: n.app,
+		pin: n.pin,
+		z: n.z
+	} : {
+		app: n.app,
+		pin: n.pin
+	};
+}
+function i(e) {
+	let n = e;
+	if (!n || typeof n != "object" || n.v !== t) return null;
+	let i = {};
+	if (n.windows && typeof n.windows == "object") for (let [e, t] of Object.entries(n.windows)) {
+		let n = r(t);
+		n && (i[e] = n);
+	}
+	return {
+		v: t,
+		windows: i,
+		active: typeof n.active == "string" && n.active ? n.active : null,
+		pattern: typeof n.pattern == "string" && n.pattern.trim() ? n.pattern : null,
+		extra: n.extra && typeof n.extra == "object" && !Array.isArray(n.extra) ? { ...n.extra } : {}
+	};
+}
+function a(e) {
+	return Object.entries(e?.windows ?? {}).filter(([, e]) => e.z != null).sort(([, e], [, t]) => e.z - t.z).map(([e, t]) => ({
+		item: e,
+		app: t.app,
+		pin: t.pin
+	}));
+}
+function o(e, n, i) {
+	let a = {};
+	for (let [t, n] of Object.entries(e)) a[t] = {
+		app: n.app,
+		pin: n.pin
+	};
+	for (let [e, t] of Object.entries(n.windows)) {
+		let n = r(t);
+		n && (a[e] = n);
+	}
+	return {
+		v: t,
+		windows: a,
+		active: n.active,
+		pattern: n.pattern,
+		extra: { ...i }
+	};
+}
+function s(e, t = {}) {
+	let r = t.fresh ?? new URLSearchParams(location.search).get("fresh") === "1", i = t.extra ?? {}, a = r ? null : c(e), s = {
+		...i,
+		...a?.extra ?? {}
+	}, l = { ...a?.windows ?? {} }, u = !1, d = null, f = () => {
+		if (r || u || !d) return;
+		let t = o(l, d(), s);
+		l = t.windows;
+		try {
+			localStorage.setItem(e, JSON.stringify(t));
+		} catch {}
+	};
+	return {
+		saved: a,
+		pin: (e) => a?.windows[e]?.pin ?? null,
+		get: (e) => s[e],
+		set(e, t) {
+			s[e] = t, f();
+		},
+		hold() {
+			u = !0;
+		},
+		release() {
+			u = !1, f();
+		},
+		start(e, t) {
+			if (r) return () => {};
+			d = e;
+			let i = 0, a = () => {
+				clearTimeout(i), i = window.setTimeout(f, n);
+			}, o = () => {
+				document.visibilityState === "hidden" && f();
+			}, s = t(a);
+			return document.addEventListener("visibilitychange", o), window.addEventListener("pagehide", f), () => {
+				clearTimeout(i), s(), document.removeEventListener("visibilitychange", o), window.removeEventListener("pagehide", f), d = null;
+			};
+		}
+	};
+}
+function c(e) {
+	try {
+		return i(JSON.parse(localStorage.getItem(e) ?? "null"));
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { s as localStorageState, o as mergeSession, a as openWindowsOf, i as readSession };

package/dist/shell/storage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Catalog storage that keeps: IndexedDB, one object store of item records
+ * keyed by `id`.
+ *
+ * The database opens at the profile's own version, and one version up when
+ * the store is missing — opening at a fixed version throws `VersionError` on
+ * a profile already past it. It opens on first use; a failed open is retried
+ * on the next call. Every call rejects on failure (a private window), and the
+ * catalog then reports itself unavailable. A connection closes itself when
+ * another tab upgrades the database, and the next call reopens.
+ */
+import type { CatalogStorage } from './catalog.js';
+/** A catalog storage in the IndexedDB database `name`, which keeps it across reloads. */
+export declare function indexedDbStorage(name: string): CatalogStorage;

package/dist/shell/storage.js

@@ -0,0 +1,41 @@
+//#region src/shell/storage.ts
+var e = "items", t = (e) => new Promise((t, n) => {
+	e.onsuccess = () => t(e.result), e.onerror = () => n(e.error ?? /* @__PURE__ */ Error("IndexedDB request failed"));
+});
+function n(t, n, r) {
+	return new Promise((i, a) => {
+		let o = n == null ? indexedDB.open(t) : indexedDB.open(t, n);
+		o.onupgradeneeded = () => {
+			o.result.objectStoreNames.contains(e) || o.result.createObjectStore(e, { keyPath: "id" });
+		}, o.onsuccess = () => {
+			let e = o.result;
+			e.onversionchange = () => {
+				r(), e.close();
+			}, i(e);
+		}, o.onerror = () => a(o.error ?? /* @__PURE__ */ Error("IndexedDB open failed")), o.onblocked = () => {
+			console.warn(`vintage-frames/shell: waiting for another tab to let go of the "${t}" database`);
+		};
+	});
+}
+async function r(t, r) {
+	let i = await n(t, void 0, r);
+	if (!i.objectStoreNames.contains(e)) {
+		let e = i.version + 1;
+		i.close(), i = await n(t, e, r);
+	}
+	return i;
+}
+function i(n) {
+	let i = null, a = () => typeof indexedDB > "u" ? Promise.reject(/* @__PURE__ */ Error("IndexedDB is unavailable")) : (i ??= r(n, () => {
+		i = null;
+	}).catch((e) => {
+		throw i = null, e;
+	}), i), o = async (n, r) => t(r((await a()).transaction(e, n).objectStore(e)));
+	return {
+		list: () => o("readonly", (e) => e.getAll()),
+		put: (e) => o("readwrite", (t) => t.put(e)),
+		remove: (e) => o("readwrite", (t) => t.delete(e))
+	};
+}
+//#endregion
+export { i as indexedDbStorage };

package/dist/shell/windows.d.ts

@@ -0,0 +1,215 @@
+/**
+ * The window manager. Applications make their windows; the manager places
+ * them, opens and closes them, follows the front application, carries them
+ * through a raster resize and arranges them.
+ *
+ * - `adopt()` takes a window an application made and appended: its
+ *   application, the item it shows, how to place it, its resize policy, and
+ *   what its close box means. `open()` raises the window for an item if one
+ *   is open, and otherwise makes, appends, adopts and places one, and shows
+ *   it out of `from`. `close()` hides a window into `to` — by default its
+ *   home box, which the Finder provides: the item's icon, or the
+ *   application's — then releases and removes it.
+ * - Placement, in order: this session's pin for the item, the saved pin,
+ *   then the `place` policy — by default the first cascade slot no open
+ *   window holds. The result is clamped into the desktop's window area.
+ * - The front application is the active window's, or the default one while
+ *   none is active. `beforeFront` runs before a change, `onFront` reports it.
+ * - Palettes are an application's utility windows: shown while it is front
+ *   and hidden otherwise, never closed or removed.
+ * - Opening a window moves keyboard focus into it; closing the active one
+ *   moves focus to the window that becomes active, else to the closed
+ *   window's icon, else to the desktop's icons. Focus left behind in a
+ *   window that is no longer active — a title-bar press moves none — goes
+ *   to the active window too.
+ * - `onWindows` reports a window opened or closed and a close's zoom rects
+ *   landing, palettes aside; `isOpen()` and `hasWindows()` hold until they
+ *   land, which is what the Finder's open ghost follows.
+ * - The resize rule re-pins every window with the nine-slice pin, re-reads a
+ *   resizable window's pin when its size changed, floors it at the window's
+ *   own size limits and caps it to the window area, so growing back restores
+ *   every place.
+ */
+import { VfWindow } from '../index.js';
+import type { VfDesktop, VfViewportBox } from '../index.js';
+import type { Bands, Box, Pin, Policy, Size } from './geometry.js';
+/** A box to write, any edge optional. */
+export interface BoxInput {
+    left?: number;
+    top?: number;
+    width?: number;
+    height?: number;
+}
+/** A placement: a position, and a size where one is stated. */
+export interface Placed extends BoxInput {
+    left: number;
+    top: number;
+}
+/** How a window is placed: its box on the desktop's live window area. */
+export type PlacePolicy = (area: Box) => BoxInput & Point;
+type Point = {
+    left: number;
+    top: number;
+};
+/** What adopting a window declares. */
+export interface AdoptOptions {
+    /** The application shown while the window is active. */
+    app: string;
+    /** The item it shows: a catalog id, or an application's own key. */
+    item?: string | null;
+    /** Its placement on the live window area; adopt() and arrange() apply it. Unset, the owner places it. */
+    place?: PlacePolicy | null;
+    /** A saved pin to open at instead. */
+    pin?: Pin | null;
+    /** Its resize policy for the re-pin. Default: a resizable window floored at its size limits, else fixed. */
+    policy?: ((cur: Box) => Policy) | null;
+    /** A box held across a raster resize while the window is near it. */
+    keep?: ((area: Box) => Box) | null;
+    /**
+     * A palette: shown while its application is front — and while the
+     * predicate holds, for one the application hides for its own reasons —
+     * and hidden otherwise. Never closed by the manager.
+     */
+    palette?: boolean | (() => boolean);
+    /**
+     * What the close box means. Unset, it closes the window. Set, the close box
+     * asks the application, which calls `close()` once it decides — after a
+     * Save prompt, say — or never.
+     */
+    close?: ((win: VfWindow) => void) | null;
+}
+/** What opening a window for an item declares. */
+export interface OpenOptions extends Omit<AdoptOptions, 'pin' | 'palette'> {
+    /** Makes the window, not yet appended. */
+    create: () => VfWindow;
+    /** The box it opens out of, in viewport CSS px: an icon's `cellRect()`. */
+    from?: VfViewportBox | null;
+}
+/** An application's arrangement group, for windows it places itself. */
+export interface ArrangeGroup {
+    arrange(): void;
+    arranged(): boolean;
+}
+/**
+ * The box a closing window shrinks into, in viewport CSS px: `item` is the
+ * window's item, or null, and `app` its application. The Finder answers with
+ * the item's icon, the nearest open folder around it, or the application's
+ * icon.
+ */
+export type HomeBox = (item: string | null, app: string) => VfViewportBox | null;
+/** Move the focus to the closed window's icon (`item` null: the desktop's first); resolves whether it moved. */
+export type FocusHome = (item: string | null, app: string | null) => boolean;
+export interface WindowManagerOptions {
+    /** The application front while no window is active. */
+    defaultApp: string;
+    /** A saved pin by item — the session the boot read. */
+    savedPin?: (item: string) => Pin | null;
+}
+/** The innermost focused element, through open shadow roots. */
+export declare function deepActiveElement(): Element | null;
+/**
+ * Move keyboard focus to the first thing in `win`'s content that takes it,
+ * once that content has rendered — and then only if `when`, read at that
+ * point, still holds. Resolves whether it did: a window with nothing
+ * focusable in its content keeps the focus where it was.
+ */
+export declare function focusInto(win: Element, { when }?: {
+    when?: () => boolean;
+}): Promise<boolean>;
+/** The window manager over a desktop. */
+export declare function createWindowManager(desktop: VfDesktop, options: WindowManagerOptions): {
+    /** The desktop's window area, system px. */
+    readonly area: Box;
+    /** The front application's id. */
+    readonly front: string;
+    /**
+     * Take a window an application made and appended (a slotted child of the
+     * desktop: the clamp reads its lattice). It opens at the saved `pin`, or
+     * at its `place`; without either the owner placed it.
+     */
+    adopt(win: VfWindow, opts: AdoptOptions): void;
+    /**
+     * Open the window for `item`: raise it if one is open, else make it,
+     * append it, adopt it and place it — this session's pin, then the saved
+     * one, then `place`, by default the first free cascade slot — and show it
+     * out of `from`. Keyboard focus moves into it. Returns the window.
+     */
+    open(opts: OpenOptions): VfWindow;
+    /**
+     * Close a window into `to` — by default its home box, the Finder's icon
+     * for it — then release and remove it. The item's box is remembered for
+     * the session. Resolves when the zoom rects have landed.
+     */
+    close(win: VfWindow, { to }?: {
+        to?: VfViewportBox | null;
+    }): Promise<boolean>;
+    /** The close box's route: the window's own close, or a plain close. */
+    requestClose(win: VfWindow): void;
+    /** The window showing `item`, or null. */
+    windowFor(item: string): VfWindow | null;
+    /** Every window of an application, back to front. */
+    windowsOf(app: string): VfWindow[];
+    /** A window's item, or null. */
+    itemOf(win: Element | null): string | null;
+    /** A window's application, or null when the manager doesn't hold it. */
+    appOf(win: Element | null): string | null;
+    /** Whether `win` is a palette. */
+    isPalette(win: Element | null): boolean;
+    /** Change the item a window shows: an untitled document's first save, say. */
+    setItem(win: VfWindow, item: string | null): void;
+    /** Whether a window shows `item`, or is still closing into its icon. */
+    isOpen(item: string): boolean;
+    /** Whether an application has a window open, palettes aside, or one still closing. */
+    hasWindows(app: string): boolean;
+    /** Re-read every palette's predicate: an application hid or showed one. */
+    palettesChanged(): void;
+    /** Write a box for a gesture the owner runs itself — a zoom, its group's arrange. */
+    write(win: VfWindow, box: Placed): void;
+    /** The box a placement would write, not written. */
+    clamped(win: VfWindow, box: BoxInput): Placed;
+    /** A window's `place` on the live area, clamped, or null. */
+    placed(win: VfWindow): Placed | null;
+    /** A window's pin on the current raster, for an owner that saves it. */
+    pinOf(win: VfWindow): Pin;
+    /** A pin on the live raster, clamped, under the window's policy or `policy`. */
+    fromPin(win: VfWindow, pin: Pin, policy?: Policy): Placed;
+    /** Widen the frame's bands, for an application whose windows dock along the edges. */
+    setFrameBands(next: Partial<Bands>): void;
+    /** Register an application's arrangement group. Returns the unregister. */
+    arrangeWith(app: string, group: ArrangeGroup): () => void;
+    /** View → Arrange Windows: every group's arrange, then every `place`. Nothing is raised. */
+    arrange(): void;
+    /** Whether every group is arranged and every shown window sits at its `place`. */
+    arranged(): boolean;
+    /**
+     * Carry every window from the `before` raster to the live one with the
+     * nine-slice pin, then tell the onRaster listeners. Nothing clamps a
+     * window's position, so growing back restores it.
+     */
+    resized(before: Size): void;
+    /** The windows' saved boxes: each open one with its depth, the palettes as boxes alone. */
+    snapshot(): Record<string, {
+        app: string;
+        pin: Pin;
+        z?: number;
+    }>;
+    /** This session's pin for an item whose window closed, or null. */
+    rememberedPin(item: string): Pin | null;
+    /** Notify layout of a change the owner made itself. */
+    layoutChanged(): void;
+    /** Set where a window closes into and where focus goes after it: the Finder's. */
+    setHome(box: HomeBox, focus: FocusHome): () => void;
+    /** The layout signal: any geometry write, drag, grow or arrange. Returns the unsubscribe. */
+    onLayout(fn: () => void): () => void;
+    /** A window opened or closed, or finished closing, palettes aside; a window's item changed. */
+    onWindows(fn: () => void): () => void;
+    /** A raster resize, after every window has re-pinned. */
+    onRaster(fn: (before: Size, after: Size) => void): () => void;
+    /** An activation, before the front application changes: `fn(win)`, the new active window or null. */
+    beforeFront(fn: (win: HTMLElement | null) => void): () => void;
+    /** The front application changed. */
+    onFront(fn: (app: string) => void): () => void;
+    dispose(): void;
+};
+export type WindowManager = ReturnType<typeof createWindowManager>;
+export {};