zidane-ui 9.0.4 → 9.1.3

package/README.md

@@ -16,7 +16,7 @@ Peers: `react` and `react-dom` ^19.3, `motion` ^13.5, and two optional ones:
 - `zidane` ^8, needed by the adapters (`zidane-ui/adapters`), the server helpers (`zidane-ui/server`) and these areas: chat (`zidane-ui/chat*`), approvals, app, files, git, keybindings, machines, onboarding (the setup wizard), palette (`palette/rank.worker` included), session, settings, terminal and workspace. They call `zidane/chat/pure` at runtime: formatters, diffs, the live-event reducer. That slice is browser-safe and React-free, so a browser bundle never pulls the agent runtime. Without `zidane` you can use the design system (`zidane-ui`, `zidane-ui/code/editor`, the highlight and patch-parse workers, `labels`, `uno`), the appearance area, and the headless and testing entries of files and terminal.
 - `unocss`, only for `zidane-ui/uno` (the token palette as a UnoCSS preset).
 
-The kit's other dependencies load where they're used: `shiki` (code highlighting, on first use or in a worker), Tiptap (the composer), `react-markdown` + `remark-gfm` (the default Markdown slot), Radix's dropdown (the session filter menu), `@pierre/diffs` + `@pierre/trees` (the code editor and file tree), `@tahul/ghostty-web` (the terminal, on first use).
+The kit's other dependencies load where they're used: `@pierre/highlights` (code highlighting, on first use or in a worker), Tiptap (the composer), `react-markdown` + `remark-gfm` (the default Markdown slot), Radix's dropdown (the session filter menu), `@pierre/diffs` + `@pierre/trees` (the code editor and file tree), `@tahul/ghostty-web` (the terminal, on first use).
 
 ## Use
 
@@ -90,6 +90,8 @@ Pick one route:
 
 - **UnoCSS in the app:** `@import 'zidane-ui/styles/index.css';` after the Uno utilities (`… layer(zidane-ui);` to put it in a layer). In `uno.config.ts`: `presets: [presetIcons({ collections: { ph: () => import('@iconify-json/ph/icons.json').then((i) => i.default) } }), presetUno({ dark: { dark: '.dark' } }), presetZidane()]` (`import { presetZidane } from 'zidane-ui/uno'`), and `node_modules/zidane-ui/dist/**/*.js` in `content.filesystem` so the components' classes are generated. Your markup can then use `bg-zg-raised`, `text-zg-muted`, `bg-zg-danger/10`…
 
+Either way, extensions name icons at runtime (`icon: { gui: 'i-ph-rocket' }`) that no built stylesheet holds. Call `watchRuntimeIcons({ loadPhosphor: () => import('@iconify-json/ph/icons.json').then((m) => crispPhosphor(m.default)) })` once at startup: it adds the rule of each `i-ph-*` class the page shows without one, and loads the set only the first time one is missing.
+
 ## Theming
 
 Everything paints from `--zg-*` custom properties, with default-dark fallbacks, so the components render with no theme set.

package/dist/adapters/extension-modules.d.ts

@@ -0,0 +1,147 @@
+//#region src/adapters/extension-modules.d.ts
+/** Loads an extension's `ui.tsx` module: its exports by name (`zidane-ui/extensions`' `ExtensionModuleLoader`). */
+type ExtensionModuleLoad = (extensionId: string) => Promise<Readonly<Record<string, unknown>>>;
+/** The global the linked bundles read host modules from. */
+declare const EXTENSION_HOST_MODULES_GLOBAL = "__zidaneExtensionHostModules__";
+/** A module namespace (`import * as React from 'react'`). */
+type ExtensionHostModule = Readonly<Record<string, unknown>>;
+/** Host modules by specifier: what the app hands the extensions' components. */
+type ExtensionHostModules = Readonly<Record<string, ExtensionHostModule>>;
+/**
+ * Host modules by specifier, each a namespace or a loader of one (a function resolving the namespace): a
+ * loader runs the first time a bundle imports its specifier, so the app's first load stays small.
+ */
+type ExtensionHostModuleSources = Readonly<Record<string, ExtensionHostModule | (() => Promise<ExtensionHostModule>)>>;
+/** A linked bundle: its code, and the host modules it reads. */
+interface LinkedExtensionModule {
+  /** The bundle with its host-module imports rewritten to reads of the shared module map. */
+  code: string;
+  /** The host module specifiers the code reads, each once. */
+  uses: readonly string[];
+}
+/** A bundle that imports something the app does not provide. */
+declare class ExtensionModuleLinkError extends Error {
+  readonly specifiers: readonly string[];
+  /**
+   * @param specifiers - The specifiers the app has no module for.
+   */
+  constructor(specifiers: readonly string[]);
+}
+/**
+ * Rewrites a bundle's imports of host modules into reads of the host module map, so the code runs
+ * as a module with no imports. A bare import the map has no module for fails, every one named.
+ * Relative and URL imports are left alone (a self-contained bundle has none).
+ *
+ * @param code - One ESM module (zidane's `compileUiEntry` output).
+ * @param provided - Whether the app provides a specifier.
+ * @returns The linked code and the host modules it reads.
+ * @throws {ExtensionModuleLinkError} When it imports a bare specifier the app does not provide.
+ */
+declare function linkExtensionModule(code: string, provided: (specifier: string) => boolean): LinkedExtensionModule;
+/**
+ * Puts `modules` in the host module map linked bundles read (merged over what is there).
+ *
+ * @param modules - Host modules by specifier.
+ * @param target - The global object. Default `globalThis`.
+ */
+declare function installExtensionHostModules(modules: ExtensionHostModules, target?: object): void;
+/** One extension's bundle in the folder's listing: where it is (relative to the server's origin), or why it did not bundle. */
+type ServerExtensionBundle = {
+  hash: string;
+  url: string;
+} | {
+  errors: readonly string[];
+};
+/**
+ * Where an extension's bundle is, from the folder's current listing (`ServerExtensionsHost.bundle`);
+ * `fresh`: list again first (the listed URL went stale). `undefined`: it has none.
+ */
+type ServerExtensionBundleLookup = (extensionId: string, opts?: {
+  fresh?: boolean;
+}) => Promise<ServerExtensionBundle | undefined>;
+/** A bundle that could not be loaded: not listed, did not bundle, or the server refused. */
+declare class ExtensionModuleLoadError extends Error {
+  readonly extensionId: string;
+  /**
+   * @param extensionId - The extension.
+   * @param message - What went wrong.
+   */
+  constructor(extensionId: string, message: string);
+}
+/** Options for {@link createServerExtensionModuleLoader}. */
+interface ServerExtensionModuleLoaderOptions {
+  /** The server's HTTP origin (`https://zidane.example.com`). */
+  origin: string;
+  /** The client token. Absent: a server without auth. */
+  token?: string;
+  /** Where each bundle is: `ServerExtensionsHost.bundle`. */
+  bundle: ServerExtensionBundleLookup;
+  /** The host modules the components import, each a namespace or a loader of one. */
+  modules: ExtensionHostModuleSources;
+  /** `fetch`. Default: the global one. */
+  fetch?: typeof fetch;
+  /** Evaluates linked code as a module and returns its exports. Default: import from a `blob:` URL. */
+  importModule?: (code: string) => Promise<Readonly<Record<string, unknown>>>;
+}
+/** What {@link createServerExtensionModuleLoader} returns. */
+interface ServerExtensionModuleLoader {
+  /** `AppHostProvider`'s `loadExtensionModule`. A new function after {@link ServerExtensionModuleLoader.invalidate}. */
+  load: ExtensionModuleLoad;
+  /** A fresh `load` (the folder changed, an extension reloaded, the server came back): a module loads again. */
+  invalidate(): ExtensionModuleLoad;
+}
+/**
+ * Creates a loader of extension `ui.tsx` modules from zidane-server: each bundle where the folder's
+ * listing says, by its hash, linked against `modules`. A bundle URL the server no longer knows (it
+ * restarted since the listing) is looked up again in a fresh listing, once.
+ *
+ * @param options - The server's origin and token, where bundles are, the host modules.
+ */
+declare function createServerExtensionModuleLoader(options: ServerExtensionModuleLoaderOptions): ServerExtensionModuleLoader;
+/** Options for {@link createServerWebviewSources}. */
+interface ServerWebviewSourcesOptions {
+  /** The server's HTTP origin. */
+  origin: string;
+  /** The client token. Absent: a server without auth. */
+  token?: string;
+  /** The folder whose extensions the webviews belong to (`null`: none). */
+  cwd: () => string | null;
+  /** `fetch`. Default: the global one. */
+  fetch?: typeof fetch;
+  /** Called with a mint that failed. Default: a console warning. */
+  onError?: (error: unknown) => void;
+}
+/** Webview URLs from zidane-server, for `ExtensionWebview`'s `resolveSrc`. */
+interface ServerWebviewSources {
+  /**
+   * The URL a webview's iframe loads: a `url` source as given, a `file` source the URL the server
+   * minted for it (`null` until it answered; subscribers hear when it did).
+   */
+  resolveSrc(webview: {
+    id: string;
+    src: {
+      url: string;
+    } | {
+      file: string;
+    };
+  }): string | null;
+  /** Called when a minted URL arrives. Returns the unsubscribe. */
+  subscribe(listener: () => void): () => void;
+  /** Forgets the minted URLs (the folder changed): the next `resolveSrc` mints again. */
+  clear(): void;
+  /**
+   * Forgets the minted URLs and tells subscribers, so every shown webview mints again (a rebuild, a
+   * reconnect to a server that may have restarted and dropped its tickets).
+   */
+  reset(): void;
+}
+/**
+ * Creates the webview URL source over zidane-server: a `file` source is minted once per folder
+ * (`POST /zidane/extensions/webview?cwd=&id=`, with the token) into a URL under an unguessable ticket,
+ * served sandboxed with no network: the page talks to its extension only through the RPC bridge.
+ *
+ * @param options - The server's origin and token, the folder.
+ */
+declare function createServerWebviewSources(options: ServerWebviewSourcesOptions): ServerWebviewSources;
+//#endregion
+export { EXTENSION_HOST_MODULES_GLOBAL, ExtensionHostModule, ExtensionHostModuleSources, ExtensionHostModules, ExtensionModuleLinkError, ExtensionModuleLoad, ExtensionModuleLoadError, LinkedExtensionModule, ServerExtensionBundle, ServerExtensionBundleLookup, ServerExtensionModuleLoader, ServerExtensionModuleLoaderOptions, ServerWebviewSources, ServerWebviewSourcesOptions, createServerExtensionModuleLoader, createServerWebviewSources, installExtensionHostModules, linkExtensionModule };

package/dist/adapters/extension-modules.js

@@ -0,0 +1,244 @@
+import { SERVER_EXTENSIONS_WEBVIEW_PATH } from "zidane/ipc/browser";
+//#region src/adapters/extension-modules.ts
+/**
+* Loading an extension's `ui.tsx` bundle in a browser, from zidane-server.
+*
+* The server bundles each extension's `ui` entry into one ESM module (zidane's `compileUiEntry`)
+* and keeps the host modules (`react`, `react/jsx-runtime`, `react-dom`, `zidane-ui/*`) as bare
+* imports: the components must run on the app's own React and kit, or their hooks and contexts
+* split from the app's. A page can't map bare specifiers to modules it already loaded (a vite
+* build has no stable URL for its React, and a static import map can't name them), so the loader
+* links the bundle against a host module map instead: each `import … from '<host module>'`
+* becomes a read of the module the app put in the map ({@link linkExtensionModule}), and the
+* linked code is imported from a `blob:` URL. Where each bundle is comes from the folder's
+* `extensions.ui.list` (`ServerExtensionsHost.bundle`); the bundle itself is fetched with the
+* client's token, by content hash (`immutable`), so the browser cache keeps it until the code changes.
+*
+*   const loader = createServerExtensionModuleLoader({
+*     origin: 'https://zidane.example.com', token, bundle: host.bundle,
+*     modules: { react: React, 'react/jsx-runtime': jsxRuntime, 'zidane-ui/extensions/kit': kit },
+*   });
+*   <AppHostProvider host={host} loadExtensionModule={loader.load}>…
+*/
+/** The global the linked bundles read host modules from. */
+const EXTENSION_HOST_MODULES_GLOBAL = "__zidaneExtensionHostModules__";
+/** A bundle that imports something the app does not provide. */
+var ExtensionModuleLinkError = class extends Error {
+	specifiers;
+	/**
+	* @param specifiers - The specifiers the app has no module for.
+	*/
+	constructor(specifiers) {
+		super(`the extension module imports ${specifiers.map((s) => `"${s}"`).join(", ")}, which this app does not provide`);
+		this.specifiers = specifiers;
+		this.name = "ExtensionModuleLinkError";
+	}
+};
+const HELPER = "__zidaneHostModule$";
+const STATIC_IMPORT = /^[ \t]*import\s*(?:([\w$]+)\s*,?\s*)?(?:\*\s*as\s+([\w$]+)|\{([^}]*)\})?\s*(?:from\s*)?(["'])([^"'\n]+)\4[ \t]*;?/gm;
+const RE_EXPORT = /^[ \t]*export\s*(?:\*\s*(?:as\s+([\w$]+)\s*)?|\{([^}]*)\})\s*from\s*(["'])([^"'\n]+)\3[ \t]*;?/gm;
+const DYNAMIC_IMPORT = /\bimport\(\s*(["'])([^"'\n]+)\1\s*\)/g;
+/** `a, b as c, "d" as e, default as f` → a destructuring pattern `a, b: c, "d": e, default: f`. */
+function bindings(list) {
+	return list.split(",").map((part) => part.trim()).filter(Boolean).map((part) => part.replace(/^(["']?[\w$-]+["']?)\s+as\s+([\w$]+)$/, "$1: $2")).join(", ");
+}
+const isBare = (specifier) => !/^(?:[./]|[a-z][a-z\d+.-]*:)/i.test(specifier);
+/**
+* Rewrites a bundle's imports of host modules into reads of the host module map, so the code runs
+* as a module with no imports. A bare import the map has no module for fails, every one named.
+* Relative and URL imports are left alone (a self-contained bundle has none).
+*
+* @param code - One ESM module (zidane's `compileUiEntry` output).
+* @param provided - Whether the app provides a specifier.
+* @returns The linked code and the host modules it reads.
+* @throws {ExtensionModuleLinkError} When it imports a bare specifier the app does not provide.
+*/
+function linkExtensionModule(code, provided) {
+	const missing = /* @__PURE__ */ new Set();
+	const uses = /* @__PURE__ */ new Set();
+	const host = (specifier) => {
+		if (!isBare(specifier)) return void 0;
+		if (!provided(specifier)) missing.add(specifier);
+		uses.add(specifier);
+		return `${HELPER}(${JSON.stringify(specifier)})`;
+	};
+	let seq = 0;
+	let linked = code.replace(STATIC_IMPORT, (statement, def, ns, named, _q, specifier) => {
+		if (!def && !ns && named === void 0 && isBare(specifier) && specifier.endsWith(".css")) return "";
+		const read = host(specifier);
+		if (!read) return statement;
+		const out = [];
+		if (def) out.push(`const ${def} = ${HELPER}.default(${JSON.stringify(specifier)});`);
+		if (ns) out.push(`const ${ns} = ${read};`);
+		if (named !== void 0 && bindings(named)) out.push(`const { ${bindings(named)} } = ${read};`);
+		return out.join(" ");
+	});
+	linked = linked.replace(RE_EXPORT, (statement, as, named, _q, specifier) => {
+		const read = host(specifier);
+		if (!read) return statement;
+		if (named === void 0) {
+			if (!as) throw new ExtensionModuleLinkError([`export * from "${specifier}"`]);
+			return `const ${as} = ${read}; export { ${as} };`;
+		}
+		const pairs = named.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+			const [from, to = from] = part.split(/\s+as\s+/);
+			return {
+				from,
+				to,
+				local: `${HELPER}re${++seq}`
+			};
+		});
+		return `const { ${pairs.map((p) => `${p.from}: ${p.local}`).join(", ")} } = ${read}; export { ${pairs.map((p) => `${p.local} as ${p.to}`).join(", ")} };`;
+	});
+	linked = linked.replace(DYNAMIC_IMPORT, (call, _q, specifier) => {
+		const read = host(specifier);
+		return read ? `Promise.resolve().then(() => ${read})` : call;
+	});
+	if (missing.size > 0) throw new ExtensionModuleLinkError([...missing]);
+	const global = JSON.stringify(EXTENSION_HOST_MODULES_GLOBAL);
+	return {
+		code: `const ${HELPER} = (s) => { const m = globalThis[${global}]?.[s]; if (!m) throw new Error('zidane: no host module ' + s); return m; };\n${HELPER}.default = (s) => { const m = ${HELPER}(s); return 'default' in m ? m.default : m; };\n` + linked,
+		uses: [...uses]
+	};
+}
+/**
+* Puts `modules` in the host module map linked bundles read (merged over what is there).
+*
+* @param modules - Host modules by specifier.
+* @param target - The global object. Default `globalThis`.
+*/
+function installExtensionHostModules(modules, target = globalThis) {
+	const slot = target;
+	slot[EXTENSION_HOST_MODULES_GLOBAL] = {
+		...slot[EXTENSION_HOST_MODULES_GLOBAL],
+		...modules
+	};
+}
+/** A bundle that could not be loaded: not listed, did not bundle, or the server refused. */
+var ExtensionModuleLoadError = class extends Error {
+	extensionId;
+	/**
+	* @param extensionId - The extension.
+	* @param message - What went wrong.
+	*/
+	constructor(extensionId, message) {
+		super(`${extensionId}: ${message}`);
+		this.extensionId = extensionId;
+		this.name = "ExtensionModuleLoadError";
+	}
+};
+const blobImport = async (code) => {
+	const url = URL.createObjectURL(new Blob([code], { type: "text/javascript" }));
+	try {
+		return await import(
+			/* @vite-ignore */
+			url
+);
+	} finally {
+		URL.revokeObjectURL(url);
+	}
+};
+/**
+* Creates a loader of extension `ui.tsx` modules from zidane-server: each bundle where the folder's
+* listing says, by its hash, linked against `modules`. A bundle URL the server no longer knows (it
+* restarted since the listing) is looked up again in a fresh listing, once.
+*
+* @param options - The server's origin and token, where bundles are, the host modules.
+*/
+function createServerExtensionModuleLoader(options) {
+	const doFetch = options.fetch ?? ((input, init) => fetch(input, init));
+	const importModule = options.importModule ?? blobImport;
+	const headers = options.token ? { authorization: `Bearer ${options.token}` } : {};
+	const provided = (specifier) => Object.hasOwn(options.modules, specifier);
+	const resolved = /* @__PURE__ */ new Map();
+	const resolve = (specifier) => {
+		let module = resolved.get(specifier);
+		if (!module) {
+			const source = options.modules[specifier];
+			module = typeof source === "function" ? source() : Promise.resolve(source);
+			resolved.set(specifier, module);
+			module.catch(() => resolved.delete(specifier));
+		}
+		return module;
+	};
+	const link = async (code) => {
+		const linked = linkExtensionModule(code, provided);
+		const modules = await Promise.all(linked.uses.map(async (s) => [s, await resolve(s)]));
+		installExtensionHostModules(Object.fromEntries(modules));
+		return linked.code;
+	};
+	const fetchBundle = (url) => doFetch(/^https?:/i.test(url) ? url : `${options.origin}${url}`, { headers });
+	const make = () => async (extensionId) => {
+		let bundle = await options.bundle(extensionId);
+		if (!bundle) throw new ExtensionModuleLoadError(extensionId, "no ui bundle on the server");
+		if ("errors" in bundle) throw new ExtensionModuleLoadError(extensionId, bundle.errors.join("; "));
+		let response = await fetchBundle(bundle.url);
+		if (response.status === 404) {
+			bundle = await options.bundle(extensionId, { fresh: true });
+			if (!bundle) throw new ExtensionModuleLoadError(extensionId, "no ui bundle on the server");
+			if ("errors" in bundle) throw new ExtensionModuleLoadError(extensionId, bundle.errors.join("; "));
+			response = await fetchBundle(bundle.url);
+		}
+		if (!response.ok) throw new ExtensionModuleLoadError(extensionId, `the server answered ${response.status} for its bundle`);
+		return importModule(await link(await response.text()));
+	};
+	const loader = {
+		load: make(),
+		invalidate() {
+			loader.load = make();
+			return loader.load;
+		}
+	};
+	return loader;
+}
+/**
+* Creates the webview URL source over zidane-server: a `file` source is minted once per folder
+* (`POST /zidane/extensions/webview?cwd=&id=`, with the token) into a URL under an unguessable ticket,
+* served sandboxed with no network: the page talks to its extension only through the RPC bridge.
+*
+* @param options - The server's origin and token, the folder.
+*/
+function createServerWebviewSources(options) {
+	const doFetch = options.fetch ?? ((input, init) => fetch(input, init));
+	const onError = options.onError ?? ((error) => console.warn("[zidane-ui] webview:", error));
+	const minted = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		resolveSrc(webview) {
+			if ("url" in webview.src) return webview.src.url;
+			const cwd = options.cwd();
+			if (!cwd) return null;
+			const key = `${cwd}\u0000${webview.id}`;
+			if (minted.has(key)) return minted.get(key) ?? null;
+			minted.set(key, null);
+			const url = `${options.origin}${SERVER_EXTENSIONS_WEBVIEW_PATH}?cwd=${encodeURIComponent(cwd)}&id=${encodeURIComponent(webview.id)}`;
+			doFetch(url, {
+				method: "POST",
+				headers: options.token ? { authorization: `Bearer ${options.token}` } : {}
+			}).then(async (response) => {
+				if (!response.ok) throw new Error(`the server answered ${response.status} for webview ${webview.id}`);
+				const { url: path } = await response.json();
+				if (!minted.has(key)) return;
+				minted.set(key, /^https?:/i.test(path) ? path : `${options.origin}${path}`);
+				for (const listener of [...listeners]) listener();
+			}).catch((error) => {
+				minted.delete(key);
+				onError(error);
+			});
+			return null;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		clear() {
+			minted.clear();
+		},
+		reset() {
+			minted.clear();
+			for (const listener of [...listeners]) listener();
+		}
+	};
+}
+//#endregion
+export { EXTENSION_HOST_MODULES_GLOBAL, ExtensionModuleLinkError, ExtensionModuleLoadError, createServerExtensionModuleLoader, createServerWebviewSources, installExtensionHostModules, linkExtensionModule };

package/dist/adapters/index.d.ts

@@ -1,6 +1,7 @@
 import { BrowserAppearanceHostOptions, createBrowserAppearanceHost } from "./browser-appearance-host.js";
 import { BrowserKeybindingsHostOptions, createBrowserKeybindingsHost } from "./browser-keybindings-host.js";
 import { BrowserWorkspaceHostOptions, createBrowserWorkspaceHost } from "./browser-workspace-host.js";
+import { EXTENSION_HOST_MODULES_GLOBAL, ExtensionHostModule, ExtensionHostModuleSources, ExtensionHostModules, ExtensionModuleLinkError, ExtensionModuleLoad, ExtensionModuleLoadError, LinkedExtensionModule, ServerExtensionBundle, ServerExtensionBundleLookup, ServerExtensionModuleLoader, ServerExtensionModuleLoaderOptions, ServerWebviewSources, ServerWebviewSourcesOptions, createServerExtensionModuleLoader, createServerWebviewSources, installExtensionHostModules, linkExtensionModule } from "./extension-modules.js";
 import { RunContext, RunFn, RunHost, RunHostOptions, createRunHost } from "./run-host.js";
 import { FromWorker, MessageEndpoint, ToWorker, WORKER_PROTOCOL_VERSION, WorkerRunInput, decodeFromWorker, decodeToWorker } from "./worker-protocol.js";
 import { WorkerHostOptions, createWorkerHost, exposeRunHost } from "./worker-host.js";
@@ -20,8 +21,9 @@ import { SERVER_MACHINES_HOST_ID, ServerMachinesHost, ServerMachinesHostOptions,
 import { ServerOnboardingHost, ServerOnboardingHostOptions, createServerOnboardingHost } from "./server-onboarding-host.js";
 import { ServerSettingsHost, ServerSettingsHostOptions, createServerSettingsHost } from "./server-settings-host.js";
 import { ServerSidebarHostOptions, createServerSidebarHost } from "./server-sidebar-host.js";
+import { ExtensionFlowStepHandler, ExtensionsClientAnnounce, ServerExtensionAssetsAccess, ServerExtensionCommandWire, ServerExtensionCommands, ServerExtensionDialogs, ServerExtensionsHost, ServerExtensionsHostOptions, createServerExtensionsHost } from "./server-extensions-host.js";
 import { applyLiveEvent, closeThinkingSegment, finishLive } from "../chat/headless/streams/live-events.js";
 import { LiveState, LiveStateOptions, LiveTranscript, createLiveState } from "./live.js";
 import "./live-events.js";
 import { StreamPacer, StreamPacerOptions, createStreamPacer } from "./stream-pacer.js";
-export { AnswerBody, BrowserAppearanceHostOptions, BrowserKeybindingsHostOptions, BrowserWorkspaceHostOptions, FromWorker, HydrateResponse, LiveState, LiveStateOptions, LiveTranscript, MessageEndpoint, RunContext, RunFn, RunHost, RunHostOptions, SERVER_AUTH_CHECK_PATH, SERVER_MACHINES_HOST_ID, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, ServerApprovalsHostOptions, ServerCallError, type ServerClient, type ServerClientOptions, type ServerClientState, ServerComposerHost, ServerComposerHostOptions, ServerConnectionError, ServerFilesHostOptions, ServerGitHostOptions, ServerHost, ServerHostOptions, ServerMachinesHost, ServerMachinesHostOptions, ServerOnboardingHost, ServerOnboardingHostOptions, ServerPaletteHost, ServerPaletteHostOptions, type ServerRefusal, ServerSessionHost, ServerSessionHostOptions, ServerSettingsHost, ServerSettingsHostOptions, ServerSidebarHostOptions, ServerTerminalHostOptions, SseHost, SseHostOptions, SseParser, SseRecord, StreamPacer, StreamPacerOptions, StreamRecord, ToWorker, WORKER_PROTOCOL_VERSION, WorkerHostOptions, WorkerRunInput, applyLiveEvent, attachmentsFromPreviews, closeThinkingSegment, createBrowserAppearanceHost, createBrowserKeybindingsHost, createBrowserWorkspaceHost, createLiveState, createRunHost, createServerApprovalsHost, createServerClient, createServerComposerHost, createServerFilesHost, createServerGitHost, createServerHost, createServerMachinesHost, createServerOnboardingHost, createServerPaletteHost, createServerSessionHost, createServerSettingsHost, createServerSidebarHost, createServerTerminalHost, createSseHost, createSseParser, createStreamPacer, createWorkerHost, decodeFromWorker, decodeToWorker, encodeSseRecord, exposeRunHost, finishLive, formatCursor, parseCursor, toChatModelProviders, toChatSession, toSidebarListSession };
+export { AnswerBody, BrowserAppearanceHostOptions, BrowserKeybindingsHostOptions, BrowserWorkspaceHostOptions, EXTENSION_HOST_MODULES_GLOBAL, ExtensionFlowStepHandler, ExtensionHostModule, ExtensionHostModuleSources, ExtensionHostModules, ExtensionModuleLinkError, ExtensionModuleLoad, ExtensionModuleLoadError, ExtensionsClientAnnounce, FromWorker, HydrateResponse, LinkedExtensionModule, LiveState, LiveStateOptions, LiveTranscript, MessageEndpoint, RunContext, RunFn, RunHost, RunHostOptions, SERVER_AUTH_CHECK_PATH, SERVER_MACHINES_HOST_ID, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, ServerApprovalsHostOptions, ServerCallError, type ServerClient, type ServerClientOptions, type ServerClientState, ServerComposerHost, ServerComposerHostOptions, ServerConnectionError, ServerExtensionAssetsAccess, ServerExtensionBundle, ServerExtensionBundleLookup, ServerExtensionCommandWire, ServerExtensionCommands, ServerExtensionDialogs, ServerExtensionModuleLoader, ServerExtensionModuleLoaderOptions, ServerExtensionsHost, ServerExtensionsHostOptions, ServerFilesHostOptions, ServerGitHostOptions, ServerHost, ServerHostOptions, ServerMachinesHost, ServerMachinesHostOptions, ServerOnboardingHost, ServerOnboardingHostOptions, ServerPaletteHost, ServerPaletteHostOptions, type ServerRefusal, ServerSessionHost, ServerSessionHostOptions, ServerSettingsHost, ServerSettingsHostOptions, ServerSidebarHostOptions, ServerTerminalHostOptions, ServerWebviewSources, ServerWebviewSourcesOptions, SseHost, SseHostOptions, SseParser, SseRecord, StreamPacer, StreamPacerOptions, StreamRecord, ToWorker, WORKER_PROTOCOL_VERSION, WorkerHostOptions, WorkerRunInput, applyLiveEvent, attachmentsFromPreviews, closeThinkingSegment, createBrowserAppearanceHost, createBrowserKeybindingsHost, createBrowserWorkspaceHost, createLiveState, createRunHost, createServerApprovalsHost, createServerClient, createServerComposerHost, createServerExtensionModuleLoader, createServerExtensionsHost, createServerFilesHost, createServerGitHost, createServerHost, createServerMachinesHost, createServerOnboardingHost, createServerPaletteHost, createServerSessionHost, createServerSettingsHost, createServerSidebarHost, createServerTerminalHost, createServerWebviewSources, createSseHost, createSseParser, createStreamPacer, createWorkerHost, decodeFromWorker, decodeToWorker, encodeSseRecord, exposeRunHost, finishLive, formatCursor, installExtensionHostModules, linkExtensionModule, parseCursor, toChatModelProviders, toChatSession, toSidebarListSession };

package/dist/adapters/index.js

@@ -1,6 +1,7 @@
 import { createBrowserAppearanceHost } from "./browser-appearance-host.js";
 import { createBrowserKeybindingsHost } from "./browser-keybindings-host.js";
 import { createBrowserWorkspaceHost } from "./browser-workspace-host.js";
+import { EXTENSION_HOST_MODULES_GLOBAL, ExtensionModuleLinkError, ExtensionModuleLoadError, createServerExtensionModuleLoader, createServerWebviewSources, installExtensionHostModules, linkExtensionModule } from "./extension-modules.js";
 import { applyLiveEvent, closeThinkingSegment, finishLive } from "../chat/headless/streams/live-events.js";
 import { createLiveState } from "./live.js";
 import { createRunHost } from "./run-host.js";
@@ -22,5 +23,6 @@ import { SERVER_MACHINES_HOST_ID, createServerMachinesHost } from "./server-mach
 import { createServerOnboardingHost } from "./server-onboarding-host.js";
 import { createServerSettingsHost } from "./server-settings-host.js";
 import { createServerSidebarHost } from "./server-sidebar-host.js";
+import { createServerExtensionsHost } from "./server-extensions-host.js";
 import { createStreamPacer } from "./stream-pacer.js";
-export { SERVER_AUTH_CHECK_PATH, SERVER_MACHINES_HOST_ID, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, ServerCallError, ServerConnectionError, WORKER_PROTOCOL_VERSION, applyLiveEvent, attachmentsFromPreviews, closeThinkingSegment, createBrowserAppearanceHost, createBrowserKeybindingsHost, createBrowserWorkspaceHost, createLiveState, createRunHost, createServerApprovalsHost, createServerClient, createServerComposerHost, createServerFilesHost, createServerGitHost, createServerHost, createServerMachinesHost, createServerOnboardingHost, createServerPaletteHost, createServerSessionHost, createServerSettingsHost, createServerSidebarHost, createServerTerminalHost, createSseHost, createSseParser, createStreamPacer, createWorkerHost, decodeFromWorker, decodeToWorker, encodeSseRecord, exposeRunHost, finishLive, formatCursor, parseCursor, toChatModelProviders, toChatSession, toSidebarListSession };
+export { EXTENSION_HOST_MODULES_GLOBAL, ExtensionModuleLinkError, ExtensionModuleLoadError, SERVER_AUTH_CHECK_PATH, SERVER_MACHINES_HOST_ID, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, ServerCallError, ServerConnectionError, WORKER_PROTOCOL_VERSION, applyLiveEvent, attachmentsFromPreviews, closeThinkingSegment, createBrowserAppearanceHost, createBrowserKeybindingsHost, createBrowserWorkspaceHost, createLiveState, createRunHost, createServerApprovalsHost, createServerClient, createServerComposerHost, createServerExtensionModuleLoader, createServerExtensionsHost, createServerFilesHost, createServerGitHost, createServerHost, createServerMachinesHost, createServerOnboardingHost, createServerPaletteHost, createServerSessionHost, createServerSettingsHost, createServerSidebarHost, createServerTerminalHost, createServerWebviewSources, createSseHost, createSseParser, createStreamPacer, createWorkerHost, decodeFromWorker, decodeToWorker, encodeSseRecord, exposeRunHost, finishLive, formatCursor, installExtensionHostModules, linkExtensionModule, parseCursor, toChatModelProviders, toChatSession, toSidebarListSession };

package/dist/adapters/live.d.ts

@@ -47,6 +47,12 @@ interface LiveStateOptions {
   onOpen?: (sessionId: string) => void;
   /** Called with the session id when the last subscriber of its transcript leaves. An adapter stops the session's stream here. */
   onClose?: (sessionId: string) => void;
+  /**
+   * Forget the transcripts nobody reads: when a session's last subscriber leaves, every window goes but the
+   * open sessions', the running ones' and the 12 most recently opened. For an adapter that loads a transcript
+   * again in `onOpen`. Default: `false`.
+   */
+  evict?: boolean;
 }
 /**
  * Creates the stores a {@link ChatHost} exposes: the session list, per-session transcripts, and pending interactions.

package/dist/adapters/live.js

@@ -3,6 +3,8 @@ import { applyLiveEvent, finishLive } from "../chat/headless/streams/live-events
 import { SessionStreamStore } from "../chat/headless/streams/store.js";
 import { transcriptSnapshot } from "../chat/headless/streams/transcript.js";
 //#region src/adapters/live.ts
+/** Closed sessions whose windows stay, most recent first: the desktop's prewarm window (`sidebar/directory.ts`) less the open one. */
+const RECENT_KEPT = 12;
 /**
 * Creates the stores a {@link ChatHost} exposes: the session list, per-session transcripts, and pending interactions.
 *
@@ -18,6 +20,24 @@ function createLiveState(options = {}) {
 	const pendings = /* @__PURE__ */ new Map();
 	const allPending = writable([]);
 	const readables = /* @__PURE__ */ new Map();
+	const subscribers = /* @__PURE__ */ new Map();
+	/** Recently opened sessions, the most recent last. */
+	const recent = /* @__PURE__ */ new Set();
+	const visit = (sessionId) => {
+		if (!options.evict) return;
+		recent.delete(sessionId);
+		recent.add(sessionId);
+		if (recent.size > RECENT_KEPT) recent.delete(recent.values().next().value);
+	};
+	const evict = () => {
+		const keep = /* @__PURE__ */ new Set([...recent, ...subscribers.keys()]);
+		store.evictExcept(keep);
+		for (const sessionId of /* @__PURE__ */ new Set([...transcripts.keys(), ...readables.keys()])) {
+			if (keep.has(sessionId) || store.getRunningSnapshot(sessionId) || store.getPageSnapshot(sessionId).loadingEarlier) continue;
+			transcripts.delete(sessionId);
+			readables.delete(sessionId);
+		}
+	};
 	const transcript = (sessionId) => {
 		let t = transcripts.get(sessionId);
 		if (!t) {
@@ -51,21 +71,31 @@ function createLiveState(options = {}) {
 		sessions,
 		transcript,
 		readable(sessionId, extra) {
+			visit(sessionId);
 			let r = readables.get(sessionId);
 			if (r) return r;
 			const { state } = transcript(sessionId);
-			let subscribers = 0;
 			r = {
 				get: state.get,
 				subscribe(onChange) {
 					const off = state.subscribe(onChange);
-					if (subscribers++ === 0) options.onOpen?.(sessionId);
+					const count = subscribers.get(sessionId) ?? 0;
+					subscribers.set(sessionId, count + 1);
+					visit(sessionId);
+					if (count === 0) options.onOpen?.(sessionId);
 					let done = false;
 					return () => {
 						if (done) return;
 						done = true;
 						off();
-						if (--subscribers === 0) options.onClose?.(sessionId);
+						const left = subscribers.get(sessionId) - 1;
+						if (left > 0) {
+							subscribers.set(sessionId, left);
+							return;
+						}
+						subscribers.delete(sessionId);
+						options.onClose?.(sessionId);
+						if (options.evict) evict();
 					};
 				},
 				...extra?.loadEarlier ? { loadEarlier: extra.loadEarlier } : {}

package/dist/adapters/server-composer-host.js

@@ -19,12 +19,10 @@ import { fmtTokens, formatCostLabel } from "zidane/chat/pure";
 * (`models.list`, refetched on `settings:changed` / `catalog:changed`), the
 * context gauge and breakdown (`sessions.contextBreakdown`, refetched on a
 * session's `turn:end` / `compacting:end`), the run counters (a run meter fed
-* by `run:start`, `stream:progress`, `turn:end`, `run:end`), the extensions'
-* strip (`hud:state` pushes) and the picker preferences (this browser's
-* `localStorage`).
+* by `run:start`, `stream:progress`, `turn:end`, `run:end`) and the picker
+* preferences (this browser's `localStorage`).
 * A session's settled cost and a joined run's progress come from its header
-* (`sessions.getHeader` with `usage`), the strip's current snapshot from
-* `hud.get`. The extensions' completion triggers, items and submit hooks
+* (`sessions.getHeader` with `usage`). The extensions' completion triggers, items and submit hooks
 * (`completions.*`, triggers refetched on `catalog:changed`), the agent
 * profiles (`agents.list`), the picks remembered across apps (`prefs.*`,
 * the server's `state.json`), the files `@` lists under a folder
@@ -56,11 +54,24 @@ function mapped(resource, map) {
 		subscribe: resource.subscribe
 	};
 }
-/** `models.list`'s providers as catalog rows. */
+/**
+* `models.list`'s providers as catalog rows. A provider with several accounts lists once per account,
+* each with that account's own models (the provider's when it has none): the picker shows the active
+* account's list, and a session pinned to an account picks from that account's.
+*/
 function toModelEntries(providers) {
-	return providers.flatMap((p) => p.models.map((m) => ({
+	return providers.flatMap((p) => p.accounts?.length ? p.accounts.flatMap((a) => modelRows(p, a.models ?? p.models, {
+		id: a.id,
+		label: a.label,
+		...a.active ? { active: true } : {}
+	})) : modelRows(p, p.models));
+}
+/** One provider's (or one of its accounts') models as catalog rows. */
+function modelRows(p, models, account) {
+	return models.map((m) => ({
 		providerKey: p.key,
 		providerLabel: p.label,
+		...account ? { account } : {},
 		modelId: m.id,
 		modelName: m.name ?? m.id,
 		contextWindow: m.contextWindow ?? null,
@@ -71,7 +82,7 @@ function toModelEntries(providers) {
 			label,
 			...description ? { description } : {}
 		})) } : {}
-	})));
+	}));
 }
 /** `models.list`'s image models as the picker's Image tab lists them. */
 /** A session row as `#` lists it. */
@@ -100,19 +111,6 @@ function toImageRows(providers) {
 		...m.isDefault ? { isDefault: true } : {}
 	})));
 }
-/** A `hud:state` push as the strip's snapshot: each session's statuses, its badges. */
-function toHudSnapshot(signal) {
-	const sessions = {};
-	for (const [sessionId, byExtension] of Object.entries(signal.sessions ?? {})) sessions[sessionId] = Object.entries(byExtension).map(([extension, s]) => ({
-		extension,
-		text: s.text,
-		loader: s.loader
-	}));
-	return {
-		sessions,
-		badges: signal.badges ?? {}
-	};
-}
 /** The gauge a breakdown measures, with what the catalog says of its model. */
 function toContextStatus(breakdown, catalog, providerKey) {
 	const model = catalog.find((m) => m.modelId === breakdown.modelId && (!providerKey || m.providerKey === providerKey)) ?? catalog.find((m) => m.modelId === breakdown.modelId);
@@ -139,13 +137,7 @@ function createServerComposerHost(options) {
 	const unsubscribe = client.onSignal((signal) => {
 		for (const listener of listeners) listener(signal);
 	});
-	const offRuns = client.onSignal((signal) => {
-		meter.handle(signal);
-		if (signal.kind === "hud:state" && hudListeners.size > 0) {
-			const snapshot = toHudSnapshot(signal);
-			for (const listener of hudListeners) listener(snapshot);
-		}
-	});
+	const offRuns = client.onSignal((signal) => meter.handle(signal));
 	const on = (kinds, listener) => {
 		const filtered = (signal) => {
 			if (kinds.includes(signal.kind)) listener(signal);
@@ -204,7 +196,6 @@ function createServerComposerHost(options) {
 		return rows;
 	};
 	const meter = createRunMeter();
-	const hudListeners = /* @__PURE__ */ new Set();
 	const skills = async (scope) => {
 		const { skills: entries } = await client.call("catalog.skills", scope.cwd ? { cwd: scope.cwd } : {});
 		return entries.filter((entry) => entry.enabled).map((entry) => ({
@@ -439,16 +430,8 @@ function createServerComposerHost(options) {
 			noteProgress: meter.noteProgress,
 			settleCost: meter.settleCost
 		},
-		hud: {
-			...client.can("hud.get") ? { get: async () => toHudSnapshot(await client.call("hud.get", {})) } : {},
-			onState: (listener) => {
-				hudListeners.add(listener);
-				return () => void hudListeners.delete(listener);
-			}
-		},
 		close() {
 			listeners.clear();
-			hudListeners.clear();
 			unsubscribe();
 			offRuns();
 			resources.reset();