vintage-frames 0.15.0 → 0.16.1

package/dist/shell/index.d.ts

@@ -12,7 +12,7 @@
 export { createShell, defineApp, appIdOf, APP_KIND } from './shell.js';
 export type { AppContext, AppDefinition, CatalogSetup, KindDefinition, Shell, ShellOptions } from './shell.js';
 export { createWindowManager, focusInto } from './windows.js';
-export type { AdoptOptions, ArrangeGroup, BoxInput, FocusHome, HomeBox, OpenOptions, PlacePolicy, Placed, WindowManager, WindowManagerOptions, } from './windows.js';
+export type { AdoptOptions, ArrangeGroup, BoxInput, CloseHandler, FocusHome, HomeBox, OpenOptions, PlacePolicy, Placed, WindowManager, WindowManagerOptions, } from './windows.js';
 export { finder, FINDER } from './finder.js';
 export type { FinderAlert, FinderAlertHandler, FinderAlerts, FinderApi, FinderArt, FinderCommand, FinderCommandSpec, FinderFailedAction, FinderMenu, FinderOpen, FinderOptions, } from './finder.js';
 export { fileByDrag } from './filing.js';

package/dist/shell/pure.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `vintage-frames/shell/pure` — the shell's pure modules on their own: the
+ * catalog, the geometry and the saved session. They import nothing from the
+ * kit and touch no DOM at import, so a site's own pure modules and their
+ * tests import them under Node. `vintage-frames/shell` exports the same
+ * names.
+ */
+export * from './catalog.js';
+export * from './geometry.js';
+export * from './state.js';

package/dist/shell/pure.js

@@ -0,0 +1,4 @@
+import { DISK as e, FOLDER as t, TRASH as n, UNTITLED_FOLDER as r, childrenOf as i, containerOf as a, copyName as o, createCatalog as s, descendantsOf as c, enclosingFolders as l, isContainerKind as u, isInside as d, isTrashed as f, isVolume as p, itemCount as m, itemOf as h, memoryStorage as g, nextFolderName as _ } from "./catalog.js";
+import { BAND as v, CASCADE_SLOTS as y, CASCADE_STEP as b, ICON_CELL as x, ICON_COLUMN as S, ICON_INSET as C, ICON_ROW as w, NEAR as T, WINDOW_ORIGIN as E, cascadeFrom as D, cascadeSlot as O, cascadedBox as k, centeredBox as A, cleanUp as j, collisions as M, desktopLattice as N, fieldExtent as P, fillOrder as F, folderLattice as I, frameOf as L, isPin as R, latticeCell as z, latticeSlot as B, nearBox as V, nextFreeCell as H, pinOf as U, pinTo as W, trashCell as G, windowOrigin as K } from "./geometry.js";
+import { localStorageState as q, mergeSession as J, openWindowsOf as Y, readSession as X } from "./state.js";
+export { v as BAND, y as CASCADE_SLOTS, b as CASCADE_STEP, e as DISK, t as FOLDER, x as ICON_CELL, S as ICON_COLUMN, C as ICON_INSET, w as ICON_ROW, T as NEAR, n as TRASH, r as UNTITLED_FOLDER, E as WINDOW_ORIGIN, D as cascadeFrom, O as cascadeSlot, k as cascadedBox, A as centeredBox, i as childrenOf, j as cleanUp, M as collisions, a as containerOf, o as copyName, s as createCatalog, c as descendantsOf, N as desktopLattice, l as enclosingFolders, P as fieldExtent, F as fillOrder, I as folderLattice, L as frameOf, u as isContainerKind, d as isInside, R as isPin, f as isTrashed, p as isVolume, m as itemCount, h as itemOf, z as latticeCell, B as latticeSlot, q as localStorageState, g as memoryStorage, J as mergeSession, V as nearBox, _ as nextFolderName, H as nextFreeCell, Y as openWindowsOf, U as pinOf, W as pinTo, X as readSession, G as trashCell, K as windowOrigin };

package/dist/shell/shell.d.ts

@@ -10,16 +10,18 @@
  * - While an application's held dialog is open, the bar shows that
  *   application's name and menus instead; nothing else changes.
  * - Each application's `init(ctx)` gets the desktop, the window manager, its
- *   own menus and dialogs, the system menu, the other applications' actions
+ *   own menus, dialogs and window markup, the system menu, the other applications' actions
  *   (read at the call), the catalog when a Finder runs, the site's services,
  *   `ask()`, `gate()`, `onFront()` and `onDispose()`. Everything it sets up
  *   comes down through `onDispose()`, and its dialogs with it, so a hot
  *   reload starts clean. The shell composes no UI of its own.
  * - A window showing a catalog item follows it: its title follows a rename,
  *   and it closes when the item is removed.
- * - The boot reads the catalog, seeds it once, reopens the last session's
- *   windows deepest first and the active one last, then starts saving.
+ * - The boot waits for the desktop and its menu bar to render, reads the
+ *   catalog, seeds it once, reopens the last session's windows deepest
+ *   first and the active one last, then starts saving.
  */
+import { VfWindow } from '../index.js';
 import type { VfDesktop, VfDialog, VfMenu, VfMenuItem, VfModalDialog, VfViewportBox } from '../index.js';
 import type { Catalog, CatalogStorage, Item, Volumes } from './catalog.js';
 import type { WindowManager } from './windows.js';
@@ -64,6 +66,11 @@ export interface AppDefinition<Actions = unknown> {
      * an element that renders one inside itself. Held under the application.
      */
     dialogs?: string;
+    /**
+     * A fragment of windows, each with a `data-window` name, kept inert:
+     * `ctx.window(name)` makes a fresh copy of one on each call.
+     */
+    windows?: string;
     /** The catalog kinds it opens. */
     kinds?: Record<string, KindDefinition>;
     /** The Finder's: the catalog every application shares. */
@@ -107,6 +114,12 @@ export interface AppContext {
     systemItem(value: string, label: string, fn: () => void): VfMenuItem;
     /** One of its dialogs by `data-dialog`; throws when the markup drifts. */
     dialog<T extends HTMLElement = VfDialog>(name: string): T;
+    /**
+     * A fresh copy of one of its windows by `data-window`, upgraded and not yet
+     * appended: `open({ create: () => ctx.window('viewer') })`. Throws when the
+     * markup drifts.
+     */
+    window<T extends HTMLElement = VfWindow>(name: string): T;
     /** Hold a dialog it made in code: appended to the desktop, held under it, removed with it. Returns it. */
     hold<T extends Element>(dialog: T): T;
     /** Let a dialog it holds go, and remove it. */

package/dist/shell/shell.js

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

package/dist/shell/windows.d.ts

@@ -17,7 +17,8 @@
  *   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
+ * - Opening a window moves keyboard focus into it, and a new window's field
+ *   marked `autoselect` opens with its text selected; 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
@@ -29,12 +30,15 @@
  *   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.
+ * - The zoom box, for a window adopted with `zoom`: the window goes to its
+ *   zoomed box and back to the box it had, kept as a pin; a zoomed window
+ *   stays zoomed across a resize.
  * - Dialogs: `holdDialog()` holds an application's dialog under it, in the
  *   desktop. The manager follows each held dialog's `open` attribute, and
  *   `asking` is the application of the one opened last and still open.
  */
 import { VfWindow } from '../index.js';
-import type { VfDesktop, VfViewportBox } from '../index.js';
+import type { VfCloseKeys, 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 {
@@ -68,6 +72,13 @@ export interface AdoptOptions {
     policy?: ((cur: Box) => Policy) | null;
     /** A box held across a raster resize while the window is near it. */
     keep?: ((area: Box) => Box) | null;
+    /**
+     * Its zoom box: the window's zoomed box on the window area, given its
+     * current box (to keep its top-left, say). Set, the manager runs the zoom
+     * box: it goes to this box and back to the box the user had, and a window
+     * at it stays zoomed across a raster resize.
+     */
+    zoom?: ((area: Box, box: Box) => BoxInput) | null;
     /**
      * A palette: shown while its application is front — and while the
      * predicate holds, for one the application hides for its own reasons —
@@ -77,10 +88,14 @@ export interface AdoptOptions {
     /**
      * 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.
+     * Save prompt, say — or never. It gets the modifier keys held on the
+     * close box's click; a close from a menu or code holds none. A handler
+     * that decides later returns its promise, so `closeAll()` waits for it.
      */
-    close?: ((win: VfWindow) => void) | null;
+    close?: CloseHandler | null;
 }
+/** A window's close handler: decides whether it closes, and calls `close()` if so. */
+export type CloseHandler = (win: VfWindow, keys: Partial<VfCloseKeys>) => void | Promise<void>;
 /** What opening a window for an item declares. */
 export interface OpenOptions extends Omit<AdoptOptions, 'pin' | 'palette'> {
     /** Makes the window, not yet appended. */
@@ -108,16 +123,26 @@ export interface WindowManagerOptions {
     /** A saved pin by item — the session the boot read. */
     savedPin?: (item: string) => Pin | null;
 }
+/** Settles once the desktop and its menu bar have rendered, so `workArea` measures the bar. */
+export declare function desktopRendered(desktop: VfDesktop): Promise<void>;
 /** 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.
+ * Move keyboard focus into `win`'s content once that content has rendered —
+ * and then only if `when`, read at that point, still holds: to the first
+ * descendant marked `autofocus` or `autoselect`, else to the first thing that
+ * takes the focus. With `select`, a control marked `autoselect` has its text
+ * selected too; the window manager passes it on a window's first open only,
+ * so a caret placed in the window survives a return to it. An element whose
+ * `tabindex` is negative is passed over: a roving cell parked off the tab
+ * order, a disabled control. A kit host with no `tabindex` goes through,
+ * since it hands the focus on inside itself. Resolves whether the focus
+ * moved: a window with nothing focusable in its content keeps the focus where
+ * it was.
  */
-export declare function focusInto(win: Element, { when }?: {
+export declare function focusInto(win: Element, { when, select }?: {
     when?: () => boolean;
+    select?: boolean;
 }): Promise<boolean>;
 /** The window manager over a desktop. */
 export declare function createWindowManager(desktop: VfDesktop, options: WindowManagerOptions): {
@@ -135,7 +160,8 @@ export declare function createWindowManager(desktop: VfDesktop, options: WindowM
      * 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.
+     * out of `from`. Keyboard focus moves into it, and a new window's field
+     * marked `autoselect` has its text selected. Returns the window.
      */
     open(opts: OpenOptions): VfWindow;
     /**
@@ -146,8 +172,18 @@ export declare function createWindowManager(desktop: VfDesktop, options: WindowM
     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 close box's route: the window's own close, given the modifier keys
+     * held, or a plain close. Resolves whether the window closed, once its
+     * close handler has settled.
+     */
+    requestClose(win: VfWindow, keys?: Partial<VfCloseKeys>): Promise<boolean>;
+    /**
+     * Ask each of an application's windows to close, front to back, palettes
+     * aside: a Quit. Resolves false at the first window still open once its
+     * handler has settled — a Cancel — and true when all have closed.
+     */
+    closeAll(app: string, keys?: Partial<VfCloseKeys>): Promise<boolean>;
     /** The window showing `item`, or null. */
     windowFor(item: string): VfWindow | null;
     /** Every window of an application, back to front. */
@@ -180,8 +216,16 @@ export declare function createWindowManager(desktop: VfDesktop, options: WindowM
     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 a box for a gesture the owner runs itself — its group's arrange, a zoom of its own. */
     write(win: VfWindow, box: Placed): void;
+    /**
+     * The zoom box, for a window adopted with a `zoom`: away from its zoomed
+     * box, the window goes there, its box remembered; at it, the window goes
+     * back to that box, carried by its pin through any raster resize since,
+     * or to its `place` with none remembered. The zoom box's press runs it;
+     * so can a menu command.
+     */
+    zoom(win: VfWindow): 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. */