acrylblends 1.0.10 → 1.1.0

package/lib/cordis/state.js

@@ -1,7 +1,7 @@
 import { t as Acryl } from "../app-CQcGWjrk.js";
 import { t as methodNotAllowed } from "../method-not-allowed-TO2_hnfl.js";
 import { r as streamSSE } from "../streaming-BlDaph8U.js";
-import { i as loopbackOnly } from "../loopback-only-BbasoF7R.js";
+import { i as loopbackOnly, r as loopbackAuthority } from "../loopback-only-BbasoF7R.js";
 import "../helpers-BEjcdbgw.js";
 import "../src-BTBm4OPD.js";
 import "../middleware-BfG_fp8P.js";
@@ -58,6 +58,345 @@ function createDerived(key, inputs, compute, report = () => void 0) {
 	};
 }
 //#endregion
+//#region ../../plugins/acryl-state/src/client-source.ts
+/**
+* The browser module served at `/api/state/client.js`, kept as text so it travels with the plugin wherever the plugin goes (copied into an app as source, or bundled): there is
+* no file to find at run time and no compiler needed to serve it. `String.raw` keeps every backslash as written, so what is below is the module exactly as the browser gets it.
+* The code has no imports and uses no backtick or dollar-brace of its own.
+*
+*   import { watch } from '/api/state/client.js'
+*   const stop = watch('tasks.count', (value) => { badge.textContent = String(value) })
+*
+* One WebSocket for the whole page carries every key; a WebSocket is not one of the browser's six connections per host, so a page that watches ten keys, in as many windows,
+* leaves every one of them free for requests. Where the WebSocket cannot open (no `ws` package on the server, a proxy that does not upgrade), each key is followed by its
+* event stream instead, with one console warning.
+*/
+const CLIENT_SOURCE = String.raw`// acryl-state: watch(key, onValue, onError?) follows a state key over one WebSocket for the page.
+const HEARTBEAT_SILENCE_MS = 45000
+const RETRY_MIN_MS = 250
+const RETRY_MAX_MS = 10000
+
+const here = import.meta.url
+const watchers = new Map()
+const latest = new Map()
+const streams = new Map()
+const complained = new Set()
+let socket
+let timer
+let watchdog
+let attempts = 0
+let opened = false
+let following = 'socket'
+let suspended = false
+let warnedStream = false
+
+const socketUrl = () => {
+  const url = new URL('ws', here)
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
+  return url.href
+}
+const streamUrl = (key) => new URL(encodeURIComponent(key) + '/events?json=1', here).href
+
+const deliver = (key, text) => {
+  if (latest.get(key) === text) return
+  latest.set(key, text)
+  let value
+  try {
+    value = JSON.parse(text)
+  } catch {
+    return
+  }
+  for (const watcher of [...(watchers.get(key) ?? [])]) {
+    try {
+      watcher.onValue(value)
+    } catch (cause) {
+      console.error('acryl-state: a watcher of ' + key + ' threw', cause)
+    }
+  }
+}
+
+const fail = (key, message) => {
+  const set = watchers.get(key)
+  if (set === undefined) return
+  let told = false
+  for (const watcher of [...set]) {
+    if (watcher.onError === undefined) continue
+    told = true
+    try {
+      watcher.onError(new Error(message))
+    } catch (cause) {
+      console.error('acryl-state: an error handler of ' + key + ' threw', cause)
+    }
+  }
+  if (!told && !complained.has(key)) {
+    complained.add(key)
+    console.warn('acryl-state: ' + key + ': ' + message)
+  }
+}
+
+const send = (frame) => {
+  if (socket !== undefined && socket.readyState === 1) socket.send(JSON.stringify(frame))
+}
+
+const arm = () => {
+  clearTimeout(watchdog)
+  watchdog = setTimeout(() => lost(socket), HEARTBEAT_SILENCE_MS)
+}
+
+const closeSocket = () => {
+  clearTimeout(watchdog)
+  const current = socket
+  socket = undefined
+  if (current === undefined) return
+  current.onopen = current.onmessage = current.onerror = current.onclose = null
+  try {
+    current.close(1000, 'page left')
+  } catch {
+    // Already closed.
+  }
+}
+
+const closeStreams = () => {
+  for (const source of streams.values()) source.close()
+  streams.clear()
+}
+
+const openStream = (key) => {
+  if (streams.has(key) || typeof EventSource === 'undefined') return
+  const source = new EventSource(streamUrl(key))
+  streams.set(key, source)
+  source.addEventListener('value', (event) => deliver(key, event.data))
+  source.onerror = () => {
+    // A network error is retried by the browser itself; a refusal (the key does not exist) ends the stream for good.
+    if (source.readyState === 2) {
+      streams.delete(key)
+      fail(key, 'the event stream was refused (no such state?)')
+    }
+  }
+}
+
+const fallBack = () => {
+  following = 'stream'
+  if (!warnedStream) {
+    warnedStream = true
+    console.warn('acryl-state: the WebSocket did not open, so each key is followed by its own event stream (each holds one of the browser\'s six connections to this host)')
+  }
+  for (const key of watchers.keys()) openStream(key)
+}
+
+// A socket that closes, errors or goes quiet: before it ever opened this is a server without WebSockets, so the streams take over; after, the server went away and the page tries again.
+const lost = (which) => {
+  if (which !== socket) return
+  closeSocket()
+  if (watchers.size === 0 || suspended) return
+  if (!opened) {
+    fallBack()
+    return
+  }
+  const delay = Math.min(RETRY_MIN_MS * 2 ** attempts, RETRY_MAX_MS)
+  attempts += 1
+  clearTimeout(timer)
+  timer = setTimeout(connect, delay)
+}
+
+const connect = () => {
+  clearTimeout(timer)
+  if (socket !== undefined || watchers.size === 0 || suspended || following !== 'socket') return
+  let made
+  try {
+    made = new WebSocket(socketUrl())
+  } catch {
+    fallBack()
+    return
+  }
+  socket = made
+  made.onopen = () => {
+    opened = true
+    attempts = 0
+    arm()
+    for (const key of watchers.keys()) send({ t: 'sub', key })
+  }
+  made.onmessage = (event) => {
+    if (made !== socket) return
+    arm()
+    let frame
+    try {
+      frame = JSON.parse(event.data)
+    } catch {
+      return
+    }
+    if (frame === null || typeof frame !== 'object' || typeof frame.key !== 'string') return
+    if (typeof frame.error === 'string') fail(frame.key, frame.error)
+    else deliver(frame.key, JSON.stringify(frame.value))
+  }
+  made.onerror = () => lost(made)
+  made.onclose = () => lost(made)
+}
+
+const start = () => {
+  if (watchers.size === 0) return
+  if (following === 'stream') for (const key of watchers.keys()) openStream(key)
+  else connect()
+}
+
+if (typeof addEventListener === 'function') {
+  // A page in the back/forward cache keeps its connections open for as long as it is kept; let them go when the page is hidden for good, and open them again when it comes back.
+  addEventListener('pagehide', () => {
+    suspended = true
+    clearTimeout(timer)
+    closeSocket()
+    closeStreams()
+  })
+  addEventListener('pageshow', () => {
+    if (!suspended) return
+    suspended = false
+    start()
+  })
+}
+
+// Follow the state key: onValue gets the value now and after every change, as the JSON value the server holds (a string stays a string). onError, when given, is told of a key that
+// does not exist; without it the page console gets one warning. Returns the function that stops watching.
+export function watch(key, onValue, onError) {
+  if (typeof key !== 'string' || key === '') throw new TypeError('watch(key, onValue): the key is a state key like "tasks.count"')
+  if (typeof onValue !== 'function') throw new TypeError('watch(key, onValue): onValue is a function')
+  const watcher = { onValue, onError }
+  let set = watchers.get(key)
+  const first = set === undefined
+  if (first) {
+    set = new Set()
+    watchers.set(key, set)
+  }
+  set.add(watcher)
+  complained.delete(key)
+  if (!first && latest.has(key)) {
+    const text = latest.get(key)
+    queueMicrotask(() => {
+      if (!set.has(watcher)) return
+      try {
+        onValue(JSON.parse(text))
+      } catch (cause) {
+        console.error('acryl-state: a watcher of ' + key + ' threw', cause)
+      }
+    })
+  }
+  if (first && !suspended) {
+    if (following === 'stream') openStream(key)
+    else if (socket === undefined) connect()
+    else send({ t: 'sub', key })
+  }
+  let stopped = false
+  return () => {
+    if (stopped) return
+    stopped = true
+    set.delete(watcher)
+    if (set.size > 0) return
+    watchers.delete(key)
+    latest.delete(key)
+    complained.delete(key)
+    streams.get(key)?.close()
+    streams.delete(key)
+    send({ t: 'unsub', key })
+    if (watchers.size === 0) {
+      clearTimeout(timer)
+      closeSocket()
+    }
+  }
+}
+`;
+/** A refusal (403) unless the upgrade comes from this machine to this app, and from its own page when it comes from a page at all. */
+function refuseStranger(c) {
+	const authority = loopbackAuthority(c);
+	if (authority === void 0) return c.json({ error: "request authority rejected" }, 403);
+	const origin = c.req.header("origin");
+	const site = c.req.header("sec-fetch-site");
+	if (origin !== void 0 && origin !== authority.origin || site !== void 0 && site !== "same-origin") return c.json({ error: "only this app's own page may follow its state" }, 403);
+}
+/** The route handler that upgrades and follows keys of `cells` for as long as the socket is open. */
+function stateSocket(cells, options) {
+	const heartbeatMs = options.heartbeatMs ?? 15e3;
+	return options.upgrade(() => {
+		const following = /* @__PURE__ */ new Map();
+		let beat;
+		return {
+			onOpen(_event, ws) {
+				beat = setInterval(() => {
+					try {
+						ws.send(JSON.stringify({ t: "ping" }));
+					} catch {}
+				}, heartbeatMs);
+				beat.unref();
+			},
+			onMessage(event, ws) {
+				if (typeof event.data !== "string") return;
+				let message;
+				try {
+					message = JSON.parse(event.data);
+				} catch {
+					return;
+				}
+				if (typeof message.key !== "string") return;
+				const key = message.key;
+				const tell = (frame) => {
+					try {
+						ws.send(JSON.stringify(frame));
+					} catch {}
+				};
+				const value = (current) => {
+					let text;
+					try {
+						text = JSON.stringify({
+							key,
+							value: current === void 0 ? null : current
+						});
+					} catch {
+						tell({
+							key,
+							error: "the value cannot be sent as JSON"
+						});
+						return;
+					}
+					try {
+						ws.send(text);
+					} catch {}
+				};
+				if (message.t === "unsub") {
+					following.get(key)?.();
+					following.delete(key);
+					return;
+				}
+				if (message.t !== "sub") return;
+				const cell = cells.find(key);
+				if (cell === void 0) {
+					tell({
+						key,
+						error: "no such state"
+					});
+					return;
+				}
+				const known = following.has(key);
+				if (!known && following.size >= 256) {
+					tell({
+						key,
+						error: "too many keys on one socket"
+					});
+					return;
+				}
+				if (known) {
+					value(cell.get());
+					return;
+				}
+				value(cell.get());
+				following.set(key, cell.subscribe(value));
+			},
+			onClose() {
+				if (beat !== void 0) clearInterval(beat);
+				for (const stop of following.values()) stop();
+				following.clear();
+			}
+		};
+	}, { textOnly: true });
+}
+//#endregion
 //#region ../../plugins/acryl-state/src/service.ts
 /**
 * The ACRYL state service (`ctx.state`): observable cells owned by plugins. A cell created from a plugin's context is removed
@@ -69,6 +408,8 @@ const KEEP_ALIVE_MS = 15e3;
 /** Stable Cordis plugin name, equal to the package name and the Loader row id. */
 const name = "acryl-state";
 const KEY_PATTERN = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
+/** Names under `/api/state` that are routes, not keys: a cell cannot be called by one. */
+const RESERVED_KEYS = /* @__PURE__ */ new Set(["ws", "client.js"]);
 var State = class extends Service {
 	cells = /* @__PURE__ */ new Map();
 	constructor(ctx) {
@@ -76,6 +417,7 @@ var State = class extends Service {
 	}
 	claim(key) {
 		if (!KEY_PATTERN.test(key)) throw new TypeError(`acryl-state: key "${key}" must be dotted lowercase words, like "market.sources"`);
+		if (RESERVED_KEYS.has(key)) throw new TypeError(`acryl-state: "${key}" is the name of a route under /api/state, choose another key`);
 		if (this.cells.has(key)) throw new Error(`acryl-state: key "${key}" is already in use`);
 	}
 	report = (error) => {
@@ -111,9 +453,10 @@ var State = class extends Service {
 	}
 	/**
 	* The current value of `key` as a server-sent event stream: the value now, then one event per change, until the client cancels or the router
-	* is disposed (both abort the stream). A comment line goes out every 15 seconds so proxies and browsers keep an idle stream open.
+	* is disposed (both abort the stream). A comment line goes out every 15 seconds so proxies and browsers keep an idle stream open. A string value travels as it is; with `json`
+	* (the `?json=1` of the browser client) every value is JSON, so `"12"` and `12` can be told apart.
 	*/
-	stream(key, c) {
+	stream(key, c, json = false) {
 		const cell = this.find(key);
 		if (cell === void 0) return void 0;
 		return streamSSE(c, async (stream) => {
@@ -124,7 +467,7 @@ var State = class extends Service {
 			const send = (value) => {
 				queue = queue.then(() => stream.writeSSE({
 					event: "value",
-					data: typeof value === "string" ? value : JSON.stringify(value)
+					data: typeof value === "string" && !json ? value : JSON.stringify(value)
 				})).catch(() => {});
 			};
 			send(cell.get());
@@ -146,14 +489,35 @@ function apply(ctx) {
 	const state = new State(ctx);
 	ctx.inject(["router"], (inner) => {
 		const api = new Acryl();
-		api.use(loopbackOnly({ inProcess: "allow" }), methodNotAllowed({ app: api })).get("/", (c) => c.json({ keys: state.keys() })).get("/:key", (c) => {
+		let socket;
+		api.use(loopbackOnly({ inProcess: "allow" }), methodNotAllowed({ app: api })).get("/", (c) => c.json({ keys: state.keys() })).get("/client.js", (c) => c.body(CLIENT_SOURCE, 200, {
+			"content-type": "text/javascript; charset=utf-8",
+			"cache-control": "no-cache"
+		})).get("/ws", async (c, next) => {
+			const upgrade = socket;
+			if (upgrade === void 0) return c.json({ error: "this server does not upgrade to a WebSocket" }, 404);
+			const refusal = refuseStranger(c);
+			if (refusal !== void 0) return refusal;
+			return await upgrade(c, next);
+		}).get("/:key", (c) => {
 			const cell = state.find(c.req.param("key"));
 			return cell === void 0 ? c.json({ error: "no such state" }, 404) : c.json({
 				key: cell.key,
 				value: cell.get()
 			});
-		}).get("/:key/events", (c) => state.stream(c.req.param("key"), c) ?? c.json({ error: "no such state" }, 404));
+		}).get("/:key/events", (c) => state.stream(c.req.param("key"), c, c.req.query("json") === "1") ?? c.json({ error: "no such state" }, 404));
 		inner.router.route("/api/state", api);
+		inner.inject(["nodeServer"], (withServer) => {
+			try {
+				const upgrade = withServer.nodeServer.upgrades();
+				socket = stateSocket(state, { upgrade });
+				withServer.effect(() => () => {
+					socket = void 0;
+				}, "acryl-state: the WebSocket route");
+			} catch (cause) {
+				ctx.logger.warn(`acryl-state: state is followed by event streams only (${cause instanceof Error ? cause.message : String(cause)})`);
+			}
+		});
 		inner.inject(["routerHttp"], (http) => {
 			http.routerHttp.mount("/api/state");
 		});

package/lib/door/host.d.ts

@@ -1,6 +1,6 @@
 import { t as Acryl } from "../app-D8riatvv.js";
 import { n as AuditEntry, y as UiSnapshot } from "../protocol-a2aqrp2X.js";
-import { i as UiChannel, n as auditPath, r as PageStream, t as AuditLog } from "../audit-Dw-siYTp.js";
+import { i as UiChannel, n as auditPath, r as PageStream, t as AuditLog } from "../audit-BFpULBCj.js";
 
 //#region ../../plugins/acryl-door/src/host/page-routes.d.ts
 /** How often the Host writes a `ping`; the page gives up on a stream that is silent for three of these. */

package/lib/door/host.js

@@ -1,2 +1,2 @@
-import { d as AuditLog, f as auditPath, n as HEARTBEAT_MS, p as UiChannel, r as pageChannelRoutes, t as renderSnapshot } from "../snapshot-text-BfEbEOjA.js";
+import { d as AuditLog, f as auditPath, n as HEARTBEAT_MS, p as UiChannel, r as pageChannelRoutes, t as renderSnapshot } from "../snapshot-text-BwM6T2nG.js";
 export { AuditLog, HEARTBEAT_MS, UiChannel, auditPath, pageChannelRoutes, renderSnapshot };

package/lib/door/page.d.ts

@@ -4,6 +4,8 @@ import { _ as UiRequest, v as UiResult } from "../protocol-a2aqrp2X.js";
 interface DriverActivity {
   /** True from the moment a call starts until it ends. */
   readonly busy: boolean;
+  /** True from the moment a run asked for from this page's panel starts until it ends, between the calls too. */
+  readonly running: boolean;
   /** What the agent is doing, for the indicator ("click", "type", ...). */
   readonly doing: string;
   /** True after the user pressed the kill switch. */
@@ -32,6 +34,7 @@ declare class UiDriver {
   private busyCount;
   private doing;
   private current;
+  private runningFlag;
   private readonly options;
   constructor(options: UiDriverOptions);
   /** The current activity; the same object until something changes, as a store snapshot must be. */
@@ -39,6 +42,11 @@ declare class UiDriver {
   subscribe(listener: (activity: DriverActivity) => void): () => void;
   /** The user pressed the kill switch: pending calls settle as `killed` and new ones are refused. */
   kill(): void;
+  /**
+   * A run asked for from this page's panel starts (`true`) or ends (`false`). The indicator stays up for the whole run, not only while a call is in flight. A new run is a new
+   * question from the person, so it also allows the agent to drive again after an earlier Stop.
+   */
+  setRunning(running: boolean): void;
   /** The user allowed the agent to drive again. */
   resume(): void;
   /** The driver goes away: pending calls settle as `unloaded`; refs are gone. */
@@ -87,6 +95,8 @@ interface PageChannelOptions {
   readonly post?: (url: string, body: string) => Promise<unknown>;
   readonly silenceMs?: number;
   readonly now?: () => number;
+  /** The Host says a run asked for from this page's panel started (`true`) or ended (`false`); false too when the stream is lost, until the Host says again. */
+  readonly onRun?: (running: boolean) => void;
 }
 declare class PageChannel {
   private source;

package/lib/door/page.js

@@ -99,6 +99,10 @@ var PageChannel = class {
 			heard();
 		});
 		source.addEventListener("ping", heard);
+		source.addEventListener("run", (event) => {
+			heard();
+			this.options.onRun?.(event.data === "1");
+		});
 		source.addEventListener("call", (event) => {
 			heard();
 			if (typeof event.data === "string") this.answer(event.data);
@@ -170,6 +174,7 @@ var PageChannel = class {
 		if (source !== void 0) {
 			source.onerror = null;
 			source.close();
+			this.options.onRun?.(false);
 		}
 	}
 	answer(text) {
@@ -938,9 +943,11 @@ var UiDriver = class {
 	doing = "";
 	current = {
 		busy: false,
+		running: false,
 		doing: "",
 		killed: false
 	};
+	runningFlag = false;
 	options;
 	constructor(options) {
 		this.options = options;
@@ -969,6 +976,16 @@ var UiDriver = class {
 		this.snapshots.clear();
 		this.emit();
 	}
+	/**
+	* A run asked for from this page's panel starts (`true`) or ends (`false`). The indicator stays up for the whole run, not only while a call is in flight. A new run is a new
+	* question from the person, so it also allows the agent to drive again after an earlier Stop.
+	*/
+	setRunning(running) {
+		if (running === this.runningFlag) return;
+		this.runningFlag = running;
+		if (running) this.killedFlag = false;
+		this.emit();
+	}
 	/** The user allowed the agent to drive again. */
 	resume() {
 		this.killedFlag = false;
@@ -1058,10 +1075,11 @@ var UiDriver = class {
 	emit() {
 		const next = {
 			busy: this.busyCount > 0,
+			running: this.runningFlag,
 			doing: this.doing,
 			killed: this.killedFlag
 		};
-		if (next.busy === this.current.busy && next.doing === this.current.doing && next.killed === this.current.killed) return;
+		if (next.busy === this.current.busy && next.running === this.current.running && next.doing === this.current.doing && next.killed === this.current.killed) return;
 		this.current = next;
 		const activity = next;
 		for (const listener of [...this.listeners]) listener(activity);
@@ -1111,6 +1129,8 @@ const LABELS = {
 	scroll: "scrolling",
 	wait: "waiting"
 };
+/** Dispatched on the page's window by the Stop button: the agent panel in the same page cancels its run. */
+const STOP_RUN_EVENT = "acryl:stop-run";
 const STYLE_ID = "acryl-door-indicator-style";
 const STYLES = `
 .acrylDoorBar { position: fixed; z-index: 2147483647; left: 50%; bottom: 16px; transform: translateX(-50%); display: flex; align-items: center; gap: 10px;
@@ -1133,12 +1153,16 @@ function mountIndicator(driver, document) {
 	bar.setAttribute("data-acryl-no-agent", "");
 	bar.setAttribute("role", "status");
 	bar.setAttribute("aria-live", "polite");
+	const stopAgent = () => {
+		driver.kill();
+		document.defaultView?.dispatchEvent(new CustomEvent(STOP_RUN_EVENT));
+	};
 	const onKey = (event) => {
-		if (event.key === "Escape" && event.isTrusted && driver.activity.busy) driver.kill();
+		if (event.key === "Escape" && event.isTrusted && (driver.activity.busy || driver.activity.running)) stopAgent();
 	};
 	document.addEventListener("keydown", onKey, true);
 	const render = (activity) => {
-		if (!activity.busy && !activity.killed) {
+		if (!activity.busy && !activity.running && !activity.killed) {
 			bar.remove();
 			return;
 		}
@@ -1158,11 +1182,9 @@ function mountIndicator(driver, document) {
 			const dot = document.createElement("span");
 			dot.className = "acrylDoorDot";
 			dot.setAttribute("aria-hidden", "true");
-			text.textContent = `Agent is driving: ${LABELS[activity.doing] ?? activity.doing}`;
+			text.textContent = `Agent is driving: ${activity.busy ? LABELS[activity.doing] ?? activity.doing : "working on your request"}`;
 			button.textContent = "Stop";
-			button.addEventListener("click", () => {
-				driver.kill();
-			});
+			button.addEventListener("click", stopAgent);
 			bar.replaceChildren(dot, text, button);
 		}
 		if (!bar.isConnected) document.body.append(bar);

package/lib/{snapshot-text-BfEbEOjA.js → snapshot-text-BwM6T2nG.js}

@@ -29,14 +29,16 @@ const DEFAULT_CALL_TIMEOUT_MS = 3e4;
 /** How long a page has to say it heard a read-only call before the call goes to the next page. */
 const DEFAULT_ACK_MS = 3e3;
 /**
-* The pages and who drives which. One page answers a call, chosen the same way every time: the page the Host just sent somewhere (it comes back as a new page, `prefer`), else the
-* one in front (it reports `focused`), else the most recently active; a page that did not acknowledge a call in time goes to the end of the line. An explicit desktop `window` picks its page.
+* The pages and who drives which. One page answers a call, chosen the same way every time: the page whose panel asked for the run that is making the call (`driveFor`), else the page the
+* Host just sent somewhere (it comes back as a new page, `prefer`), else the one in front (it reports `focused`), else the most recently active; a page that did not acknowledge a call in time goes to the end of the line. An explicit desktop `window` picks its page.
 */
 var UiChannel = class {
 	ackMs;
 	attachWaitMs;
 	/** The page the Host sent to a new place and that came back: it keeps being driven until the person focuses another page. */
 	preferred;
+	/** The pages whose panels have a run going, the latest last: a call with no `window` goes to the latest of them that is still connected. */
+	askers = [];
 	constructor(options = {}) {
 		this.ackMs = options.ackMs ?? DEFAULT_ACK_MS;
 		this.attachWaitMs = options.attachWaitMs ?? 0;
@@ -64,6 +66,7 @@ var UiChannel = class {
 			suspect: previous?.suspect === true
 		};
 		this.connections.set(windowId, connection);
+		if (this.askers.some((asker) => asker.windowId === windowId)) this.tell(connection, "1");
 		for (const waiter of [...this.attachWaiters]) waiter(windowId);
 		return () => {
 			if (this.connections.get(windowId) === connection) this.drop(connection, false);
@@ -104,12 +107,39 @@ var UiChannel = class {
 			...shellWindow === void 0 ? {} : { shellWindow }
 		}));
 	}
+	/**
+	* A run asked for from this page's panel is going: its calls (which name no window) are for this page, whatever else is open and whichever was driven last, until the run ends.
+	* An explicit desktop `window` still picks its own page.
+	* @returns the function to call when the run ends.
+	*/
+	driveFor(windowId) {
+		const asker = { windowId };
+		this.askers.push(asker);
+		this.tellPage(windowId, "1");
+		return () => {
+			const at = this.askers.indexOf(asker);
+			if (at === -1) return;
+			this.askers.splice(at, 1);
+			if (!this.askers.some((other) => other.windowId === asker.windowId)) this.tellPage(asker.windowId, "0");
+		};
+	}
+	tellPage(windowId, running) {
+		const connection = this.connections.get(windowId);
+		if (connection !== void 0) this.tell(connection, running);
+	}
+	tell(connection, running) {
+		try {
+			connection.stream.notify?.("run", running);
+		} catch {}
+	}
 	/** Drive this page from now on (it is the one the Host just sent to a new place), until the person focuses another. */
 	prefer(windowId) {
 		const connection = this.connections.get(windowId);
 		if (connection === void 0) return;
 		this.preferred = windowId;
 		connection.lastActive = ++this.clock;
+		for (const asker of this.askers) if (!this.connections.has(asker.windowId)) asker.windowId = windowId;
+		if (this.askers.some((asker) => asker.windowId === windowId)) this.tellPage(windowId, "1");
 	}
 	/**
 	* Ask the current page to do something. A read-only call (`look`, `wait`) that the page does not acknowledge in time goes to the next page, and the silent one is last in line
@@ -258,9 +288,10 @@ var UiChannel = class {
 		for (const connection of [...this.connections.values()]) connection.stream.close();
 		this.connections.clear();
 	}
-	/** The order pages are driven in: the one the Host sent somewhere, suspect ones last, the one in front, then the most recently active. */
+	/** The order pages are driven in: the one whose panel asked, the one the Host sent somewhere, suspect ones last, the one in front, then the most recently active. */
 	ordered() {
-		const rank = (connection) => (connection.suspect ? 0 : 4) + (connection.windowId === this.preferred ? 2 : 0) + (connection.focused ? 1 : 0);
+		const asker = [...this.askers].reverse().find((entry) => this.connections.has(entry.windowId))?.windowId;
+		const rank = (connection) => (connection.suspect ? 0 : 4) + (connection.windowId === this.preferred ? 2 : 0) + (connection.focused ? 1 : 0) + (connection.windowId === asker && !connection.suspect ? 8 : 0);
 		return [...this.connections.values()].sort((a, b) => rank(b) - rank(a) || b.lastActive - a.lastActive);
 	}
 	/** Forget a connection; its calls in flight settle as `disconnected` at once rather than waiting for their timeout. */
@@ -441,6 +472,7 @@ function pageChannelRoutes(channel, options) {
 				send: (data) => {
 					write("call", data);
 				},
+				notify: write,
 				close: end
 			}, shellWindow);
 			const beat = setInterval(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acrylblends",
-  "version": "1.0.10",
+  "version": "1.1.0",
   "description": "The Acryl web framework (import { Acryl } from \"acrylblends\") and the acrylblends command that scaffolds Cordis apps.",
   "license": "MIT",
   "type": "module",