zidane-ui 9.0.4 → 9.1.3

package/dist/extensions/headless/select.d.ts

@@ -0,0 +1,120 @@
+import { ExtensionItem, RendererTarget, RendererWire, SelectOptionWire, SlotName, SlotWire, WireSettings } from "./wire.js";
+import { ExtensionAccessScope } from "./host.js";
+import { ExtensionConfigValue, WireExtensionConfigItem } from "zidane";
+//#region src/extensions/headless/select.d.ts
+/**
+ * The slot items for one place, lowest `order` first (stable). Items scoped to a session show only
+ * beside that session; unscoped items show everywhere. A `transcript.turn-end` item that names a turn
+ * shows only after that turn (`turnId`); one that names none, only where no turn is given (the end of
+ * the transcript).
+ *
+ * @param items - Every slot item.
+ * @param at - The place.
+ * @param sessionId - The session the place belongs to, if any.
+ * @param turnId - `transcript.turn-end`: the turn the place follows. Absent: the end of the transcript.
+ */
+declare function slotItems(items: readonly ExtensionItem<'slot'>[], at: SlotName, sessionId?: string, turnId?: string): readonly ExtensionItem<'slot'>[];
+/**
+ * The scope an action needs that this client's token lacks, or `null` when it may run it: the token
+ * grants `granted` (`null` or absent: not limited, as a local or in-process host), the action needs
+ * `required` (default `admin`, as zidane's).
+ *
+ * @param granted - The token's scope (`ExtensionsHost.scope`).
+ * @param required - The action's `scope`.
+ */
+declare function missingScope(granted: ExtensionAccessScope | null | undefined, required: ExtensionAccessScope | undefined): ExtensionAccessScope | null;
+/** How many `app.titlebar` items one extension shows: as many as its composer badges. */
+declare const TITLEBAR_ITEMS_PER_EXTENSION = 8;
+/**
+ * The `app.titlebar` items, lowest `order` first, at most {@link TITLEBAR_ITEMS_PER_EXTENSION} per
+ * extension (its first ones in that order).
+ *
+ * @param items - Every slot item.
+ * @param sessionId - The session on screen: its session-scoped items show too.
+ */
+declare function titlebarItems(items: readonly ExtensionItem<'slot'>[], sessionId?: string): readonly ExtensionItem<'slot'>[];
+/**
+ * Whether a renderer draws `target`. Languages compare case-insensitively; a renderer for several
+ * tools draws each of them, and one for `'*'` draws every tool. A block id matches as given or, with
+ * `extension`, under the extension that registered the renderer (`<extension>/<id>`, the form
+ * `CommandOutputBlock.custom.renderer` and `PanelCustomItem.renderer` carry).
+ *
+ * @param renderer - A renderer's wire form.
+ * @param target - What needs drawing (one tool name for a tool).
+ * @param extension - The extension that registered the renderer.
+ */
+declare function rendererMatches(renderer: RendererWire, target: RendererTarget, extension?: string): boolean;
+/**
+ * The renderers for `target`, in the host's order: the first draws, the next ones take over when a
+ * `fallthrough` renderer draws nothing.
+ *
+ * @param items - Every renderer item.
+ * @param target - What needs drawing.
+ */
+declare function renderersFor(items: readonly ExtensionItem<'renderer'>[], target: RendererTarget): readonly ExtensionItem<'renderer'>[];
+/**
+ * The full id of a panel an extension names: `<extension>/<id>` when that extension has one by
+ * that id, else the id as given (already full, or a built-in tab such as `todos`).
+ *
+ * @param extension - The naming extension.
+ * @param panel - The id it named.
+ * @param panels - Every panel item.
+ */
+declare function qualifyPanelId(extension: string, panel: string, panels: readonly ExtensionItem<'panel'>[]): string;
+/**
+ * The options whose label, description or group contains every word of `query` (case-insensitive).
+ *
+ * @param options - A select dialog's options.
+ * @param query - What the user typed.
+ */
+declare function filterSelectOptions(options: readonly SelectOptionWire[], query: string): readonly SelectOptionWire[];
+/**
+ * Options grouped in first-seen group order; ungrouped options come first under `group: undefined`.
+ *
+ * @param options - The options to group.
+ */
+declare function groupSelectOptions(options: readonly SelectOptionWire[]): readonly {
+  group: string | undefined;
+  options: readonly SelectOptionWire[];
+}[];
+/** A setting's value as a form holds it. */
+type SettingValue = ExtensionConfigValue;
+/**
+ * The value a row shows: the stored value when its type fits, else the default.
+ *
+ * @param item - The row.
+ * @param stored - The stored value, if any.
+ */
+declare function settingValue(item: WireExtensionConfigItem, stored: unknown): SettingValue;
+/**
+ * Every row's starting value, by `extension` then key.
+ *
+ * @param settings - The wire settings.
+ */
+declare function settingsValues(settings: WireSettings): Record<string, Record<string, SettingValue>>;
+/**
+ * Whether a declarative config entry sets this setting (shown, not editable).
+ *
+ * @param settings - The wire settings.
+ * @param extension - The extension.
+ * @param key - The setting.
+ */
+declare function isSettingLocked(settings: WireSettings, extension: string, key: string): boolean;
+/**
+ * Clamps and snaps a number the way zidane does (`clampExtensionConfigNumber`), so a typed value
+ * persists the same from every client.
+ *
+ * @param item - A number row.
+ * @param n - The typed number.
+ */
+declare function clampSettingNumber(item: Extract<WireExtensionConfigItem, {
+  type: 'number';
+}>, n: number): number;
+/**
+ * Whether a slot item does something on click: opens a panel or runs a command.
+ *
+ * @param item - The slot item.
+ */
+declare function slotIsActionable(item: SlotWire): boolean;
+//#endregion
+export { SettingValue, TITLEBAR_ITEMS_PER_EXTENSION, clampSettingNumber, filterSelectOptions, groupSelectOptions, isSettingLocked, missingScope, qualifyPanelId, rendererMatches, renderersFor, settingValue, settingsValues, slotIsActionable, slotItems, titlebarItems };

package/dist/extensions/headless/select.js

@@ -0,0 +1,191 @@
+//#region src/extensions/headless/select.ts
+/**
+* The slot items for one place, lowest `order` first (stable). Items scoped to a session show only
+* beside that session; unscoped items show everywhere. A `transcript.turn-end` item that names a turn
+* shows only after that turn (`turnId`); one that names none, only where no turn is given (the end of
+* the transcript).
+*
+* @param items - Every slot item.
+* @param at - The place.
+* @param sessionId - The session the place belongs to, if any.
+* @param turnId - `transcript.turn-end`: the turn the place follows. Absent: the end of the transcript.
+*/
+function slotItems(items, at, sessionId, turnId) {
+	return items.filter((e) => e.item.at === at && (e.item.sessionId === void 0 || e.item.sessionId === sessionId) && e.item.turnId === turnId).map((e, index) => ({
+		e,
+		index
+	})).sort((a, b) => a.e.item.order - b.e.item.order || a.index - b.index).map((x) => x.e);
+}
+const SCOPE_RANK = {
+	chat: 0,
+	approve: 1,
+	admin: 2
+};
+/**
+* The scope an action needs that this client's token lacks, or `null` when it may run it: the token
+* grants `granted` (`null` or absent: not limited, as a local or in-process host), the action needs
+* `required` (default `admin`, as zidane's).
+*
+* @param granted - The token's scope (`ExtensionsHost.scope`).
+* @param required - The action's `scope`.
+*/
+function missingScope(granted, required) {
+	if (!granted) return null;
+	const need = required ?? "admin";
+	return SCOPE_RANK[granted] >= SCOPE_RANK[need] ? null : need;
+}
+/** How many `app.titlebar` items one extension shows: as many as its composer badges. */
+const TITLEBAR_ITEMS_PER_EXTENSION = 8;
+/**
+* The `app.titlebar` items, lowest `order` first, at most {@link TITLEBAR_ITEMS_PER_EXTENSION} per
+* extension (its first ones in that order).
+*
+* @param items - Every slot item.
+* @param sessionId - The session on screen: its session-scoped items show too.
+*/
+function titlebarItems(items, sessionId) {
+	const shown = /* @__PURE__ */ new Map();
+	return slotItems(items, "app.titlebar", sessionId).filter((e) => {
+		const n = (shown.get(e.extension) ?? 0) + 1;
+		shown.set(e.extension, n);
+		return n <= 8;
+	});
+}
+/**
+* Whether a renderer draws `target`. Languages compare case-insensitively; a renderer for several
+* tools draws each of them, and one for `'*'` draws every tool. A block id matches as given or, with
+* `extension`, under the extension that registered the renderer (`<extension>/<id>`, the form
+* `CommandOutputBlock.custom.renderer` and `PanelCustomItem.renderer` carry).
+*
+* @param renderer - A renderer's wire form.
+* @param target - What needs drawing (one tool name for a tool).
+* @param extension - The extension that registered the renderer.
+*/
+function rendererMatches(renderer, target, extension) {
+	const own = renderer.for;
+	if ("block" in target) return "block" in own && (own.block === target.block || extension !== void 0 && `${extension}/${own.block}` === target.block);
+	if ("language" in target) return "language" in own && own.language.toLowerCase() === target.language.toLowerCase();
+	if ("artifact" in target) return "artifact" in own && own.artifact === target.artifact;
+	if (!("tool" in own)) return false;
+	const wanted = typeof target.tool === "string" ? [target.tool] : target.tool;
+	const tools = typeof own.tool === "string" ? [own.tool] : own.tool;
+	return tools.includes("*") || wanted.some((t) => tools.includes(t));
+}
+/**
+* The renderers for `target`, in the host's order: the first draws, the next ones take over when a
+* `fallthrough` renderer draws nothing.
+*
+* @param items - Every renderer item.
+* @param target - What needs drawing.
+*/
+function renderersFor(items, target) {
+	return items.filter((e) => rendererMatches(e.item, target, e.extension));
+}
+/**
+* The full id of a panel an extension names: `<extension>/<id>` when that extension has one by
+* that id, else the id as given (already full, or a built-in tab such as `todos`).
+*
+* @param extension - The naming extension.
+* @param panel - The id it named.
+* @param panels - Every panel item.
+*/
+function qualifyPanelId(extension, panel, panels) {
+	if (panel.includes("/")) return panel;
+	const full = `${extension}/${panel}`;
+	return panels.some((p) => p.item.id === full) ? full : panel;
+}
+/**
+* The options whose label, description or group contains every word of `query` (case-insensitive).
+*
+* @param options - A select dialog's options.
+* @param query - What the user typed.
+*/
+function filterSelectOptions(options, query) {
+	const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+	if (words.length === 0) return options;
+	return options.filter((o) => {
+		const text = `${o.label} ${o.description ?? ""} ${o.group ?? ""}`.toLowerCase();
+		return words.every((w) => text.includes(w));
+	});
+}
+/**
+* Options grouped in first-seen group order; ungrouped options come first under `group: undefined`.
+*
+* @param options - The options to group.
+*/
+function groupSelectOptions(options) {
+	const groups = /* @__PURE__ */ new Map();
+	groups.set(void 0, []);
+	for (const o of options) {
+		const list = groups.get(o.group) ?? [];
+		list.push(o);
+		groups.set(o.group, list);
+	}
+	return [...groups.entries()].filter(([, list]) => list.length > 0).map(([group, list]) => ({
+		group,
+		options: list
+	}));
+}
+/**
+* The value a row shows: the stored value when its type fits, else the default.
+*
+* @param item - The row.
+* @param stored - The stored value, if any.
+*/
+function settingValue(item, stored) {
+	switch (item.type) {
+		case "boolean": return typeof stored === "boolean" ? stored : item.default;
+		case "number": return typeof stored === "number" && Number.isFinite(stored) ? stored : item.default;
+		case "enum": return typeof stored === "string" && item.options.some((o) => o.value === stored) ? stored : item.default;
+		default: return typeof stored === "string" ? stored : item.default;
+	}
+}
+/**
+* Every row's starting value, by `extension` then key.
+*
+* @param settings - The wire settings.
+*/
+function settingsValues(settings) {
+	const out = {};
+	for (const item of settings.schema.items) (out[item.extension] ??= {})[item.key] = settingValue(item, settings.values[item.extension]?.[item.key]);
+	return out;
+}
+/**
+* Whether a declarative config entry sets this setting (shown, not editable).
+*
+* @param settings - The wire settings.
+* @param extension - The extension.
+* @param key - The setting.
+*/
+function isSettingLocked(settings, extension, key) {
+	return settings.locked.includes(`${extension}:${key}`);
+}
+/**
+* Clamps and snaps a number the way zidane does (`clampExtensionConfigNumber`), so a typed value
+* persists the same from every client.
+*
+* @param item - A number row.
+* @param n - The typed number.
+*/
+function clampSettingNumber(item, n) {
+	let v = n;
+	if (item.min !== void 0) v = Math.max(item.min, v);
+	if (item.max !== void 0) v = Math.min(item.max, v);
+	if (item.step !== void 0 && item.step > 0) {
+		const base = item.min ?? 0;
+		v = base + Math.round((v - base) / item.step) * item.step;
+		if (item.max !== void 0) v = Math.min(item.max, v);
+		if (item.min !== void 0) v = Math.max(item.min, v);
+	}
+	return v;
+}
+/**
+* Whether a slot item does something on click: opens a panel or runs a command.
+*
+* @param item - The slot item.
+*/
+function slotIsActionable(item) {
+	return item.panel !== void 0 || item.command !== void 0;
+}
+//#endregion
+export { TITLEBAR_ITEMS_PER_EXTENSION, clampSettingNumber, filterSelectOptions, groupSelectOptions, isSettingLocked, missingScope, qualifyPanelId, rendererMatches, renderersFor, settingValue, settingsValues, slotIsActionable, slotItems, titlebarItems };

package/dist/extensions/headless/webview-bridge.d.ts

@@ -0,0 +1,71 @@
+import { ExtensionsHost } from "./host.js";
+//#region src/extensions/headless/webview-bridge.d.ts
+/** The `type` of a request the page posts. */
+declare const WEBVIEW_RPC_REQUEST = "zidane:rpc";
+/** The `type` of the reply the bridge posts. */
+declare const WEBVIEW_RPC_RESULT = "zidane:rpc:result";
+/** Error type for a contract the webview does not list. */
+declare const WEBVIEW_RPC_NOT_ALLOWED = "rpc.not-allowed";
+/** Error type when the host offers no RPC. */
+declare const WEBVIEW_RPC_UNAVAILABLE = "rpc.unavailable";
+/** A request from the page. */
+interface WebviewRpcRequest {
+  /** Marks the message as an RPC request. */
+  type: typeof WEBVIEW_RPC_REQUEST;
+  /** The page's id for the call; the reply carries it. */
+  id: string | number;
+  /** The RPC contract to call; the webview's `rpc` list must name it. */
+  contract: string;
+  /** The contract's method to call. */
+  method: string;
+  /** The method's input. */
+  input?: unknown;
+}
+/** The reply to a request. */
+type WebviewRpcResult = {
+  type: typeof WEBVIEW_RPC_RESULT;
+  id: string | number;
+  ok: true;
+  output: unknown;
+} | {
+  type: typeof WEBVIEW_RPC_RESULT;
+  id: string | number;
+  ok: false;
+  error: {
+    type: string;
+    message: string;
+    data?: unknown;
+  };
+};
+/** Options of {@link createWebviewRpcBridge}. */
+interface WebviewRpcBridgeOptions {
+  /** The webview's extension: its UI is the caller. */
+  extensionId: string;
+  /** The contract ids the webview lists (`WebviewWire.rpc`). */
+  contracts: readonly string[];
+  /** The host's RPC. Absent: every call answers `rpc.unavailable`. */
+  rpc?: ExtensionsHost['rpc'];
+  /** Posts a reply to the page. */
+  post(message: WebviewRpcResult): void;
+}
+/** A bridge for one page. */
+interface WebviewRpcBridge {
+  /** Handles one message from the page. `false`: not a bridge request (ignored). */
+  handle(data: unknown): boolean;
+  /** Aborts calls in flight and posts nothing more. */
+  dispose(): void;
+}
+/**
+ * Whether `data` is a well-formed bridge request.
+ *
+ * @param data - A message from the page.
+ */
+declare function isWebviewRpcRequest(data: unknown): data is WebviewRpcRequest;
+/**
+ * Creates the bridge for one webview page.
+ *
+ * @param options - The extension, the contracts it lists, the host's RPC and how to post back.
+ */
+declare function createWebviewRpcBridge(options: WebviewRpcBridgeOptions): WebviewRpcBridge;
+//#endregion
+export { WEBVIEW_RPC_NOT_ALLOWED, WEBVIEW_RPC_REQUEST, WEBVIEW_RPC_RESULT, WEBVIEW_RPC_UNAVAILABLE, WebviewRpcBridge, WebviewRpcBridgeOptions, WebviewRpcRequest, WebviewRpcResult, createWebviewRpcBridge, isWebviewRpcRequest };

package/dist/extensions/headless/webview-bridge.js

@@ -0,0 +1,78 @@
+import { extensionsErrorOf } from "./host.js";
+//#region src/extensions/headless/webview-bridge.ts
+/** The `type` of a request the page posts. */
+const WEBVIEW_RPC_REQUEST = "zidane:rpc";
+/** The `type` of the reply the bridge posts. */
+const WEBVIEW_RPC_RESULT = "zidane:rpc:result";
+/** Error type for a contract the webview does not list. */
+const WEBVIEW_RPC_NOT_ALLOWED = "rpc.not-allowed";
+/** Error type when the host offers no RPC. */
+const WEBVIEW_RPC_UNAVAILABLE = "rpc.unavailable";
+/**
+* Whether `data` is a well-formed bridge request.
+*
+* @param data - A message from the page.
+*/
+function isWebviewRpcRequest(data) {
+	if (!data || typeof data !== "object") return false;
+	const m = data;
+	return m.type === "zidane:rpc" && (typeof m.id === "string" || typeof m.id === "number") && typeof m.contract === "string" && typeof m.method === "string";
+}
+/**
+* Creates the bridge for one webview page.
+*
+* @param options - The extension, the contracts it lists, the host's RPC and how to post back.
+*/
+function createWebviewRpcBridge(options) {
+	const controller = new AbortController();
+	const allowed = new Set(options.contracts);
+	const reply = (message) => {
+		if (!controller.signal.aborted) options.post(message);
+	};
+	const fail = (id, type, message, data) => reply({
+		type: WEBVIEW_RPC_RESULT,
+		id,
+		ok: false,
+		error: {
+			type,
+			message,
+			...data !== void 0 ? { data } : {}
+		}
+	});
+	return {
+		handle(data) {
+			if (!isWebviewRpcRequest(data)) return false;
+			if (controller.signal.aborted) return true;
+			const { id, contract, method, input } = data;
+			if (!allowed.has(contract)) {
+				fail(id, WEBVIEW_RPC_NOT_ALLOWED, `this webview may not call ${contract}`);
+				return true;
+			}
+			if (!options.rpc) {
+				fail(id, WEBVIEW_RPC_UNAVAILABLE, "no RPC here");
+				return true;
+			}
+			options.rpc(contract, method, input, {
+				extensionId: options.extensionId,
+				signal: controller.signal
+			}).then((output) => reply({
+				type: WEBVIEW_RPC_RESULT,
+				id,
+				ok: true,
+				output
+			}), (err) => {
+				const error = extensionsErrorOf(err);
+				if (error.code === "rpc") fail(id, error.type, error.message, error.data);
+				else if (error.code === "unavailable") fail(id, WEBVIEW_RPC_UNAVAILABLE, "unavailable");
+				else if (error.code === "refused") fail(id, WEBVIEW_RPC_NOT_ALLOWED, error.message ?? error.reason);
+				else fail(id, "rpc.internal", error.message);
+			});
+			return true;
+		},
+		dispose() {
+			controller.abort();
+		}
+	};
+}
+//#endregion
+export { WEBVIEW_RPC_NOT_ALLOWED, WEBVIEW_RPC_REQUEST, WEBVIEW_RPC_RESULT, WEBVIEW_RPC_UNAVAILABLE, createWebviewRpcBridge, isWebviewRpcRequest };

package/dist/extensions/headless/wire.d.ts

@@ -0,0 +1,113 @@
+import { ReferenceProviderWire } from "zidane/chat/pure";
+import { Theme } from "zidane/chat";
+import * as Api from "zidane/extensions";
+//#region src/extensions/headless/wire.d.ts
+/** A component an item names, an export of the extension's `ui.tsx` bundle and its JSON props: zidane's `ComponentWire` (`zidane/extensions`). */
+type ComponentWire = Api.ComponentWire;
+/** The places every app knows. An app without the place ignores the item. */
+type SlotName = Api.SlotWire['at'];
+/** Every slot name, in a fixed order. */
+declare const SLOT_NAMES: readonly SlotName[];
+/** A side or home panel (its `load`, `onAction` and `subscribe` stay with the extension): zidane's `PanelWire` (`zidane/extensions`). */
+type PanelWire = Api.PanelWire;
+/** A small item in a slot: a status line, a banner, a composer badge: zidane's `SlotWire` (`zidane/extensions`). */
+type SlotWire = Api.SlotWire;
+/** A full-screen view, or a modal: zidane's `ScreenWire` (`zidane/extensions`). */
+type ScreenWire = Api.ScreenWire;
+/** What a renderer draws: a custom block id, a code-block language, a tool's result, or an artifact kind's detail. */
+type RendererTarget = Api.RendererWire['for'];
+/** A renderer: a component, with a markdown fallback: zidane's `RendererWire` (`zidane/extensions`). */
+type RendererWire = Api.RendererWire;
+/** Everything a Settings UI needs to draw settings (values without secrets, locked keys as `extension:key`): zidane's `WireSettings` (`zidane/extensions`). */
+type WireSettings = Api.WireSettings;
+/** One page of an extension's settings in the settings sidebar: zidane's `WireSettingsPage` (`zidane/extensions`). */
+type WireSettingsPage = Api.WireSettingsPage;
+/** A Settings page under an extension: zidane's `SettingsPageWire` (`zidane/extensions`). */
+type SettingsPageWire = Api.SettingsPageWire;
+/** A sandboxed web page in a panel or a screen (a `file` source is relative to the extension's folder): zidane's `WebviewWire` (`zidane/extensions`). */
+type WebviewWire = Api.WebviewWire;
+/** Badge actions, and the badges they apply to: zidane's `BadgeActionWire` (`zidane/extensions`). */
+type BadgeActionWire = Api.BadgeActionWire;
+/** A context breakdown or context panel section: zidane's `ContextSectionWire` (`zidane/extensions`). */
+type ContextSectionWire = Api.ContextSectionWire;
+/** A space an extension adds to the switcher, with its base query: zidane's `SpaceWire` (`zidane/extensions`). */
+type SpaceWire = Api.SpaceWire;
+/** A filter an extension offers in every space's filter menu: zidane's `SidebarFilterWire` (`zidane/extensions`). */
+type SidebarFilterWire = Api.SidebarFilterWire;
+/** A sort an extension offers in the filter menu: zidane's `SidebarSortWire` (`zidane/extensions`). */
+type SidebarSortWire = Api.SidebarSortWire;
+/** A grouping an extension offers in the filter menu: zidane's `SidebarGroupWire` (`zidane/extensions`). */
+type SidebarGroupWire = Api.SidebarGroupWire;
+/** Extra data on the rows of matching sessions: zidane's `SidebarDecorationWire` (`zidane/extensions`). */
+type SidebarDecorationWire = Api.SidebarDecorationWire;
+/** A row an extension lists among a space's sessions: zidane's `SidebarRowWire` (`zidane/extensions`). */
+type SidebarRowWire = Api.SidebarRowWire;
+/** One action of a sidebar row's menu: zidane's `SidebarRowActionWire` (`zidane/extensions`). */
+type SidebarRowActionWire = Api.SidebarRowActionWire;
+/** A link handler (its `match` and `open` stay with the extension): zidane's `LinkHandlerWire` (`zidane/extensions`). */
+type LinkHandlerWire = Api.LinkHandlerWire;
+/** The wire form of each token the kit draws, by token name. */
+interface ExtensionWireMap {
+  /** A side or home panel. */
+  panel: PanelWire;
+  /** A small item in a named place of the app. */
+  slot: SlotWire;
+  /** A full-screen view, or a modal. */
+  screen: ScreenWire;
+  /** A component that draws a block, a code language, a tool result or an artifact. */
+  renderer: RendererWire;
+  /** A Settings page under an extension. */
+  'settings-page': SettingsPageWire;
+  /** A sandboxed web page. */
+  webview: WebviewWire;
+  /** A color theme. */
+  theme: Theme;
+  /** A source of references the user can add to a message. */
+  reference: ReferenceProviderWire;
+  /** An action offered on composer badges. */
+  'badge-action': BadgeActionWire;
+  /** Opens matching links before the app (the kit routes links only while one exists). */
+  'link-handler': LinkHandlerWire;
+  /** A section of the context breakdown or the context panel. */
+  'context-section': ContextSectionWire;
+  /** A space in the switcher, with its base query. */
+  space: SpaceWire;
+  /** A filter in the sidebar's filter menu. */
+  'sidebar-filter': SidebarFilterWire;
+  /** A sort in the sidebar's filter menu. */
+  'sidebar-sort': SidebarSortWire;
+  /** A grouping in the sidebar's filter menu. */
+  'sidebar-group': SidebarGroupWire;
+  /** Extra data on session rows. */
+  'sidebar-decoration': SidebarDecorationWire;
+  /** A row among a space's sessions. */
+  'sidebar-row': SidebarRowWire;
+}
+/** A token the kit draws. (Native menus are the desktop app's own.) */
+type ExtensionTokenName = keyof ExtensionWireMap;
+/** Every token the kit draws, in a fixed order. */
+declare const EXTENSION_TOKENS: readonly ExtensionTokenName[];
+/** One contribution: zidane's `UiEntry`. */
+interface ExtensionItem<N extends ExtensionTokenName = ExtensionTokenName> {
+  /** Unique across the host; stable for the item's life. */
+  readonly key: string;
+  /** The kind of contribution; picks the type of `item`. */
+  readonly token: N;
+  /** The contributing extension's id. */
+  readonly extension: string;
+  /** The wire form. */
+  readonly item: ExtensionWireMap[N];
+}
+/** One option of a select dialog. */
+type SelectOptionWire = Extract<DialogRequestWire, {
+  kind: 'select';
+}>['options'][number];
+/**
+ * A dialog `ctx.ui` asked for, by kind: zidane's `DialogRequest` (`zidane/extensions`). A `form`'s
+ * `settings` holds the initial values, and its answer is a value per key.
+ */
+type DialogRequestWire = Api.DialogRequest;
+/** The kinds of {@link DialogRequestWire}. */
+type DialogKind = DialogRequestWire['kind'];
+//#endregion
+export { BadgeActionWire, ComponentWire, ContextSectionWire, DialogKind, DialogRequestWire, EXTENSION_TOKENS, ExtensionItem, ExtensionTokenName, ExtensionWireMap, LinkHandlerWire, PanelWire, RendererTarget, RendererWire, SLOT_NAMES, ScreenWire, SelectOptionWire, SettingsPageWire, SidebarDecorationWire, SidebarFilterWire, SidebarGroupWire, SidebarRowActionWire, SidebarRowWire, SidebarSortWire, SlotName, SlotWire, SpaceWire, WebviewWire, WireSettings, WireSettingsPage };

package/dist/extensions/headless/wire.js

@@ -0,0 +1,38 @@
+//#region src/extensions/headless/wire.ts
+/** Every slot name, in a fixed order. */
+const SLOT_NAMES = [
+	"app.statusbar",
+	"app.titlebar",
+	"session.header",
+	"composer.above",
+	"composer.below",
+	"composer.badges",
+	"sidebar.top",
+	"sidebar.bottom",
+	"sidebar.footer",
+	"transcript.turn-end",
+	"home.block",
+	"settings.section"
+];
+/** Every token the kit draws, in a fixed order. */
+const EXTENSION_TOKENS = [
+	"panel",
+	"slot",
+	"screen",
+	"renderer",
+	"settings-page",
+	"webview",
+	"theme",
+	"reference",
+	"badge-action",
+	"link-handler",
+	"context-section",
+	"space",
+	"sidebar-filter",
+	"sidebar-sort",
+	"sidebar-group",
+	"sidebar-decoration",
+	"sidebar-row"
+];
+//#endregion
+export { EXTENSION_TOKENS, SLOT_NAMES };