zidane-ui 9.0.4 → 9.1.3

package/dist/dist/{index-Cx7GDZlz.d.ts → index-WlE93Q6d.d.ts}

@@ -1,59 +1,12 @@
-/**
- * `defineExtension` — identity helper for authoring extensions.
- *
- * Mirrors {@link definePreset} / {@link defineSkill}: returns its
- * argument verbatim, but its presence in the source gives TypeScript
- * an inference anchor and the import surface a stable name.
- *
- * Authoring example (drop in `.zidane/extensions/hello/index.ts`):
- *
- * ```ts
- * import { defineExtension } from 'zidane'
- *
- * export default defineExtension({
- *   name: 'hello',
- *   version: '0.1.0',
- *   setup(ctx) {
- *     ctx.registerHook('tool:after', ({ name }) =>
- *       ctx.logger.info('tool ran', { name }))
- *   },
- * })
- * ```
- *
- * No validation runs here — that lives in the loader so a malformed
- * definition surfaces in the Settings panel rather than throwing
- * during a module's top-level evaluation.
- *
- * **Zero-import alternative.** The loader accepts a plain object too,
- * so extensions running against the compiled `zidane-tui` binary
- * (which doesn't expose `node_modules/zidane` to dynamic imports
- * outside the bundle) can skip the import entirely:
- *
- * ```ts
- * // .zidane/extensions/hello/index.ts — no imports needed
- * export default {
- *   name: 'hello',
- *   setup(ctx) {
- *     ctx.registerHook('tool:after', e => ctx.logger.info('ran', e))
- *   },
- * }
- * ```
- *
- * You lose TypeScript inference on `ctx` this way; pair with
- * `/// <reference types="zidane" />` or an `import type { ExtensionContext } from 'zidane'`
- * (type-only imports don't need a runtime resolution) to recover it.
- */
-import "../node_modules/.bun/@earendil-works_pi-ai@1.3.0_bff1df87cb190f90/node_modules/@earendil-works/pi-ai/dist/api/google-vertex.js";
-import "../node_modules/.bun/@earendil-works_pi-ai@1.3.0_bff1df87cb190f90/node_modules/@earendil-works/pi-ai/dist/api/google-shared.js";
-import "../node_modules/.bun/@earendil-works_pi-ai@1.3.0_bff1df87cb190f90/node_modules/@earendil-works/pi-ai/dist/index.js";
-import "./types-bDQagoiL.js";
+import "./types-2HrgolQz.js";
 import "../node_modules/.bun/@earendil-works_pi-ai@1.3.0_bff1df87cb190f90/node_modules/@earendil-works/pi-ai/dist/oauth.js";
 import "./oauth-callback-page-DMxIgurj.js";
 import "../node_modules/.bun/hookable@6.1.2/node_modules/hookable/dist/index.js";
+import "../node_modules/.bun/@earendil-works_pi-ai@1.3.0_bff1df87cb190f90/node_modules/@earendil-works/pi-ai/dist/index.js";
 import "../node_modules/.bun/@anthropic-ai_sdk@0.104.2_fff7ddf946fac095/node_modules/@anthropic-ai/sdk/index.js";
 import "../node_modules/.bun/@anthropic-ai_sdk@0.104.2_fff7ddf946fac095/node_modules/@anthropic-ai/sdk/resources2.js";
 import { ReactNode } from "react";
-//#region ../dist/index-Cx7GDZlz.d.ts
+//#region ../dist/index-WlE93Q6d.d.ts
 //#endregion
 //#region src/thinking-levels.d.ts
 /**
@@ -98,6 +51,199 @@ interface EnvironmentSettings {
   config?: Record<string, Record<string, EnvironmentConfigValue>>;
 }
 //#endregion
+//#region src/chat/ansi.d.ts
+/**
+ * Terminal output as styled lines: ANSI SGR codes (colors, bold, dim, italic,
+ * underline, inverse) become styles on spans of text; every other escape
+ * (cursor moves, titles, charsets) is dropped; a carriage return rewrites its
+ * line as a terminal does (a progress bar keeps its last state), backspace
+ * erases. One incremental parser ({@link createAnsiLines}) serves the whole
+ * text ({@link parseAnsi}) and plain text ({@link stripAnsi}). A line cut
+ * out of a stream keeps its spans, so it renders with the colors it had.
+ *
+ * Node-free (exported from `zidane/chat/pure`).
+ */
+/** A color: one of the 256 palette entries (0 to 15 are the theme's), or `#rrggbb`. */
+type AnsiColor = number | `#${string}`;
+/** How a span of text is drawn. Absent fields are the default. */
+interface AnsiStyle {
+  /** Text color. */
+  fg?: AnsiColor;
+  /** Background color. */
+  bg?: AnsiColor;
+  /** Bold (SGR 1). */
+  bold?: true;
+  /** Faint (SGR 2). */
+  dim?: true;
+  /** Italic (SGR 3). */
+  italic?: true;
+  /** Underlined (SGR 4). */
+  underline?: true;
+  /** Foreground and background swapped. */
+  inverse?: true;
+}
+/** Text in one style. `style` is absent for plain text. */
+interface AnsiSpan {
+  /** The text, without escapes. */
+  text: string;
+  /** Its style, absent for plain text. */
+  style?: AnsiStyle;
+}
+//#endregion
+//#region src/chat/output-tail.d.ts
+/** Where an output line came from: a printed item (`output`, `console`) or a command's `stdout` / `stderr`. */
+type OutputStream = 'output' | 'console' | 'stdout' | 'stderr';
+/** One line of output. */
+interface OutputLine {
+  /**
+   * The line's number in the whole output, from 0: the same while the line
+   * shows (a command's line keeps its id as it is written, then ended), so a
+   * view can key on it and animate only what is new.
+   */
+  id: number;
+  /** Where it came from. */
+  stream: OutputStream;
+  /** The line's visible text, without its newline, cut to the tail's width. */
+  text: string;
+  /** The same text in styled spans, when it had colors or styles (ANSI codes). */
+  spans?: AnsiSpan[];
+  /** Script line of the call that wrote it (codemode). */
+  line?: number;
+}
+//#endregion
+//#region src/chat/script-progress.d.ts
+/** How the latest call of a script line stands. */
+type ScriptCallStatus = 'running' | 'ok' | 'error';
+/** A script line that made calls. */
+interface ScriptLineProgress {
+  /** 1-based line in the script as the model wrote it. */
+  line: number;
+  /** State of the latest call made from this line. */
+  status: ScriptCallStatus;
+  /** Calls made from this line so far. */
+  calls: number;
+}
+/** One line of what a script printed or its shell calls wrote. */
+type ScriptOutputLine = OutputLine;
+/** A script's progress as a `tool-progress` event carries it. */
+interface ScriptProgress {
+  /** Lines that made calls, by line. */
+  lines: ScriptLineProgress[];
+  /** Calls that ended, failed ones included. */
+  done: number;
+  /** Calls still running. */
+  running: number;
+  /** Calls that failed. */
+  failed: number;
+  /** The last lines of output, oldest first. A command's line still being written comes last. */
+  output: ScriptOutputLine[];
+  /** How the script ended, once it did: its last line shows done when it ended without error. */
+  ended?: 'ok' | 'error';
+}
+//#endregion
+//#region src/chat/session-query/types.d.ts
+/**
+ * The types of the session query: a declarative filter, sort, grouping
+ * and paging over session rows. JSON only, so a query travels over the
+ * wire and an extension can declare one as data.
+ */
+/** A value a condition compares against. `null` stands for "no value". */
+type QueryValue = string | number | boolean | null;
+/**
+ * A bound of `gt` / `gte` / `lt` / `lte`: a number (epoch ms on time
+ * fields), a relative time (`'now'`, `'-7d'`, `'+12h'`; units `s m h d w`),
+ * or an ISO date (`'2026-01-31'`, `'2026-01-31T09:00:00Z'`; a date without a
+ * zone is UTC). Strings are accepted on time fields and facets.
+ */
+type QueryBound = number | string;
+/**
+ * A session row field a query can read. `environment.kind` is `'local'` for a
+ * session without an environment. `projectName` is computed: the folder name
+ * (last path segment) of `projectRoot`, or of `cwd` without one.
+ */
+type SessionFieldName = 'id' | 'title' | 'projectRoot' | 'projectName' | 'cwd' | 'agentId' | 'status' | 'createdAt' | 'updatedAt' | 'runStartedAt' | 'archived' | 'favorite' | 'isMain' | 'spaceId' | 'providerKey' | 'modelId' | 'account' | 'effort' | 'hostId' | 'repoKey' | 'environment.kind' | 'environment.state' | 'environment.branch';
+/**
+ * A facet an extension computes for each session: `facet.<extensionId>.<key>`,
+ * optionally followed by `.<property>` steps into an object value (a number
+ * step indexes an array).
+ */
+type FacetPath = `facet.${string}`;
+/** What a condition, a sort or a grouping reads: a row field or a facet. */
+type SessionFieldPath = SessionFieldName | FacetPath;
+/**
+ * One test on one field. Every operator given must hold. An array value
+ * (a facet holding a list) matches `eq` / `in` / `contains` when one of
+ * its elements does. A missing value equals `null`; a missing boolean field
+ * reads `false`.
+ */
+interface SessionCondition {
+  /** The field or facet tested. */
+  field: SessionFieldPath;
+  /** Equals this value (strings compare exactly). */
+  eq?: QueryValue;
+  /** Does not equal this value. A missing value matches unless the value is `null`. */
+  ne?: QueryValue;
+  /** Equals one of these values. An empty list matches no row. */
+  in?: readonly QueryValue[];
+  /** Equals none of these values. An empty list matches every row. */
+  nin?: readonly QueryValue[];
+  /** Greater than this number or time. Rows without a number never match. */
+  gt?: QueryBound;
+  /** Greater than or equal to this number or time. */
+  gte?: QueryBound;
+  /** Less than this number or time. */
+  lt?: QueryBound;
+  /** Less than or equal to this number or time. */
+  lte?: QueryBound;
+  /** Contains this text, ignoring case. */
+  contains?: string;
+  /** `true`: has a value (not missing, not `null`). `false`: has none. Boolean fields always have one. */
+  exists?: boolean;
+}
+/** Every sub-query holds. An empty list matches every row. */
+interface SessionQueryAll {
+  /** The sub-queries. */
+  all: readonly SessionQuery[];
+}
+/** At least one sub-query holds. An empty list matches no row. */
+interface SessionQueryAny {
+  /** The sub-queries. */
+  any: readonly SessionQuery[];
+}
+/** The sub-query does not hold. */
+interface SessionQueryNot {
+  /** The sub-query. */
+  not: SessionQuery;
+}
+/** A filter over session rows: a condition, or `all` / `any` / `not` of more queries. */
+type SessionQuery = SessionCondition | SessionQueryAll | SessionQueryAny | SessionQueryNot;
+/**
+ * One sort key. Rows without a value sort last in both directions. Only text,
+ * numbers and booleans sort: a facet holding a list or an object sorts as
+ * missing, and text sorts on its first 256 characters.
+ */
+interface SessionSort {
+  /** The field or facet sorted on. */
+  field: SessionFieldPath;
+  /** Default `'asc'`. */
+  dir?: 'asc' | 'desc';
+}
+/** Group order: by label ascending or descending, or these group keys first (the rest by label after them). */
+type SessionGroupOrder = 'asc' | 'desc' | readonly string[];
+/**
+ * Groups rows by the value of a field or facet. Each distinct value is one
+ * group; a row whose value is a list is in one group per element. Rows
+ * without a value go to a last group with key `null`.
+ */
+interface SessionGroupBy {
+  /** The field or facet grouped on. */
+  field: SessionFieldPath;
+  /** Labels by group key. Win over the labels the caller supplies. Default label: the key. */
+  labels?: Readonly<Record<string, string>>;
+  /** Default `'asc'`. The group without a value is always last. */
+  order?: SessionGroupOrder;
+}
+//#endregion
 //#region src/chat/spaces.d.ts
 /** A space's icon: one emoji, or a small image data-URL (the GUI's directory icon shape). */
 type SpaceIcon = {
@@ -132,6 +278,25 @@ interface Space {
   modelOptions?: Record<string, boolean>;
   /** Agent new sessions in this space start on (`AgentProfile.id`); absent = the global default (`Settings.defaultAgent`). */
   agentId?: string;
+  /**
+   * A query space (an extension's, or a view the user saved): the sessions
+   * it lists besides those stamped with its id. Absent: only those.
+   */
+  query?: SessionQuery;
+  /** How the space groups its sessions until the user picks a grouping. */
+  groupBy?: SessionGroupBy;
+  /** How the space sorts its sessions until the user picks a sort. */
+  sortBy?: SessionSort[];
+  /**
+   * The extension contributing the space (id `<extension>/<id>`). In the
+   * stored list, an entry with an extension space's id only places it in
+   * the switcher and may hide it; its base comes from the extension.
+   */
+  extensionId?: string;
+  /** Its name, query and defaults are the extension's: the user can't edit them (extension spaces). */
+  readonly?: boolean;
+  /** Left out of the switcher; its sessions stay in it. */
+  hidden?: boolean;
 }
 /**
  * How `tool` events render in the transcript. Drives `Settings.toolCallDisplay`.
@@ -520,6 +685,14 @@ interface Settings {
    * that run a subagent show either way, since their worker attaches there.
    */
   codemodeShowCalls: boolean;
+  /**
+   * Show each codemode script's progress while it runs: the line each call
+   * came from (running, done, failed), a count of its calls, and the last
+   * lines it printed or its shell calls wrote. Sets
+   * `behavior.codemode.streamProgress`; toggling it rebuilds live agents.
+   * The model's result does not change. Off by default.
+   */
+  codemodeStreamProgress: boolean;
   /**
    * Run the model's `shell` tool commands under the OS sandbox: macOS
    * Seatbelt (`sandbox-exec`) or Linux bubblewrap (`bwrap`). Writes are
@@ -733,6 +906,13 @@ interface Settings {
    * Default: off.
    */
   autoTitle: boolean;
+  /**
+   * Estimate how long each run and subagent has left: a decision when the
+   * run has gone a few seconds, again when its todo list moves and once if
+   * it goes over. Saved on the run (`SessionRun.estimate`); windows count
+   * down from it. Needs {@link decisions}. Default: off.
+   */
+  runEstimates: boolean;
   /**
    * Model for side-channel text (session titles, next-prompt suggestions),
    * as `"providerKey[@account]/modelId"`. Empty string = automatic: the
@@ -880,6 +1060,13 @@ interface Settings {
    * window until it reloads. Default: on.
    */
   preserveScroll: boolean;
+  /**
+   * The desktop and web apps draw a reply's ```mermaid fences as diagrams
+   * (Pele, themed with the app's colors and fonts), each with a toggle to
+   * its source. Off shows them as code. The terminal always shows the
+   * source. Default: on.
+   */
+  renderDiagrams: boolean;
   /**
    * The GUI's dev browser (the Browser panel tab). Off = no tab, no pages,
    * and the agent is not offered the `browser_*` tools. Default: on.
@@ -933,6 +1120,15 @@ interface Settings {
    * "Working". Default: on.
    */
   sidebarRunDetails: boolean;
+  /**
+   * Experimental, desktop app. The new-chat screen of a folder becomes its
+   * project home: the project's header, the composer, then blocks that
+   * extensions add (`registerPanel` with `surfaces: ['home']`; usage, recent
+   * sessions). Clicking a project's name in the sidebar opens it, and the
+   * group's collapse moves to a chevron at the end of its buttons. Off: the
+   * welcome screen and sidebar as before. Default: off.
+   */
+  projectHome: boolean;
   /**
    * Desktop notifications while no Zidane window is focused: a run finished
    * or failed, an approval or a question is waiting. The dock badge counts
@@ -947,6 +1143,14 @@ interface Settings {
    * side-panel tabs; the TUI falls back to the editor). Default: `panel`.
    */
   openIn: OpenInTarget;
+  /**
+   * The desktop Files panel's editor preferences (editing, saving,
+   * diagnostics, language servers) as the editor kit records them
+   * (`zidane-ui/files` `EditorState`, validated by its `parseEditor`).
+   * Per computer, shared by every window and build. Default: `{}` (the
+   * kit's defaults).
+   */
+  editor: Record<string, unknown>;
   /**
    * Quietly check the npm registry for a newer release of the host
    * package (`zidane-tui` for the shipped binary; any consumer can
@@ -1245,4 +1449,4 @@ interface Settings {
   activeIcon: string;
 }
 //#endregion
-export { EditDiffDisplay as Bg, InteractionMode as Gg, EnvironmentSettings as Gy, OpenInTarget as Jg, ThinkingLevel as Rk, TranscriptDensity as a_, SpaceIcon as d_, ToolCallDisplay as i_, EnvironmentConfigValue as lb, DurabilityMode as nS, Settings as t_, Space as u_, ApprovalMode as zg };
+export { SpaceIcon as Cf, ScriptOutputLine as IC, EnvironmentSettings as IT, ScriptProgress as LC, ScriptCallStatus as MC, ScriptLineProgress as NC, DurabilityMode as OE, Space as Sf, ThinkingLevel as TL, OutputLine as XC, ApprovalMode as Xd, OutputStream as ZC, EditDiffDisplay as Zd, SessionQueryNot as _b, SessionFieldName as ab, OpenInTarget as af, SessionGroupBy as cb, SessionQuery as db, EnvironmentConfigValue as eE, AnsiColor as ew, SessionQueryAll as fb, Settings as ff, TranscriptDensity as gf, ToolCallDisplay as hf, SessionCondition as ib, SessionGroupOrder as lb, QueryBound as nb, InteractionMode as nf, AnsiSpan as nw, SessionFieldPath as ob, SessionQueryAny as pb, QueryValue as rb, AnsiStyle as rw, FacetPath as tb, SessionSort as yb };

package/dist/extensions/ExtensionComponent.d.ts

@@ -0,0 +1,62 @@
+import { ComponentWire } from "./headless/wire.js";
+import { ComponentType, ReactNode } from "react";
+//#region src/extensions/ExtensionComponent.d.ts
+/** Loads an extension's `ui.tsx` module: its exports by name. */
+type ExtensionModuleLoader = (extensionId: string) => Promise<Readonly<Record<string, unknown>>>;
+/** Props for {@link ExtensionComponentsProvider}. */
+interface ExtensionComponentsProviderProps {
+  /** Loads an extension's `ui.tsx` module. Each extension's module loads once per loader. */
+  loadModule: ExtensionModuleLoader;
+  /** The subtree that resolves extension components through the loader. */
+  children: ReactNode;
+}
+/**
+ * Supplies the loader {@link ExtensionComponent} resolves components through. `ExtensionsProvider`'s `loadModule` mounts one.
+ *
+ * @param props - The loader and the children.
+ */
+declare function ExtensionComponentsProvider({ loadModule, children }: ExtensionComponentsProviderProps): import("react").JSX.Element;
+/** The loader from the nearest {@link ExtensionComponentsProvider}, or `null`. */
+declare function useExtensionModuleLoader(): ExtensionModuleLoader | null;
+/** Props for {@link ExtensionScope}. */
+interface ExtensionScopeProps {
+  /** The extension whose UI this is. */
+  extensionId: string;
+  /** The subtree the extension's UI renders in. */
+  children: ReactNode;
+}
+/**
+ * Marks the subtree as an extension's UI, for the author hooks. {@link ExtensionComponent} sets it; set it yourself to host an extension's UI some other way.
+ *
+ * @param props - The extension and the children.
+ */
+declare function ExtensionScope({ extensionId, children }: ExtensionScopeProps): import("react").JSX.Element;
+/** The extension whose UI renders here, or `null` outside one. */
+declare function useExtensionScope(): string | null;
+/**
+ * The component an extension exports under `name`, once its module loaded: `undefined` while
+ * loading, `null` when there is none (no loader, a failed load, a missing export).
+ *
+ * @param extensionId - The extension.
+ * @param name - The export name.
+ */
+declare function useExtensionExport(extensionId: string, name: string): ComponentType<Record<string, unknown>> | null | undefined;
+/** Props for {@link ExtensionComponent}. */
+interface ExtensionComponentProps {
+  /** The extension whose `ui.tsx` exports the component. */
+  extension: string;
+  /** The component the item names. */
+  component: ComponentWire;
+  /** Props passed over the item's own (the data a renderer draws, a slot's session). */
+  props?: Readonly<Record<string, unknown>>;
+  /** What shows while loading, without a component, and after a throw: the item's data or markdown. */
+  fallback: ReactNode;
+}
+/**
+ * Draws an extension component behind an error boundary, with the item's fallback in its place when it can't.
+ *
+ * @param props - The extension, the component reference, extra props and the fallback.
+ */
+declare function ExtensionComponent({ extension, component, props, fallback }: ExtensionComponentProps): import("react").JSX.Element;
+//#endregion
+export { ExtensionComponent, ExtensionComponentProps, ExtensionComponentsProvider, ExtensionComponentsProviderProps, ExtensionModuleLoader, ExtensionScope, ExtensionScopeProps, useExtensionExport, useExtensionModuleLoader, useExtensionScope };

package/dist/extensions/ExtensionComponent.js

@@ -0,0 +1,120 @@
+import { ErrorBoundary } from "../components/ErrorBoundary.js";
+import { useExtensionsLabels } from "./useExtensionsLabels.js";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { createContext, createElement, useContext, useEffect, useState } from "react";
+//#region src/extensions/ExtensionComponent.tsx
+/**
+* Draws a component an extension item names (`{ component, props }`): the
+* export of that extension's `ui.tsx` module, loaded through the app's
+* loader (`ExtensionComponentsProvider`). Until the module is there, when
+* the app has no loader, when the export is missing, and when the component
+* throws, the item's `fallback` (its data, or its markdown) shows instead:
+* an extension never blanks the surface it sits in.
+*
+* The component renders inside its extension's scope, so the author hooks
+* (`useExtension`, `useRpc`, `useStore`) know whose UI calls.
+*/
+const LoaderContext = createContext(null);
+const ScopeContext = createContext(null);
+const caches = /* @__PURE__ */ new WeakMap();
+function moduleEntry(loader, extensionId) {
+	let cache = caches.get(loader);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		caches.set(loader, cache);
+	}
+	let entry = cache.get(extensionId);
+	if (!entry) {
+		const created = { promise: Promise.resolve().then(() => loader(extensionId)) };
+		created.promise.then((module) => {
+			created.module = module;
+		}, () => {
+			created.failed = true;
+		});
+		cache.set(extensionId, created);
+		entry = created;
+	}
+	return entry;
+}
+/**
+* Supplies the loader {@link ExtensionComponent} resolves components through. `ExtensionsProvider`'s `loadModule` mounts one.
+*
+* @param props - The loader and the children.
+*/
+function ExtensionComponentsProvider({ loadModule, children }) {
+	return /* @__PURE__ */ jsx(LoaderContext.Provider, {
+		value: loadModule,
+		children
+	});
+}
+/** The loader from the nearest {@link ExtensionComponentsProvider}, or `null`. */
+function useExtensionModuleLoader() {
+	return useContext(LoaderContext);
+}
+/**
+* Marks the subtree as an extension's UI, for the author hooks. {@link ExtensionComponent} sets it; set it yourself to host an extension's UI some other way.
+*
+* @param props - The extension and the children.
+*/
+function ExtensionScope({ extensionId, children }) {
+	return /* @__PURE__ */ jsx(ScopeContext.Provider, {
+		value: extensionId,
+		children
+	});
+}
+/** The extension whose UI renders here, or `null` outside one. */
+function useExtensionScope() {
+	return useContext(ScopeContext);
+}
+function isComponent(value) {
+	return typeof value === "function" || typeof value === "object" && value !== null && "$$typeof" in value;
+}
+/**
+* The component an extension exports under `name`, once its module loaded: `undefined` while
+* loading, `null` when there is none (no loader, a failed load, a missing export).
+*
+* @param extensionId - The extension.
+* @param name - The export name.
+*/
+function useExtensionExport(extensionId, name) {
+	const loader = useContext(LoaderContext);
+	const entry = loader ? moduleEntry(loader, extensionId) : null;
+	const [, settled] = useState(0);
+	useEffect(() => {
+		if (!entry || entry.module || entry.failed) return void 0;
+		let live = true;
+		const bump = () => live && settled((n) => n + 1);
+		entry.promise.then(bump, bump);
+		return () => {
+			live = false;
+		};
+	}, [entry]);
+	if (!entry || entry.failed) return null;
+	if (!entry.module) return void 0;
+	const value = entry.module[name];
+	return isComponent(value) ? value : null;
+}
+/**
+* Draws an extension component behind an error boundary, with the item's fallback in its place when it can't.
+*
+* @param props - The extension, the component reference, extra props and the fallback.
+*/
+function ExtensionComponent({ extension, component, props, fallback }) {
+	const labels = useExtensionsLabels();
+	const Resolved = useExtensionExport(extension, component.component);
+	if (!Resolved) return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+	return /* @__PURE__ */ jsx(ExtensionScope, {
+		extensionId: extension,
+		children: /* @__PURE__ */ jsx(ErrorBoundary, {
+			region: labels.extensionRegion(extension),
+			resetKey: component,
+			fallback: () => /* @__PURE__ */ jsx(Fragment, { children: fallback }),
+			children: createElement(Resolved, {
+				...component.props,
+				...props
+			})
+		})
+	});
+}
+//#endregion
+export { ExtensionComponent, ExtensionComponentsProvider, ExtensionScope, useExtensionExport, useExtensionModuleLoader, useExtensionScope };

package/dist/extensions/ExtensionDialogHost.d.ts

@@ -0,0 +1,31 @@
+import { ExtensionDialog } from "./headless/host.js";
+import { CSSProperties } from "react";
+//#region src/extensions/ExtensionDialogHost.d.ts
+/** Props for {@link ExtensionDialogHost}. */
+interface ExtensionDialogHostProps {
+  /** Extra classes on the toasts' region. */
+  className?: string;
+  /** Inline styles on the toasts' region. */
+  style?: CSSProperties;
+}
+/**
+ * Shows routed dialogs on the modal layer and toasts in place. Renders nothing without `host.dialogs`.
+ *
+ * @param props - `className` and `style` of the toasts' region.
+ */
+declare function ExtensionDialogHost({ className, style }: ExtensionDialogHostProps): import("react").JSX.Element | null;
+/** Props for {@link ExtensionDialogView}. */
+interface ExtensionDialogViewProps {
+  /** The dialog to show. */
+  dialog: ExtensionDialog;
+  /** Answers it (`undefined` cancels): the shape per kind is `ExtensionDialogs.answer`'s. */
+  onAnswer(answer: unknown): void;
+}
+/**
+ * One dialog's surface, in a `ModalShell` (render it on the modal layer). Toasts aren't drawn here.
+ *
+ * @param props - The dialog and the answer callback.
+ */
+declare function ExtensionDialogView({ dialog, onAnswer }: ExtensionDialogViewProps): import("react").JSX.Element | null;
+//#endregion
+export { ExtensionDialogHost, ExtensionDialogHostProps, ExtensionDialogView, ExtensionDialogViewProps };