zidane 4.0.2 → 4.1.4

package/dist/tools.d.ts

@@ -1,95 +1,3 @@
-export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, f as edit, g as glob, h as grep, m as multiEdit } from './skills-use-DwZrNmcw.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, V as ValidationResult, c as createInteractionTool, b as createSpawnTool, v as validateToolArgs } from './validation-Pm--dQEU.js';
-import { a7 as ToolDef } from './agent-BAHrGtqu.js';
-export { a6 as ToolContext, aa as ToolMap } from './agent-BAHrGtqu.js';
-import 'hookable';
-import './presets.js';
-import './types-Bai5rKpa.js';
-import '@modelcontextprotocol/sdk/client/index.js';
-
-declare const listFiles: ToolDef;
-
-declare const readFile: ToolDef;
-
-declare const shell: ToolDef;
-
-/**
- * `tool_search` — progressive tool disclosure.
- *
- * Counterpart to `skills_use` for the MCP tool surface: the catalog (name +
- * description) lives in the system prompt; full `inputSchema` payloads load
- * lazily through this tool. After a successful match, the matched tools'
- * canonical names are added to the per-run "unlocked" set and become callable
- * immediately (the loop rebuilds `formattedTools` before the next provider
- * request, advertising the unlocked tools to the provider).
- *
- * Aliasing: the tool advertises and matches on the **wire** (alias-rewritten)
- * name — the only name the model ever sees. Internally each lazy entry also
- * carries its `canonicalName`, which is what gets added to the `unlocked` set
- * (the loop's tool registry is keyed by canonical name).
- *
- * Result shape: structured pseudo-XML wrapping a JSON `inputSchema` payload.
- * The schema is inlined verbatim (NOT XML-escaped) so the model can reuse it
- * directly when constructing arguments — escaping the JSON would force the
- * model to mentally un-escape `"` etc. when reasoning about field types.
- */
-
-interface LazyToolEntry {
-    /**
-     * Wire name (after `toolAliases` rewrite). What the model sees in the
-     * catalog, what `tool_search` matches against, and what the provider's
-     * tool list will carry once the entry is unlocked.
-     */
-    name: string;
-    /**
-     * Canonical (registry-key) name used for unlock-set membership and for the
-     * loop's `ctx.tools[name]` dispatch lookup. Equal to `name` when no alias
-     * is configured for this tool.
-     */
-    canonicalName: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-    /** Source MCP server, when applicable. Used for `server`-bulk unlock. */
-    server?: string;
-}
-interface ToolSearchToolOptions {
-    /**
-     * Snapshot of every lazy tool the model can discover. Built once per run by
-     * the agent — the tool closes over this array and never mutates it.
-     */
-    catalog: readonly LazyToolEntry[];
-    /**
-     * Mutable per-run set of unlocked **canonical** tool names. The tool adds
-     * matches in place; the loop reads the set when rebuilding the wire-level
-     * tool list. Keyed by canonical (not wire) so dispatch lookups stay
-     * alias-stable.
-     */
-    unlocked: Set<string>;
-    /** Default cap on returned matches when the model omits `limit`. */
-    defaultLimit?: number;
-}
-/**
- * Factory for `tool_search`. Auto-injected by the agent when
- * `behavior.toolDisclosure === 'lazy'` and at least one MCP tool is in the
- * registry. Opt out via `behavior.toolSearch.tool === false`.
- */
-declare function createToolSearchTool(options: ToolSearchToolOptions): ToolDef;
-
-/**
- * Write a file, with an idempotency signal when the content is unchanged.
- *
- * Three return shapes — chosen so the model can recognize a no-op without a
- * separate read:
- *   - `Created path (N bytes)` — file did not exist
- *   - `Updated path (N bytes)` — content differed from on-disk
- *   - `No change needed: path already at target state (N bytes)` — equal
- *
- * Race window: in non-process execution contexts (docker, sandbox) shared by
- * multiple agents, another writer can mutate the file between our read and
- * our write. Local process context is single-writer per agent so the race is
- * a non-issue there. Documented rather than locked because the cost of
- * cross-context locking outweighs the cost of a stale "No change" message.
- */
-declare const writeFile: ToolDef;
-
-export { type LazyToolEntry, ToolDef, type ToolSearchToolOptions, createToolSearchTool, listFiles, readFile, shell, writeFile };
+import { _ as ToolDef, g as ToolContext, v as ToolMap } from "./agent-BoV5Twdl.js";
+import { A as edit, C as readFile, D as createInteractionTool, E as InteractionToolOptions, O as grep, S as shell, T as listFiles, _ as createSkillsUseTool, b as SkillsReadToolOptions, c as validateToolArgs, d as createToolSearchTool, f as ChildAgent, g as SkillsUseToolOptions, h as createSpawnTool, k as glob, l as LazyToolEntry, m as SpawnToolState, o as writeFile, p as SpawnToolOptions, s as ValidationResult, u as ToolSearchToolOptions, v as SkillsRunScriptToolOptions, w as multiEdit, x as createSkillsReadTool, y as createSkillsRunScriptTool } from "./index-28otmfLX.js";
+export { ChildAgent, InteractionToolOptions, LazyToolEntry, SkillsReadToolOptions, SkillsRunScriptToolOptions, SkillsUseToolOptions, SpawnToolOptions, SpawnToolState, ToolContext, ToolDef, ToolMap, ToolSearchToolOptions, ValidationResult, createInteractionTool, createSkillsReadTool, createSkillsRunScriptTool, createSkillsUseTool, createSpawnTool, createToolSearchTool, edit, glob, grep, listFiles, multiEdit, readFile, shell, validateToolArgs, writeFile };

package/dist/tools.js

@@ -1,40 +1,2 @@
-import {
-  createInteractionTool,
-  createSkillsReadTool,
-  createSkillsRunScriptTool,
-  createSkillsUseTool,
-  createSpawnTool,
-  createToolSearchTool,
-  edit,
-  glob,
-  grep,
-  listFiles,
-  multiEdit,
-  readFile,
-  shell,
-  validateToolArgs,
-  writeFile
-} from "./chunk-4LPBN547.js";
-import "./chunk-6STZTA4N.js";
-import "./chunk-IC7FT4OD.js";
-import "./chunk-UD25QF3H.js";
-import "./chunk-7GQ7P6DM.js";
-import "./chunk-JH6IAAFA.js";
-import "./chunk-LNN5UTS2.js";
-export {
-  createInteractionTool,
-  createSkillsReadTool,
-  createSkillsRunScriptTool,
-  createSkillsUseTool,
-  createSpawnTool,
-  createToolSearchTool,
-  edit,
-  glob,
-  grep,
-  listFiles,
-  multiEdit,
-  readFile,
-  shell,
-  validateToolArgs,
-  writeFile
-};
+import { a as multiEdit, c as grep, f as createToolSearchTool, g as validateToolArgs, h as createSkillsReadTool, i as readFile, l as glob, m as createSkillsRunScriptTool, n as createSpawnTool, o as listFiles, p as createSkillsUseTool, r as shell, s as createInteractionTool, t as writeFile, u as edit } from "./tools-DpeWKzP1.js";
+export { createInteractionTool, createSkillsReadTool, createSkillsRunScriptTool, createSkillsUseTool, createSpawnTool, createToolSearchTool, edit, glob, grep, listFiles, multiEdit, readFile, shell, validateToolArgs, writeFile };

package/dist/tui.d.ts

@@ -0,0 +1,533 @@
+import { Et as SessionTurn, H as Provider, It as TurnUsage, Mt as ToolResultContent, O as SessionStore } from "./agent-BoV5Twdl.js";
+import { P as Preset } from "./index-28otmfLX.js";
+import { SyntaxStyle } from "@opentui/core";
+import * as _$react from "react";
+import { Dispatch, ReactNode, SetStateAction } from "react";
+
+//#region src/tui/auth.d.ts
+type ProviderKey = 'anthropic' | 'openai' | 'openrouter' | 'cerebras';
+interface AuthMethod {
+  source: 'env' | 'oauth';
+  /** Human-readable detail (env var name, expiry timestamp, …). */
+  detail: string;
+}
+interface ProviderAuth {
+  key: ProviderKey;
+  label: string;
+  /** True when at least one credential source is present. */
+  available: boolean;
+  methods: AuthMethod[];
+}
+declare function envKeyFor(key: ProviderKey): string;
+/**
+ * Detect available auth across the providers the harness ships with.
+ *
+ * Mirrors the resolution order used by the providers at runtime:
+ *   - explicit env var (highest)
+ *   - OAuth credentials in `.credentials.json` (anthropic + openai-codex only)
+ *
+ * Pure read — never refreshes or rewrites the credentials file.
+ */
+declare function detectAuth(env?: Record<string, string | undefined>): ProviderAuth[];
+//#endregion
+//#region src/tui/types.d.ts
+type Screen = 'auth' | 'sessions' | 'chat';
+/** Identifies the agent that produced a streaming event. */
+type Owner = 'parent' | string;
+interface StreamEvent {
+  kind: 'thinking' | 'tool' | 'tool-result' | 'error' | 'info' | 'separator' | 'markdown' | 'spawn-start' | 'spawn-end';
+  text: string;
+  /**
+   * For `markdown` events: true while the block is still receiving deltas.
+   * The renderer applies `md4x.heal()` and keeps OpenTUI's markdown parser in
+   * streaming mode while this is true. Flipped to false on `turn:after`.
+   */
+  streaming?: boolean;
+  /** Subagent that produced this event. Absent / 'parent' = top-level agent. */
+  childId?: string;
+  /** Nesting depth — 0 = parent, ≥ 1 = subagent (matches zidane's spawn depth). */
+  depth?: number;
+}
+interface Picked {
+  provider: ProviderAuth;
+  model: string;
+}
+interface SessionMeta {
+  id: string;
+  title: string;
+  turnCount: number;
+  updatedAt: number;
+}
+/** Persisted, user-toggleable transcript filters. */
+interface Settings {
+  showThinking: boolean;
+  showToolCalls: boolean;
+  showToolResults: boolean;
+}
+//#endregion
+//#region src/tui/store.d.ts
+declare function createTuiStore(dbPath: string): SessionStore;
+interface TuiState {
+  lastProvider?: ProviderKey;
+  lastSessionId?: string;
+  /** Per-provider last-used model id. */
+  lastModelByProvider?: Partial<Record<ProviderKey, string>>;
+  /** User-toggled transcript filters. Persisted so they outlive a launch. */
+  settings?: Partial<Settings>;
+}
+interface StateStoreApi {
+  load: () => TuiState;
+  save: (state: TuiState) => void;
+}
+declare function createStateStore(path: string): StateStoreApi;
+declare function loadState(path: string): TuiState;
+declare function saveState(path: string, state: TuiState): void;
+/**
+ * Load every session and project it to the compact `SessionMeta` shape used by
+ * the picker. Sorted by recency via the underlying store's `list()` contract
+ * (sqlite store returns by `updated_at DESC`).
+ */
+declare function listSessionMeta(store: SessionStore): Promise<SessionMeta[]>;
+/** Derive a short title from the first user message — returns null when empty. */
+declare function titleFromTurns(turns: SessionTurn[]): string | null;
+/**
+ * Replay persisted turns as a viewable transcript. Mirrors the event shape produced
+ * live by the agent hooks so loaded and streaming history render identically.
+ *
+ * Skips `tool_result` blocks (they're not user-visible by default), and inserts a
+ * `separator` event between turn groups so the eye can parse turn boundaries.
+ */
+declare function eventsFromTurns(turns: SessionTurn[]): StreamEvent[];
+/** Shared formatter for the `↳ name(args)` line shown on tool calls. */
+declare function toolCallPreview(name: string, input: Record<string, unknown>): string;
+/** Render tool output as plain text, whether it's a string or structured content. */
+declare function toolResultText(output: string | ToolResultContent[]): string;
+/** Effective context size of the most recent assistant turn — drives the footer indicator. */
+declare function lastContextSizeFromTurns(turns: SessionTurn[]): number;
+//#endregion
+//#region src/tui/config.d.ts
+/**
+ * Structural model metadata — compatible with pi-ai's `Model` interface but
+ * not coupled to it, so callers can pass either pi-ai-shaped objects or a
+ * custom registry of their own.
+ *
+ * Deliberately a structural duplicate of `pi-ai`'s `Model` rather than a
+ * re-export: keeps the public API stable when pi-ai bumps shape, and lets
+ * hosts implement their own registry without depending on pi-ai's types.
+ */
+interface ModelInfo {
+  id: string;
+  name?: string;
+  contextWindow: number;
+  maxTokens?: number;
+  reasoning?: boolean;
+  input?: readonly ('text' | 'image')[];
+  cost?: {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+  };
+  provider?: string;
+}
+type ProviderRegistry = Partial<Record<ProviderKey, () => Provider>>;
+type ModelRegistry = Partial<Record<ProviderKey, readonly ModelInfo[]>>;
+/**
+ * Options accepted by `runTui()` and `resolveConfig()`. Every field is optional
+ * — sensible defaults boot a working chat against the four built-in providers
+ * with sessions stored under `~/.zidane/`.
+ */
+interface TuiOptions {
+  /**
+   * Directory name used under `storageDir` for sessions + state.
+   * Default: `'.zidane'` → `~/.zidane/sessions.db` + `~/.zidane/state.json`.
+   * Pass e.g. `'.myapp'` for `~/.myapp/...`, or `'myapp'` for a visible dir.
+   */
+  prefix?: string;
+  /**
+   * Storage root. Defaults to the user's home directory. Combined with
+   * `prefix` to form the data directory.
+   */
+  storageDir?: string;
+  /**
+   * Provider factory map. Override entries (or supply a whole new map) to
+   * register custom providers. Default: anthropic/openai/openrouter/cerebras
+   * from the built-in zidane factories.
+   */
+  providers?: ProviderRegistry;
+  /**
+   * Agent preset (tools, system prompt, behavior). Default: `basic`.
+   */
+  preset?: Preset;
+  /**
+   * Bring your own session store. Default: a SQLite store at
+   * `<storageDir>/<prefix>/sessions.db`.
+   */
+  store?: SessionStore;
+  /**
+   * Per-provider model registry for the in-app model picker. Each list should
+   * be in pi-ai's `Model`-compatible shape (see `ModelInfo`). If omitted, the
+   * picker falls back to pi-ai's built-in registry via `getModels()`.
+   */
+  models?: ModelRegistry;
+}
+interface ResolvedConfig {
+  prefix: string;
+  storageDir: string;
+  paths: {
+    dir: string;
+    db: string;
+    state: string;
+  };
+  providers: ProviderRegistry;
+  preset: Preset;
+  store: SessionStore;
+  stateStore: StateStoreApi;
+  /** Lookup by `ProviderKey` returning the available models for the picker. */
+  modelsFor: (key: ProviderKey) => readonly ModelInfo[];
+  initialState: TuiState;
+  initialSettings: Partial<Settings>;
+  resumeProvider: ProviderAuth | null;
+  initialPicked: Picked | null;
+}
+/** Resolve user options into a fully-bound runtime config. Pure aside from disk reads. */
+declare function resolveConfig(options?: TuiOptions): ResolvedConfig;
+declare function ConfigProvider({
+  config,
+  children
+}: {
+  config: ResolvedConfig;
+  children: ReactNode;
+}): ReactNode;
+declare function useConfig(): ResolvedConfig;
+//#endregion
+//#region src/tui/app.d.ts
+/**
+ * Top-level TUI component. Accepts a fully-resolved `ResolvedConfig` and wires
+ * everything (settings, modal layer, screens, footer) underneath it.
+ *
+ * Hosts can either drive this via `runTui()` for the standard bootstrap or
+ * mount `<App config={resolveConfig(...)} />` themselves inside a renderer
+ * they already own.
+ */
+declare function App({
+  config
+}: {
+  config: ResolvedConfig;
+}): _$react.ReactNode;
+//#endregion
+//#region src/tui/components.d.ts
+/**
+ * `@opentui/react` extends `React.JSX.IntrinsicElements`, so `onSubmit` on `<input>`
+ * gets intersected with the DOM `SubmitEvent` shape and demands an unhelpful overload.
+ * The OpenTUI input runtime fires `(value: string) => void`; this helper isolates
+ * the cast so each call site stays readable.
+ */
+declare function onInputSubmit(handler: (value: string) => void): never;
+interface Hint {
+  key: string;
+  label: string;
+}
+interface ContextUsage {
+  used: number;
+  max: number;
+}
+declare function Footer({
+  hints,
+  picked,
+  context
+}: {
+  hints: Hint[];
+  picked: Picked | null;
+  context: ContextUsage | null;
+}): _$react.ReactNode;
+declare function Spinner({
+  label
+}: {
+  label: string;
+}): _$react.ReactNode;
+declare function Transcript({
+  events,
+  settings
+}: {
+  events: StreamEvent[];
+  settings: Settings;
+}): _$react.ReactNode;
+/**
+ * Resolve the top margin for an event given the one rendered just before it.
+ *
+ * The only context-aware rule today: a tool/tool-result event that follows
+ * another tool/tool-result event collapses its margin to zero, so a chain of
+ * tool calls reads as a tight list — whether the user has hidden tool outputs
+ * or not, and whether the agent emits back-to-back calls or call→result pairs.
+ *
+ * Exported so the spacing matrix can be unit-tested without rendering.
+ */
+declare function marginTopFor(event: StreamEvent, previous: StreamEvent | undefined): number;
+//#endregion
+//#region src/tui/format.d.ts
+/** Compact token formatter — 12_415 → "12.4k", 1_234_567 → "1.23M". */
+declare function fmtTokens(n: number): string;
+/** Compact relative-time formatter — "just now / 5m / 3h / 2d". */
+declare function ageString(ts: number, now?: number): string;
+/** Six-char short form of a session id for headers and lists. */
+declare function shortId(id: string): string;
+//#endregion
+//#region src/tui/modal.d.ts
+interface ModalApi {
+  open: (node: ReactNode) => void;
+  close: () => void;
+  isOpen: boolean;
+}
+declare function ModalRoot({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+declare function useModal(): ModalApi;
+/**
+ * Focus computed against the modal layer.
+ *
+ * Pass a component's preferred focus state and this returns `false` whenever a
+ * modal is open — so focused inputs (textarea, selects) release their focus and
+ * stop intercepting keys behind the overlay. Pair with `focusable={false}` on
+ * "passive" focusables (scrollbox) so the renderer doesn't cycle focus into
+ * them when the primary input blurs.
+ */
+declare function useModalAwareFocus(preferred?: boolean): boolean;
+interface ModalProps {
+  title?: string;
+  /** Called when the user presses esc. Defaults to `useModal().close()` if available. */
+  onClose?: () => void;
+  children: ReactNode;
+  /** Preferred width in columns. Modal grows to this when the terminal allows. */
+  maxWidth?: number;
+  /** Floor on the width, so content stays minimally legible. */
+  minWidth?: number;
+  /** Columns of breathing room kept on each side of the modal. */
+  horizontalMargin?: number;
+}
+/**
+ * Responsive modal — picks a width based on the live terminal size.
+ *
+ * - On a wide terminal, the modal grows to `maxWidth` so descriptions sit on
+ *   one line and don't wrap.
+ * - On a narrow terminal, the modal shrinks down to `minWidth`, keeping a
+ *   small horizontal margin from the screen edges. Text inside wraps naturally.
+ *
+ * Uses `useTerminalDimensions()` so it reflows on `SIGWINCH` without remount.
+ */
+declare function Modal({
+  title,
+  onClose,
+  children,
+  maxWidth,
+  minWidth,
+  horizontalMargin
+}: ModalProps): ReactNode;
+//#endregion
+//#region src/tui/model-picker.d.ts
+/**
+ * Modal that lists the available models for the current provider and lets the
+ * user pick one. Options come from `runTui({ models })` if supplied, otherwise
+ * from pi-ai's built-in registry.
+ *
+ * Each row shows: `● selected · name (ctx N · reasoning · vision)`.
+ */
+declare function ModelPickerModal({
+  models,
+  currentModelId,
+  onPick
+}: {
+  models: readonly ModelInfo[];
+  currentModelId: string;
+  onPick: (modelId: string) => void;
+}): _$react.ReactNode;
+//#endregion
+//#region src/tui/providers.d.ts
+/**
+ * Construct a fresh provider instance for a given key.
+ *
+ * Providers are cheap to build — credentials are resolved lazily at first
+ * stream call — so we instantiate on demand rather than caching a singleton.
+ * This also avoids leaking state across session/provider switches.
+ */
+declare const FACTORIES: Record<ProviderKey, () => Provider>;
+/** zidane provider key → pi-ai provider id (some don't match 1:1). */
+declare const PI_PROVIDER_ID: Record<ProviderKey, string>;
+/**
+ * Look up the model's max context window via pi-ai's model registry.
+ * Returns `null` when the model isn't known (e.g. a custom openrouter slug);
+ * callers should hide the context indicator in that case.
+ */
+declare function getContextWindow(key: ProviderKey, modelId: string): number | null;
+//#endregion
+//#region src/tui/screens.d.ts
+declare function AuthScreen({
+  onPick
+}: {
+  onPick: (p: ProviderAuth) => void;
+}): _$react.ReactNode;
+declare function SessionsScreen({
+  sessions,
+  currentId,
+  onPick,
+  onCreate
+}: {
+  sessions: SessionMeta[];
+  currentId: string | null;
+  onPick: (id: string) => void;
+  onCreate: () => void;
+}): _$react.ReactNode;
+declare function ChatScreen({
+  events,
+  busy,
+  settings,
+  onSubmit,
+  session
+}: {
+  events: StreamEvent[];
+  busy: boolean;
+  settings: Settings;
+  onSubmit: (prompt: string) => void;
+  session: SessionMeta | null;
+}): _$react.ReactNode;
+//#endregion
+//#region src/tui/settings.d.ts
+declare const DEFAULT_SETTINGS: Settings;
+interface SettingsContextValue {
+  settings: Settings;
+  toggle: (key: keyof Settings) => void;
+}
+declare function SettingsProvider({
+  initial,
+  onChange,
+  children
+}: {
+  initial: Settings;
+  onChange?: (settings: Settings) => void;
+  children: ReactNode;
+}): ReactNode;
+declare function useSettings(): SettingsContextValue;
+declare function SettingsModal(): ReactNode;
+//#endregion
+//#region src/tui/streaming.d.ts
+/** Flip any trailing streaming markdown blocks (any owner) to finalized. */
+declare function finalizeStreamingMarkdown(events: StreamEvent[]): StreamEvent[];
+/** Flip the trailing streaming markdown block for one specific owner. */
+declare function finalizeStreamingMarkdownForOwner(events: StreamEvent[], owner: Owner): StreamEvent[];
+/**
+ * Effective context size for a single turn.
+ *
+ * `usage.input` is misleading on its own when prompt caching is active: providers
+ * (Anthropic, OpenRouter→Anthropic, Gemini) report `input` as the *new uncached*
+ * tokens only — the cached prefix shows up in `cacheRead`, and newly-cached
+ * tokens in `cacheCreation`. The model still saw all three buckets, so the real
+ * context-window utilization is their sum.
+ *
+ * Non-caching providers leave `cacheRead`/`cacheCreation` undefined, so this
+ * collapses to plain `input` for them.
+ */
+declare function turnContextSize(usage: TurnUsage | undefined): number;
+interface StreamSource {
+  /** Pass `undefined` / omit for parent-agent events. */
+  childId?: string;
+  /** Nesting depth — 0 for parent, ≥ 1 for subagents. */
+  depth?: number;
+}
+interface StreamBuffer {
+  /** Queue a streaming delta for the next flush tick. */
+  queueStreamDelta: (kind: 'markdown' | 'thinking', delta: string, source?: StreamSource) => void;
+  /** Drain pending deltas immediately, then append a non-streaming event. */
+  appendImmediate: (evt: StreamEvent) => void;
+  /** Drain pending deltas immediately, then transform the event list. */
+  flushAndUpdate: (update: (events: StreamEvent[]) => StreamEvent[]) => void;
+  /** Drain pending deltas without further transformation. */
+  flush: () => void;
+  /** Cancel any pending flush and drop buffered deltas (on session teardown). */
+  reset: () => void;
+}
+declare function useStreamBuffer(setEvents: Dispatch<SetStateAction<StreamEvent[]>>): StreamBuffer;
+//#endregion
+//#region src/tui/theme.d.ts
+/**
+ * Shared color palette. Kept as plain hex strings so it can be consumed by
+ * OpenTUI props that accept `string | RGBA`. The names describe role, not
+ * literal hue, so the theme can be swapped without touching call sites.
+ */
+declare const COLOR: {
+  readonly brand: "#FFCC00";
+  readonly accent: "#00FF88";
+  readonly model: "#88CCFF";
+  readonly warn: "#FFAA66";
+  readonly error: "#FF6666";
+  readonly dim: "#888888";
+  readonly mute: "#555555";
+  readonly border: "#333333";
+  readonly borderActive: "#555555";
+};
+/**
+ * Shared select styling — keeps the highlight bar from filling with a
+ * different background than the surrounding box. The `▶` marker and the
+ * brand-colored selected text carry the focus affordance.
+ */
+declare const SELECT_THEME: {
+  readonly backgroundColor: "transparent";
+  readonly focusedBackgroundColor: "transparent";
+  readonly selectedBackgroundColor: "transparent";
+  readonly selectedTextColor: "#FFCC00";
+  readonly textColor: "#888888";
+  readonly descriptionColor: "#555555";
+  readonly selectedDescriptionColor: "#888888";
+};
+/**
+ * Theme for markdown token highlighting. Token names map to Tree-sitter highlight
+ * captures emitted by OpenTUI's markdown parser; the `default` entry is the
+ * fallback for unstyled text.
+ */
+declare const MD_STYLE: SyntaxStyle;
+//#endregion
+//#region src/tui/index.d.ts
+/**
+ * Boot a full chat TUI with sensible defaults. **Does not return** under
+ * normal use — it terminates the host process via `process.exit(0)` once
+ * the user dismisses the renderer (Ctrl+C / Esc on the auth screen / a
+ * non-zero exit code is mapped via the `catch` path below).
+ *
+ * **One-shot:** this function may only be invoked once per process. The
+ * underlying OpenTUI renderer wires up global terminal state on init.
+ *
+ * **Why it exits the process:** after the renderer's `destroy()` restores
+ * the terminal, React's reconciler and OpenTUI's internal listeners can
+ * keep the Node/Bun event loop open indefinitely — the script appears to
+ * hang in `bun run`, and under `bun --watch run` the watcher waits forever
+ * for the child to exit. Forcing a clean exit here is the contract that
+ * makes `runTui` a true one-shot launcher.
+ *
+ * Hosts that need post-renderer cleanup should mount `<App config={...} />`
+ * against their own `createCliRenderer()` instead of calling `runTui()`.
+ *
+ * Env-var overrides (handy when launching from CI or restricted shells):
+ *   - `ZIDANE_STORAGE_DIR` — sets `storageDir`
+ *   - `ZIDANE_PREFIX` — sets `prefix`
+ *
+ * Hosts building on top of `zidane/tui` typically want their own env vars
+ * (e.g. `MYAPP_STORAGE_DIR`); read them in your launch script and forward
+ * to `runTui({ storageDir, prefix })`.
+ *
+ * ```ts
+ * import { runTui } from 'zidane/tui'
+ * import { createRemoteStore } from 'zidane/session'  // for the `store` option
+ *
+ * await runTui()                                       // ~/.zidane/sessions.db + state.json
+ * await runTui({ prefix: '.myapp' })                   // ~/.myapp/...
+ * await runTui({ storageDir: '/data', prefix: 'myapp' })
+ * await runTui({ providers: { custom: () => myProvider() } })
+ * await runTui({ store: createRemoteStore({ url: '…' }) })
+ * await runTui({ models: { anthropic: [{ id: 'claude-foo', contextWindow: 200_000 }] } })
+ * ```
+ */
+declare function runTui(options?: TuiOptions): Promise<never>;
+//#endregion
+export { App, type AuthMethod, AuthScreen, COLOR, ChatScreen, ConfigProvider, type ContextUsage, DEFAULT_SETTINGS, FACTORIES, Footer, type Hint, MD_STYLE, Modal, type ModalProps, ModalRoot, type ModelInfo, ModelPickerModal, type ModelRegistry, type Owner, PI_PROVIDER_ID, type Picked, type ProviderAuth, type ProviderKey, type ProviderRegistry, type ResolvedConfig, SELECT_THEME, type Screen, type SessionMeta, SessionsScreen, type Settings, SettingsModal, SettingsProvider, Spinner, type StateStoreApi, type StreamBuffer, type StreamEvent, type StreamSource, Transcript, type TuiOptions, type TuiState, ageString, createStateStore, createTuiStore, detectAuth, envKeyFor, eventsFromTurns, finalizeStreamingMarkdown, finalizeStreamingMarkdownForOwner, fmtTokens, getContextWindow, lastContextSizeFromTurns, listSessionMeta, loadState, marginTopFor, onInputSubmit, resolveConfig, runTui, saveState, shortId, titleFromTurns, toolCallPreview, toolResultText, turnContextSize, useConfig, useModal, useModalAwareFocus, useSettings, useStreamBuffer };
+//# sourceMappingURL=tui.d.ts.map

package/dist/tui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/tui/auth.ts","../src/tui/types.ts","../src/tui/store.ts","../src/tui/config.tsx","../src/tui/app.tsx","../src/tui/components.tsx","../src/tui/format.ts","../src/tui/modal.tsx","../src/tui/model-picker.tsx","../src/tui/providers.ts","../src/tui/screens.tsx","../src/tui/settings.tsx","../src/tui/streaming.ts","../src/tui/theme.ts","../src/tui/index.tsx"],"mappings":"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"}