zidane-ui 0.0.0-stage → 9.0.2

package/README.md

@@ -1,3 +1,108 @@
-# Temporary Holding Version
+# zidane-ui
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Zidane UI kit: the design system (tokens, surface primitives, theme engine, motion, components) and the Zidane app experiences built on it (chat, setup wizard, …), each split into a React-free headless layer and the components that read it. The desktop app (`gui/`), the web app zidane-server serves (`web/`) and the website (`website/`) are built on it, and any app can be: it connects to an agent in the page, in a worker, over SSE or to a remote zidane-server.
+
+Docs: [zidane.si/docs/ui-kit](https://zidane.si/docs/ui-kit) (guides and the API reference). Contributing: [AGENTS.md](./AGENTS.md).
+
+## Install
+
+```bash
+npm install zidane-ui react react-dom motion
+npm install zidane   # for every area except appearance, plus the adapters and the server helpers
+```
+
+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).
+
+## Use
+
+```tsx
+import 'zidane-ui/core.css';
+import { IconButton, Tray } from 'zidane-ui';
+
+export function Toolbar() {
+  return (
+    <Tray>
+      <IconButton icon="i-ph-gear" label="Settings" />
+    </Tray>
+  );
+}
+```
+
+```tsx
+import 'zidane-ui/styles.css';
+import { ChatProvider, HostComposer, HostTranscript, SessionList } from 'zidane-ui/chat';
+import { createFixtureHost, DEMO_TRANSCRIPT } from 'zidane-ui/chat/testing';
+
+const host = createFixtureHost({
+  sessions: [{ id: 's1', title: 'Demo', status: 'idle', createdAt: Date.now(), updatedAt: Date.now() }],
+  transcripts: { s1: DEMO_TRANSCRIPT },
+});
+
+export function App() {
+  return (
+    <ChatProvider host={host}>
+      <SessionList activeId="s1" onSelect={() => {}} />
+      <HostTranscript sessionId="s1" />
+      <HostComposer sessionId="s1" />
+    </ChatProvider>
+  );
+}
+```
+
+A real app passes a host from `zidane-ui/adapters` instead of the fixture: `createServerHost` (a remote zidane-server), `createSseHost`, `createWorkerHost` or `createRunHost` (an agent in the page).
+
+## Entry points
+
+| Import                                                                                                                                 | What                                                                                                                                                |
+| -------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `zidane-ui`                                                                                                                            | The design system: components, motion, hooks, the theme engine, code highlighting, brand marks, labels                                              |
+| `zidane-ui/code/editor`                                                                                                                | The code editor, file view and file tree (pierre)                                                                                                   |
+| `zidane-ui/code/highlight.worker`, `/code/editor/patch-parse.worker`, `/palette/rank.worker`                                           | Worker modules (highlighting, patch parsing, palette ranking), built by the app's bundler                                                           |
+| `zidane-ui/terminal`, `/terminal/headless`, `/terminal/testing`                                                                        | The terminal surface (ghostty-web), and the terminal area over a `TerminalHost`: `TerminalProvider`, the drawer, its toggle, the panel tab          |
+| `zidane-ui/labels`, `zidane-ui/uno`                                                                                                    | The label dictionary; the UnoCSS preset                                                                                                             |
+| `zidane-ui/chat`                                                                                                                       | The chat: `ChatProvider`, `SessionList`, `Transcript` / `HostTranscript`, `Composer` / `HostComposer`, the interaction cards, and the entries below |
+| `zidane-ui/chat/transcript`, `/chat/composer`, `/chat/rich-composer`, `/chat/sidebar`, `/chat/interactions`                            | The transcript rows and slots, the composer and its pickers, the rich (Tiptap) composer, the session sidebar, the question and plan cards           |
+| `zidane-ui/chat/headless`                                                                                                              | The chat's React-free layer: `ChatHost`, stores, the session-list model, the transcript pipeline, labels                                            |
+| `zidane-ui/onboarding`, `/onboarding/headless`                                                                                         | The setup wizard and its React-free layer (`OnboardingHost`, the controller)                                                                        |
+| `zidane-ui/app`, `/app/headless`                                                                                                       | The app area: `AppHostProvider` and `useAppHost` over an `AppHost`, one optional host per area                                                      |
+| `zidane-ui/approvals`, `/workspace`, `/palette`, `/session`, `/files`, `/git`, `/machines`, `/settings`, `/appearance`, `/keybindings` | The other areas, each with `/headless` (its host interface and React-free stores) beside it                                                         |
+| `zidane-ui/adapters`                                                                                                                   | Browser-safe hosts: `createServerHost`, `createSseHost`, `createWorkerHost` / `exposeRunHost`, `createRunHost`                                      |
+| `zidane-ui/server`                                                                                                                     | Node and Bun only (`browser: null`): `createSseHandler`, `createLocalEnvironment`                                                                   |
+| `zidane-ui/<area>/testing`, `/server/testing`                                                                                          | Fixture hosts, demo data, a scripted provider: for docs, demos and an app's tests                                                                   |
+| `zidane-ui/<area>/testing/contract`                                                                                                    | The suite every implementation of an area's host runs (vitest)                                                                                      |
+| `zidane-ui/core.css`, `zidane-ui/styles.css`, `zidane-ui/reset.css`                                                                    | Prebuilt stylesheets (see Styling)                                                                                                                  |
+| `zidane-ui/styles/<part>.css`                                                                                                          | The kit stylesheet as source, for apps that run UnoCSS                                                                                              |
+
+`dist/` keeps one module per source module and the JS is side-effect free, so a page pays for what it imports (one component from `zidane-ui` costs that component). No module carries `'use client'`: with React Server Components, import the kit from a client component of your own.
+
+## Styling
+
+Pick one route:
+
+- **No UnoCSS in the app:** import one prebuilt stylesheet. `zidane-ui/core.css` has the design system alone; `zidane-ui/styles.css` has everything (chat, setup wizard, editor, terminal). Each carries the utility classes and `i-ph-*` icons the kit's components use, then the kit stylesheet. Add a reset first if the page has none (`zidane-ui/reset.css` or your own).
+
+  The prebuilt files sit in cascade layers (`zidane-ui.reset`, `zidane-ui.utilities`, `zidane-ui.kit`), so your own unlayered CSS wins over the kit's without a specificity fight. They only carry the utilities the kit uses: for `bg-zg-raised` and friends in your own markup, use the UnoCSS route, or the `--zg-*` variables directly.
+
+- **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`…
+
+## Theming
+
+Everything paints from `--zg-*` custom properties, with default-dark fallbacks, so the components render with no theme set.
+
+- **Static page or server render:** `themeStylesheet({ dark?, light?, contrast? })` returns `:root.dark { … } :root.light { … }`. Each appearance takes a built-in theme's id (`BUILTIN_THEMES`) or a `Theme` of your own. Put it in a `<style>` and set `dark` or `light` on `<html>` before first paint.
+- **At runtime:** `themeCssVars(theme, contrast)` gives the variable map for a theme (an id or a `Theme`); write it on `document.documentElement.style`, and use `withoutTransitions` to snap the swap. For colors picked at runtime, `derivePalette({ canvas, accent, appearance? })` then `paletteToCssVars` (plus `contrastToCssVars` and `depthToCssVars`).
+- **One container:** put the map on an element with the `zg-theme-scope` class plus `dark` or `light`. Portaled layers (popovers, tooltips, overlays) render in `<body>` and keep the page's theme.
+- **Motion:** `html[data-motion="off" | "reduced"]` turns CSS and JS motion down.
+
+## Strings
+
+Every visible string comes from a label dictionary. `LabelsProvider` (and `ChatProvider`'s / `OnboardingProvider`'s `labels`) overrides keys, for a translation or your product's words; providers nest and merge.
+
+## Extending
+
+The headless layers are the seams: an app implements a host (`ChatHost`, `OnboardingHost`, composed as an `AppHost` for `AppHostProvider`) over its own transport, or uses an adapter, and every member the host leaves out hides the control that needs it. The styled layer takes slots instead of forks: the transcript's renderers (`TranscriptRenderersProvider`: Markdown, code blocks, prompts, tool bodies) and actions (`TranscriptActionsProvider`), the composer's badges, mentions and commands, the session list's row props. Every component exports its props type and takes `className`.

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/adapters/browser-appearance-host.d.ts

@@ -0,0 +1,24 @@
+import { ParseAppearanceOptions } from "../appearance/headless/prefs.js";
+import { AppearanceHost } from "../appearance/headless/host.js";
+import { AppearanceStorage } from "../appearance/headless/storage.js";
+import "../appearance/headless/index.js";
+//#region src/adapters/browser-appearance-host.d.ts
+/** Options of {@link createBrowserAppearanceHost}. */
+interface BrowserAppearanceHostOptions extends ParseAppearanceOptions {
+  /** Where the preferences and the snapshot live. Default: `localStorage` (a page without one keeps nothing). */
+  storage?: AppearanceStorage;
+  /** The preferences key. Default: `zg:appearance:v1`. */
+  key?: string;
+  /** The snapshot key. Default: `zg:appearance:boot:v1`. */
+  bootKey?: string;
+  /** Calls `onChange` when another tab changed the preferences. Default: the `storage` event. */
+  watch?: (key: string, onChange: () => void) => () => void;
+}
+/**
+ * Creates an {@link AppearanceHost} over the browser's storage: `prefs` and `boot`.
+ *
+ * @param options - The storage, the keys, how to check code theme ids (`codeThemeTypeOf` from `zidane-ui/appearance`).
+ */
+declare function createBrowserAppearanceHost(options?: BrowserAppearanceHostOptions): AppearanceHost;
+//#endregion
+export { BrowserAppearanceHostOptions, createBrowserAppearanceHost };

package/dist/adapters/browser-appearance-host.js

@@ -0,0 +1,34 @@
+import { createStorageAppearancePrefs, createStorageBoot } from "../appearance/headless/storage.js";
+//#region src/adapters/browser-appearance-host.ts
+/**
+* An `AppearanceHost` (`zidane-ui/appearance/headless`) over the browser's
+* `localStorage`: the web app's. zidane-server keeps no appearance (the
+* protocol leaves themes and preferences client-local), so the preferences
+* and the pre-paint snapshot live in the page's storage, under the keys the
+* desktop app uses, and another tab's change is adopted through the
+* `storage` event. Built-in themes only: the server lists no extension themes.
+*/
+/** `localStorage`, read at each call: a page without it (or with it disabled) throws, and the stores catch it. */
+const pageStorage = {
+	getItem: (key) => localStorage.getItem(key),
+	setItem: (key, value) => localStorage.setItem(key, value)
+};
+/**
+* Creates an {@link AppearanceHost} over the browser's storage: `prefs` and `boot`.
+*
+* @param options - The storage, the keys, how to check code theme ids (`codeThemeTypeOf` from `zidane-ui/appearance`).
+*/
+function createBrowserAppearanceHost(options = {}) {
+	const { storage = pageStorage, key, bootKey, watch, codeThemeType } = options;
+	return {
+		prefs: createStorageAppearancePrefs({
+			storage,
+			...key ? { key } : {},
+			...watch ? { watch } : {},
+			...codeThemeType ? { codeThemeType } : {}
+		}),
+		boot: createStorageBoot(storage, bootKey)
+	};
+}
+//#endregion
+export { createBrowserAppearanceHost };

package/dist/adapters/browser-keybindings-host.d.ts

@@ -0,0 +1,18 @@
+import { KeybindingsHost } from "../keybindings/headless/host.js";
+import "../keybindings/headless/index.js";
+//#region src/adapters/browser-keybindings-host.d.ts
+/** Options of {@link createBrowserKeybindingsHost}. */
+interface BrowserKeybindingsHostOptions {
+  /** Where the overrides live. Default: `localStorage` (a page without one keeps none). */
+  storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+  /** The key. Default: `zg:keybindings:v1`. */
+  key?: string;
+}
+/**
+ * Creates a {@link KeybindingsHost} over the browser's storage: the overrides and `save`.
+ *
+ * @param options - The storage and the key.
+ */
+declare function createBrowserKeybindingsHost(options?: BrowserKeybindingsHostOptions): KeybindingsHost;
+//#endregion
+export { BrowserKeybindingsHostOptions, createBrowserKeybindingsHost };

package/dist/adapters/browser-keybindings-host.js

@@ -0,0 +1,40 @@
+import { createKeybindingOverrides } from "../keybindings/headless/overrides.js";
+//#region src/adapters/browser-keybindings-host.ts
+/**
+* A `KeybindingsHost` (`zidane-ui/keybindings/headless`) over the browser's
+* `localStorage`: the web app's. zidane-server keeps no keybindings (the
+* protocol leaves them client-local, and `~/.zidane/keybindings.json` is the
+* desktop app's), so the overrides live in the page's storage as one JSON map.
+*/
+/** The key the overrides live under by default. */
+const KEYBINDINGS_KEY = "zg:keybindings:v1";
+const pageStorage = {
+	getItem: (key) => localStorage.getItem(key),
+	setItem: (key, value) => localStorage.setItem(key, value),
+	removeItem: (key) => localStorage.removeItem(key)
+};
+/**
+* Creates a {@link KeybindingsHost} over the browser's storage: the overrides and `save`.
+*
+* @param options - The storage and the key.
+*/
+function createBrowserKeybindingsHost(options = {}) {
+	const { storage = pageStorage, key = KEYBINDINGS_KEY } = options;
+	const state = createKeybindingOverrides(async () => {
+		const raw = storage.getItem(key);
+		return raw === null ? void 0 : JSON.parse(raw);
+	});
+	return {
+		...state,
+		async save(overrides) {
+			try {
+				if (Object.keys(overrides).length === 0) storage.removeItem(key);
+				else storage.setItem(key, JSON.stringify(overrides));
+			} finally {
+				await state.refresh();
+			}
+		}
+	};
+}
+//#endregion
+export { createBrowserKeybindingsHost };

package/dist/adapters/browser-workspace-host.d.ts

@@ -0,0 +1,23 @@
+import { WorkspaceHost } from "../workspace/headless/host.js";
+import { LayoutStorage, LayoutStoreOptions } from "../workspace/headless/layouts.js";
+import { ServerClient } from "zidane/ipc/browser";
+//#region src/adapters/browser-workspace-host.d.ts
+/** Options for {@link createBrowserWorkspaceHost}. */
+interface BrowserWorkspaceHostOptions extends LayoutStoreOptions {
+  /** Where layouts persist. Default: `localStorage` when there is one, else in memory. */
+  storage?: LayoutStorage;
+  /** The storage key. Default: `zidane-ui:workspace:v1`. */
+  key?: string;
+  /** Hears another tab's writes. Default: the `storage` event on `window`. */
+  listenExternal?: (onExternalWrite: (key: string | null) => void) => () => void;
+  /** The server whose extension panels it offers. Absent, or a server without `panels.list`: none. */
+  client?: ServerClient;
+}
+/**
+ * Creates the web app's {@link WorkspaceHost}: layouts in browser storage, and the server's extension panels.
+ *
+ * @param options - The storage, its key, what an unknown scope reads, how other tabs' writes arrive and the server.
+ */
+declare function createBrowserWorkspaceHost(options?: BrowserWorkspaceHostOptions): WorkspaceHost;
+//#endregion
+export { BrowserWorkspaceHostOptions, createBrowserWorkspaceHost };

package/dist/adapters/browser-workspace-host.js

@@ -0,0 +1,90 @@
+import { createStorageLayouts } from "../workspace/headless/layouts.js";
+//#region src/adapters/browser-workspace-host.ts
+function memoryStorage() {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		getItem: (k) => map.get(k) ?? null,
+		setItem: (k, v) => void map.set(k, v)
+	};
+}
+function defaultStorage() {
+	try {
+		if (typeof localStorage !== "undefined") return localStorage;
+	} catch {}
+	return memoryStorage();
+}
+/** The server's extension panels. */
+function serverPanels(client) {
+	return {
+		list: (cwd) => client.call("panels.list", { cwd }),
+		load: (cwd, panelId, ctx) => client.call("panels.load", {
+			cwd,
+			panelId,
+			ctx
+		}),
+		action: async (cwd, panelId, actionId, payload, ctx) => {
+			const result = await client.call("panels.action", {
+				cwd,
+				panelId,
+				actionId,
+				payload,
+				ctx
+			});
+			return result.ok ? result : {
+				ok: false,
+				error: {
+					code: "failed",
+					message: result.error
+				}
+			};
+		},
+		watch: (cwd, panelId) => {
+			const watch = () => void client.call("panels.watch", {
+				cwd,
+				panelId
+			}).catch(() => void 0);
+			const offOpen = client.onOpen(watch);
+			watch();
+			return () => {
+				offOpen();
+				client.call("panels.unwatch", {
+					cwd,
+					panelId
+				}).catch(() => void 0);
+			};
+		},
+		subscribe: (onChange) => client.onSignal((signal) => {
+			if (signal.kind === "panel:changed") onChange({
+				cwd: signal.cwd,
+				panelId: signal.panelId
+			});
+		}),
+		subscribeCatalog: (onChange) => {
+			const offSignal = client.onSignal((signal) => {
+				if (signal.kind === "catalog:changed" && (signal.catalog === "extensions" || signal.catalog === "plugins")) onChange();
+			});
+			const offOpen = client.onOpen(() => onChange());
+			return () => {
+				offSignal();
+				offOpen();
+			};
+		}
+	};
+}
+/**
+* Creates the web app's {@link WorkspaceHost}: layouts in browser storage, and the server's extension panels.
+*
+* @param options - The storage, its key, what an unknown scope reads, how other tabs' writes arrive and the server.
+*/
+function createBrowserWorkspaceHost(options = {}) {
+	const { storage = defaultStorage(), client, ...rest } = options;
+	return {
+		layouts: createStorageLayouts({
+			storage,
+			...rest
+		}),
+		...client?.can("panels.list") ? { panels: serverPanels(client) } : {}
+	};
+}
+//#endregion
+export { createBrowserWorkspaceHost };

package/dist/adapters/closable-client.d.ts

@@ -0,0 +1,14 @@
+import { ServerClient } from "zidane/ipc/browser";
+//#region src/adapters/closable-client.d.ts
+/**
+ * A view of a shared client whose listeners one `close()` removes, for a host
+ * that listens for its whole life: the host listens through `client`, and its
+ * own `close()` calls this one. The shared client stays open. A listener added
+ * after `close()` is never attached.
+ */
+declare function closableClient(shared: ServerClient): {
+  client: ServerClient;
+  close(): void;
+};
+//#endregion
+export { closableClient };

package/dist/adapters/closable-client.js

@@ -0,0 +1,33 @@
+//#region src/adapters/closable-client.ts
+/**
+* A view of a shared client whose listeners one `close()` removes, for a host
+* that listens for its whole life: the host listens through `client`, and its
+* own `close()` calls this one. The shared client stays open. A listener added
+* after `close()` is never attached.
+*/
+function closableClient(shared) {
+	const offs = /* @__PURE__ */ new Set();
+	let closed = false;
+	const track = (on) => (listener) => {
+		if (closed) return () => void 0;
+		const off = on(listener);
+		const once = () => {
+			if (offs.delete(once)) off();
+		};
+		offs.add(once);
+		return once;
+	};
+	const client = Object.create(shared);
+	client.onSignal = track(shared.onSignal);
+	client.onOpen = track(shared.onOpen);
+	client.onState = track(shared.onState);
+	return {
+		client,
+		close() {
+			closed = true;
+			for (const off of [...offs]) off();
+		}
+	};
+}
+//#endregion
+export { closableClient };

package/dist/adapters/index.d.ts

@@ -0,0 +1,27 @@
+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 { 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";
+import { SseHost, SseHostOptions, createSseHost } from "./sse-host.js";
+import { SseParser, SseRecord, createSseParser } from "./sse-parser.js";
+import { AnswerBody, HydrateResponse, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, StreamRecord, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor } from "./sse-protocol.js";
+import { SERVER_AUTH_CHECK_PATH, ServerCallError, ServerClient, ServerClientOptions, ServerClientState, ServerConnectionError, ServerRefusal, createServerClient } from "./server-client.js";
+import { ServerHost, ServerHostOptions, createServerHost, toChatModelProviders, toChatSession, toSidebarListSession } from "./server-host.js";
+import { ServerApprovalsHostOptions, createServerApprovalsHost } from "./server-approvals-host.js";
+import { ServerSessionHost, ServerSessionHostOptions, createServerSessionHost } from "./server-session-host.js";
+import { ServerComposerHost, ServerComposerHostOptions, createServerComposerHost } from "./server-composer-host.js";
+import { ServerPaletteHost, ServerPaletteHostOptions, createServerPaletteHost } from "./server-palette-host.js";
+import { ServerTerminalHostOptions, createServerTerminalHost } from "./server-terminal-host.js";
+import { ServerGitHostOptions, createServerGitHost } from "./server-git-host.js";
+import { ServerFilesHostOptions, createServerFilesHost } from "./server-files-host.js";
+import { SERVER_MACHINES_HOST_ID, ServerMachinesHost, ServerMachinesHostOptions, createServerMachinesHost } from "./server-machines-host.js";
+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 { 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 };

package/dist/adapters/index.js

@@ -0,0 +1,26 @@
+import { createBrowserAppearanceHost } from "./browser-appearance-host.js";
+import { createBrowserKeybindingsHost } from "./browser-keybindings-host.js";
+import { createBrowserWorkspaceHost } from "./browser-workspace-host.js";
+import { applyLiveEvent, closeThinkingSegment, finishLive } from "../chat/headless/streams/live-events.js";
+import { createLiveState } from "./live.js";
+import { createRunHost } from "./run-host.js";
+import { WORKER_PROTOCOL_VERSION, decodeFromWorker, decodeToWorker } from "./worker-protocol.js";
+import { createWorkerHost, exposeRunHost } from "./worker-host.js";
+import { createSseParser } from "./sse-parser.js";
+import { SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor } from "./sse-protocol.js";
+import { createSseHost } from "./sse-host.js";
+import { SERVER_AUTH_CHECK_PATH, ServerCallError, ServerConnectionError, createServerClient } from "./server-client.js";
+import { createServerHost, toChatModelProviders, toChatSession, toSidebarListSession } from "./server-host.js";
+import { createServerApprovalsHost } from "./server-approvals-host.js";
+import { createServerSessionHost } from "./server-session-host.js";
+import { createServerComposerHost } from "./server-composer-host.js";
+import { createServerPaletteHost } from "./server-palette-host.js";
+import { createServerTerminalHost } from "./server-terminal-host.js";
+import { createServerGitHost } from "./server-git-host.js";
+import { createServerFilesHost } from "./server-files-host.js";
+import { SERVER_MACHINES_HOST_ID, createServerMachinesHost } from "./server-machines-host.js";
+import { createServerOnboardingHost } from "./server-onboarding-host.js";
+import { createServerSettingsHost } from "./server-settings-host.js";
+import { createServerSidebarHost } from "./server-sidebar-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 };

package/dist/adapters/live-events.d.ts

@@ -0,0 +1,2 @@
+import { applyLiveEvent, closeThinkingSegment, finishLive } from "../chat/headless/streams/live-events.js";
+export { applyLiveEvent, closeThinkingSegment, finishLive };

package/dist/adapters/live-events.js

@@ -0,0 +1 @@
+export { applyLiveEvent, closeThinkingSegment, finishLive } from "../chat/headless/streams/live-events.js";

package/dist/adapters/live.d.ts

@@ -0,0 +1,58 @@
+import { Readable, Writable } from "../chat/headless/store.js";
+import { ChatAttachment, ChatEvent, ChatInteraction, ChatSession, ChatSessionStatus, Transcript, TranscriptState } from "../chat/headless/host.js";
+import { applyLiveEvent, finishLive } from "../chat/headless/streams/live-events.js";
+import { InteractionRequest } from "zidane/chat";
+//#region src/adapters/live.d.ts
+/** One session's live transcript: its state store and the echo bookkeeping. */
+interface LiveTranscript {
+  /** The session's transcript state, updated as events arrive. */
+  state: Writable<TranscriptState>;
+  /** Prompts this client echoed itself, waiting for the host's echo to drop (the store's pending-echo list). */
+  echoes: string[];
+}
+/** The client half of the live transcript: the stores a {@link ChatHost} exposes, fed by live events. Shared by every adapter. */
+interface LiveState {
+  /** The session list store. */
+  sessions: Writable<readonly ChatSession[]>;
+  /** Created on first use; `onOpen` runs then (an adapter starts its stream there). */
+  transcript(sessionId: string): LiveTranscript;
+  /** The `Transcript` a host hands the components, with `onFirstSubscribe` / `onLastUnsubscribe` hooks. */
+  readable(sessionId: string, extra?: Pick<Transcript, 'loadEarlier'>): Transcript;
+  /** Replaces a session's events with a loaded history and marks it hydrated. `patch` sets other transcript state fields, such as `running`. */
+  hydrate(sessionId: string, events: readonly ChatEvent[], patch?: Partial<TranscriptState>): void;
+  /** A live event from the agent; `echo` marks the host repeating a prompt (dropped when this client echoed it). */
+  apply(sessionId: string, event: ChatEvent, echo?: boolean): void;
+  /** Show the user's prompt at once (with its attachment previews); the host's echo of it is then dropped. */
+  echoPrompt(sessionId: string, text: string, attachments?: readonly ChatAttachment[]): void;
+  /** A run started or ended; the session's status follows (`status` overrides: `'error'`, `'idle'` after an interrupt). */
+  setRunning(sessionId: string, running: boolean, status?: ChatSessionStatus): void;
+  /** Merges fields into a session in the list. A session the list does not hold is ignored. */
+  patchSession(sessionId: string, patch: Partial<ChatSession>): void;
+  /** The store of a session's pending interactions. */
+  pending(sessionId: string): Writable<readonly ChatInteraction[]>;
+  /** Every session's pending interactions, in arrival order. */
+  allPending: Readable<readonly ChatInteraction[]>;
+  /** Adds a pending request to a session. A request already pending is ignored. */
+  addInteraction(sessionId: string, request: InteractionRequest): void;
+  /** Removes a request from the pending interactions of every session. */
+  resolveInteraction(requestId: string): void;
+  /** The session a pending request belongs to. */
+  interactionSession(requestId: string): string | undefined;
+}
+/** Options for {@link createLiveState}. */
+interface LiveStateOptions {
+  /** The sessions the list starts with. Default: none. */
+  sessions?: readonly ChatSession[];
+  /** Called with the session id when the first subscriber of its transcript arrives. An adapter starts the session's stream here. */
+  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;
+}
+/**
+ * Creates the stores a {@link ChatHost} exposes: the session list, per-session transcripts, and pending interactions.
+ *
+ * @param options - The initial sessions and the transcript open and close hooks.
+ */
+declare function createLiveState(options?: LiveStateOptions): LiveState;
+//#endregion
+export { LiveState, LiveStateOptions, LiveTranscript, applyLiveEvent, createLiveState, finishLive };