vintage-frames 0.14.1 → 0.16.0

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

@@ -7,21 +7,25 @@
  *   nodes come back each time it is front, so items keep their state. A menu
  *   off the bar has no key equivalents, so only the front application's fire.
  *   The bar's label is the front application's name.
+ * - 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, the system menu, the other applications' actions (read at the
- *   call), the catalog when a Finder runs, the site's services, `alert()`,
- *   `gate()`, `onFront()` and `onDispose()`. Everything it sets up comes down
- *   through `onDispose()`, so a hot reload starts clean.
+ *   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 type { VfDesktop, VfMenu, VfMenuItem, VfViewportBox } from '../index.js';
+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';
 import type { ShellState } from './state.js';
-import type { AlertOptions } from './alert.js';
 /** A kind of catalog item an application registers: how it looks and opens. */
 export interface KindDefinition {
     /** Its 32×32 art: one URL, or one per item. */
@@ -57,6 +61,16 @@ export interface AppDefinition<Actions = unknown> {
     icon?: string;
     /** A fragment of `vf-menu` elements, each with a `data-menu` name. */
     menus?: string;
+    /**
+     * A fragment of dialogs, each with a `data-dialog` name: a `vf-dialog`, or
+     * 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. */
@@ -98,8 +112,24 @@ export interface AppContext {
     onMenu(fn: (value: string, item: VfMenuItem) => void): void;
     /** Put an item in the system menu, which runs `fn` when picked. */
     systemItem(value: string, label: string, fn: () => void): VfMenuItem;
-    /** Show an alert with the site's caution art; resolves the button's value. */
-    alert(message: string, options?: AlertOptions): Promise<string | null>;
+    /** 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. */
+    release(dialog: Element): void;
+    /**
+     * Show a dialog it holds, and resolve its `returnValue`: the value of the
+     * button that submitted it, or null when it closed without one. Throws for
+     * a dialog it doesn't hold.
+     */
+    ask(dialog: VfModalDialog): Promise<string | null>;
     /** Keep `item` disabled while `test` is false: re-run on every press, key, selection change and activation. */
     gate(item: VfMenuItem, test: () => boolean): void;
     /** Whether a text field has keyboard focus, read through shadow roots at the call. */
@@ -128,8 +158,6 @@ export interface ShellOptions {
     services?: Record<string, unknown>;
     /** The clock in the menu bar's `end` slot. Default true. */
     clock?: boolean;
-    /** The 32×32 caution art the alerts carry. */
-    caution?: string | null;
 }
 /** A running shell. */
 export interface Shell {
@@ -139,7 +167,6 @@ export interface Shell {
     readonly apps: Record<string, any>;
     /** Settles once the boot has read the catalog and reopened the session. */
     readonly ready: Promise<void>;
-    alert(message: string, options?: AlertOptions): Promise<string | null>;
     dispose(): void;
 }
 /** The kind the shell registers: an application's icon, which opens it. */

package/dist/shell/shell.js

@@ -2,10 +2,9 @@ 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";
+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 c(e) {
 	return e;
@@ -62,22 +61,30 @@ function d(c, l) {
 		}
 	};
 	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) => {
+	let j = (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");
+		let n = [...t.children].filter((e) => e instanceof HTMLElement);
 		for (let e of n) e.remove();
 		return n;
-	}, N = d.map((e) => ({
+	}, M = 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 = {
+		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 s = {
 			desktop: c,
 			windows: S,
 			menus: t,
@@ -91,7 +98,7 @@ function d(c, l) {
 			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}`);
+				if (!n) throw Error(`${a}: missing menu ${e}`);
 				return n;
 			},
 			item(e) {
@@ -99,76 +106,101 @@ function d(c, l) {
 					let t = n.querySelector(`vf-menu-item[value="${CSS.escape(e)}"]`);
 					if (t) return t;
 				}
-				throw Error(`${r}: missing menu item ${e}`);
+				throw Error(`${a}: missing menu item ${e}`);
 			},
 			onMenu(e) {
-				for (let n of t) i.on(n, "vf-menu-select", (t) => {
+				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, 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;
+			systemItem(e, t, n) {
+				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(`${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 S.holdDialog(t, { app: e.id }), o.add(t), t;
+			},
+			release(e) {
+				o.delete(e) && (S.releaseDialog(e), e.remove());
+			},
+			ask(t) {
+				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));
+					};
+					t.addEventListener("vf-close", n), t.show();
+				});
 			},
-			alert: j,
 			gate(e, t) {
-				k.set(e, t), n.push(() => k.delete(e));
-				let r = !t();
-				e.disabled !== r && (e.disabled = r);
+				k.set(e, t), i.push(() => k.delete(e));
+				let n = !t();
+				e.disabled !== n && (e.disabled = n);
 			},
 			typing: O,
 			modalOpen: D,
 			onFront(t) {
-				t(S.front === e.id), n.push(S.onFront((n) => t(n === e.id)));
+				t(S.front === e.id), i.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));
+			on(e, t, n, r) {
+				e.addEventListener(t, n, r), i.push(() => e.removeEventListener(t, n, r));
 			},
 			onDispose(e) {
-				n.push(e);
+				i.push(e);
 			}
-		}, a = e.init(i);
-		a && (w[e.id] = a), P.push(() => {
-			for (let e of n.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 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();
+	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 (_.push(S.onFront(I)), I(), l.clock !== !1) {
+	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 = o(e);
+		let n = s(e);
 		_.push(() => {
 			n(), t && e.remove();
 		});
 	}
-	let L = /* @__PURE__ */ new WeakSet(), R = () => {
+	let I = /* @__PURE__ */ new WeakSet(), L = () => {
 		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 });
+			r ? (I.add(e), e.heading !== r.name && (e.heading = r.name)) : I.has(e) && E.get().available && S.close(e, { to: null });
 		}
 	};
-	return E && _.push(E.subscribe(R), S.onWindows(R)), h?.hold(), {
+	return E && _.push(E.subscribe(L), S.onWindows(L)), 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 });
+				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 = S.windowFor(e);
@@ -186,20 +218,24 @@ function d(c, l) {
 							S.onWindows(e),
 							...E ? [E.subscribe(e)] : []
 						];
-						return c.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();
-							c.removeEventListener("vf-activate", e);
+							c.removeEventListener("vf-activate", e), n.disconnect();
 						};
 					});
 					_.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 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();
 		}

package/dist/shell/windows.d.ts

@@ -29,9 +29,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 {
@@ -65,6 +71,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 —
@@ -74,10 +87,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. */
@@ -105,13 +122,19 @@ 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 a descendant
+ * marked `autofocus`, else to the first thing that takes the focus. 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 }?: {
     when?: () => boolean;
@@ -143,16 +166,40 @@ 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. */
     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;
+    /** A window's or a held dialog's application, or null when the manager doesn't hold it. */
+    appOf(el: Element | null): string | null;
+    /**
+     * Hold an application's dialog: a `vf-dialog`, or an element that renders
+     * one inside itself. It is appended to the desktop unless it is already
+     * in it, and its `open` is followed from then on.
+     */
+    holdDialog(dialog: Element, { app }: {
+        app: string;
+    }): void;
+    /** Let a held dialog go. It stays where it is; the caller removes it. */
+    releaseDialog(dialog: Element): void;
+    /** An application's held dialogs. */
+    dialogsOf(app: string): Element[];
+    /** The application of the held dialog opened last and still open, or null. */
+    readonly asking: 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. */
@@ -163,8 +210,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. */
@@ -209,6 +264,8 @@ export declare function createWindowManager(desktop: VfDesktop, options: WindowM
     beforeFront(fn: (win: HTMLElement | null) => void): () => void;
     /** The front application changed. */
     onFront(fn: (app: string) => void): () => void;
+    /** A held dialog opened or closed, so `asking` may have changed. */
+    onDialogs(fn: () => void): () => void;
     dispose(): void;
 };
 export type WindowManager = ReturnType<typeof createWindowManager>;