@june-ai/june-ui 0.2.7 → 0.2.8

package/dist/entry-core.d.ts

@@ -0,0 +1,1005 @@
+import * as react from 'react';
+import { ComponentProps as ComponentProps$1, Component, ReactNode, ErrorInfo, CSSProperties, ComponentType } from 'react';
+import * as _openuidev_react_lang from '@openuidev/react-lang';
+import { Renderer, DefinedComponent, ComponentRenderProps, PromptOptions, createLibrary, defineComponent as defineComponent$1, Library } from '@openuidev/react-lang';
+import { z } from 'zod/v4';
+import { $ZodObject } from 'zod/v4/core';
+import * as _openuidev_lang_core from '@openuidev/lang-core';
+
+/** CSS custom properties June reads. Any other `--name` is passed through as well. */
+type JuneThemeToken = "--june-foreground" | "--june-muted" | "--june-border" | "--june-accent" | "--june-danger";
+/** CSS variable values, e.g. { "--june-accent": "#0ea5e9" }. */
+type JuneThemeVars = Partial<Record<JuneThemeToken, string>> & Record<string, string>;
+/** Separate overrides per resolved mode. */
+interface JuneThemeSet {
+    light?: JuneThemeVars;
+    dark?: JuneThemeVars;
+}
+/** `themeVars` accepts one set for both modes, or a set per mode. */
+type JuneThemeInput = JuneThemeVars | JuneThemeSet;
+type JuneThemeMode = "light" | "dark" | "system";
+type JuneResolvedTheme = "light" | "dark";
+
+/** Props of OpenUI's real Renderer. Derived, never hand-copied. */
+type OpenUIRendererProps = ComponentProps$1<typeof Renderer>;
+/** The library type OpenUI's Renderer accepts. */
+type OpenUILibrary = OpenUIRendererProps["library"];
+/** The event OpenUI passes to onAction. */
+type OpenUIActionEvent = Parameters<NonNullable<OpenUIRendererProps["onAction"]>>[0];
+
+type JuneErrorCode = "PARSE_ERROR" | "RENDER_ERROR" | "STREAM_ERROR" | "STREAM_ABORTED" | "STREAM_EMPTY" | "NETWORK_ERROR" | "ACTION_ERROR" | "ACTION_VALIDATION_ERROR" | "ACTION_REJECTED" | "LIBRARY_ERROR" | "DOCUMENT_ERROR" | "EXPORT_ERROR";
+interface JuneErrorOptions {
+    cause?: unknown;
+    details?: unknown;
+}
+declare class JuneError extends Error {
+    readonly code: JuneErrorCode;
+    readonly details?: unknown;
+    constructor(code: JuneErrorCode, message: string, options?: JuneErrorOptions);
+}
+declare function isJuneError(value: unknown): value is JuneError;
+declare function toJuneError(error: unknown, fallbackCode: JuneErrorCode, message?: string): JuneError;
+
+/** Anything with a zod-style safeParse. No hard dependency on zod. */
+interface SchemaLike<T> {
+    safeParse(data: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: unknown;
+    };
+}
+interface JuneActionContext {
+    name: string;
+    /** The raw OpenUI action event. */
+    event: unknown;
+}
+interface JuneActionDefinition<TPayload = unknown> {
+    description?: string;
+    /** Validates the payload before the handler runs. */
+    schema?: SchemaLike<TPayload>;
+    /** Sensitive actions are denied unless a confirm handler approves them. */
+    sensitive?: boolean;
+    /** Per-action confirmation; overrides the global confirmAction. */
+    confirm?: (args: {
+        name: string;
+        payload: TPayload;
+        description?: string;
+    }) => boolean | Promise<boolean>;
+    handler: (payload: TPayload, context: JuneActionContext) => void | Promise<void>;
+}
+type JuneAction<TPayload = unknown> = Readonly<JuneActionDefinition<TPayload>> & {
+    readonly __june: "action";
+};
+type JuneActionMap = Record<string, JuneAction<any>>;
+declare function defineJuneAction<TPayload = unknown>(definition: JuneActionDefinition<TPayload>): JuneAction<TPayload>;
+
+interface ParsedActionEvent {
+    name: string;
+    payload: unknown;
+}
+type ActionEventParser = (event: OpenUIActionEvent) => ParsedActionEvent | null;
+type ConfirmAction = (args: {
+    name: string;
+    payload: unknown;
+    description?: string;
+}) => boolean | Promise<boolean>;
+type ActionOutcome = "handled" | "unhandled" | "rejected" | "failed";
+/**
+ * BEST-EFFORT default: reads the action name from `type`/`name`/`action` and
+ * the payload from `params`/`payload`/`data`. Verify against OpenUI's actual
+ * action event type (see the .d.ts) and override with `parseActionEvent`
+ * if the shape differs. This is the only place that guesses the event shape.
+ */
+declare const defaultParseActionEvent: ActionEventParser;
+interface RunActionOptions {
+    actions: JuneActionMap;
+    parseEvent?: ActionEventParser;
+    confirm?: ConfirmAction;
+    onError?: (error: JuneError) => void;
+    onUnhandled?: (event: OpenUIActionEvent) => void;
+}
+/** Looks up and runs a registered action. Never evaluates model-provided code. */
+declare function runAction(event: OpenUIActionEvent, options: RunActionOptions): Promise<ActionOutcome>;
+declare function createActionHandler(options: RunActionOptions): (event: OpenUIActionEvent) => void;
+
+interface PendingUpdate {
+    json: DocJSON;
+    title: string;
+    /** AI changes merged in, with the user's version kept where both changed the same blocks. */
+    merged: DocJSON;
+    conflicts: number;
+}
+interface DocumentRecord {
+    id: string;
+    title: string;
+    documentType?: string;
+    status?: string;
+    /** What the user currently sees. */
+    json: DocJSON;
+    /** The last AI version that was accepted. Used as the merge base. */
+    baseJson: DocJSON;
+    baseTitle: string;
+    lastIncomingKey: string;
+    /** Increments whenever `json` changes. */
+    revision: number;
+    /** Which editor (or "external") produced the latest change. */
+    origin: string;
+    pending: PendingUpdate | null;
+    updatedAt: number;
+}
+interface IncomingDocument {
+    id: string;
+    title: string;
+    json: DocJSON;
+    documentType?: string;
+    status?: string;
+}
+type ReceiveOutcome = "created" | "unchanged" | "applied" | "merged" | "conflict";
+type ResolveChoice = "merge" | "replace" | "keep";
+interface DocumentStore {
+    get(id: string): DocumentRecord | undefined;
+    list(): DocumentRecord[];
+    subscribe(listener: () => void): () => void;
+    /** An AI version arrived. Applies it, merges it with user edits, or records a conflict. */
+    receive(incoming: IncomingDocument): ReceiveOutcome;
+    /** Seed or replace a document, for example from your database. */
+    hydrate(doc: IncomingDocument): void;
+    edit(id: string, json: DocJSON, origin: string): void;
+    setTitle(id: string, title: string): void;
+    resolve(id: string, choice: ResolveChoice): void;
+    remove(id: string): void;
+}
+declare function createDocumentStore(): DocumentStore;
+/**
+ * Remembers content produced from the user's own edits (for example when JuneUI rewrites
+ * the OpenUI program). When that content comes back through the DocumentEditor props it is
+ * ignored instead of being treated as a new AI version.
+ */
+declare function rememberDocumentEcho(store: DocumentStore, id: string, content: string): void;
+declare function isDocumentEcho(store: DocumentStore, id: string, content: string): boolean;
+/** The shared in-memory store used when none is provided. Documents are keyed by documentId. */
+declare function getDefaultDocumentStore(): DocumentStore;
+
+/** Structural type of a Tiptap / ProseMirror JSON node. Dependency-free on purpose. */
+interface DocNode {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: DocNode[];
+    marks?: {
+        type: string;
+        attrs?: Record<string, unknown>;
+    }[];
+    text?: string;
+}
+/** Canonical document format: a Tiptap JSON document. */
+interface DocJSON {
+    type: "doc";
+    content?: DocNode[];
+}
+type DocumentExportFormat = "html" | "markdown" | "txt" | "docx" | "pdf";
+declare const ALL_EXPORT_FORMATS: readonly DocumentExportFormat[];
+interface DocumentSnapshot {
+    documentId: string;
+    title: string;
+    documentType?: string;
+    status?: string;
+    json: DocJSON;
+}
+interface DocumentChange extends DocumentSnapshot {
+    /** user = typed in the editor, ai = new AI version applied, merge = AI merged with user edits, resolve = conflict resolved. */
+    source: "user" | "ai" | "merge" | "resolve";
+}
+interface DocumentSavePayload extends DocumentSnapshot {
+    html: string;
+    markdown: string;
+}
+interface DocumentExportEvent {
+    documentId: string;
+    format: string;
+    filename: string;
+    mimeType: string;
+    blob?: Blob;
+    text?: string;
+    /** True when the exporter delivered the file itself (for example the PDF print dialog). */
+    handled?: boolean;
+}
+interface DocumentConflict {
+    documentId: string;
+    title: string;
+    /** Number of regions that both the user and the assistant changed. */
+    conflicts: number;
+}
+interface JuneDocumentOptions {
+    /** Share one store across editors. Defaults to a global in-memory store, keyed by documentId. */
+    store?: DocumentStore;
+    /** Debounce for autosave in ms (default 1500). 0 or less disables autosave. */
+    autosaveDelay?: number;
+    onDocumentChange?: (change: DocumentChange) => void;
+    /** Persist the document. Called by autosave, the Save button and Ctrl/Cmd+S. */
+    onSave?: (payload: DocumentSavePayload) => void | Promise<void>;
+    onExport?: (event: DocumentExportEvent) => void;
+    onDocumentReady?: (snapshot: DocumentSnapshot) => void;
+    onConflict?: (conflict: DocumentConflict) => void;
+    onError?: (error: JuneError) => void;
+}
+interface DocumentEditorProps {
+    documentId: string;
+    title?: string;
+    /** Markdown, a Tiptap JSON string, or a Tiptap JSON object. */
+    content?: string | DocJSON;
+    documentType?: string;
+    /** Default "draft". Drafts show an "AI draft" badge. */
+    status?: string;
+    editable?: boolean;
+    exportFormats?: string[];
+    /** "auto" follows the June theme context. */
+    theme?: "auto" | "light" | "dark";
+    className?: string;
+    /** Show the drafting placeholder instead of the editor (use while content is streaming). */
+    generating?: boolean;
+    /** Callbacks and store. Merged over the values provided through JuneUI's `documents` prop. */
+    options?: JuneDocumentOptions;
+}
+
+interface ResponseChangeInfo {
+    documentId: string;
+    title: string;
+    /** The document body written into the program, as Markdown. */
+    markdown: string;
+    source: DocumentChange["source"];
+}
+interface DocumentBridgeOptions {
+    /** Callbacks and store given by the app. */
+    documents?: JuneDocumentOptions;
+    /** The current OpenUI program (the renderer's `response`). */
+    response: string | null;
+    /** Receives the program rewritten with the user's document edits. */
+    onResponseChange?: (response: string, change: ResponseChangeInfo) => void;
+    /** Debounce for onResponseChange in ms (default 300). */
+    responseChangeDelay?: number;
+    /** Document and sync errors. */
+    onJuneError?: (error: JuneError) => void;
+}
+/**
+ * Connects document editors to the response they came from. Returns the options to provide
+ * through `JuneDocumentContext`: the app's callbacks, plus a debounced write-back of user edits
+ * (body as Markdown, and title) into the matching `DocumentEditor(...)` call of the program.
+ *
+ * Kept in the document feature so the renderer knows nothing about documents.
+ */
+declare function useDocumentBridge(options: DocumentBridgeOptions): JuneDocumentOptions;
+
+interface FallbackArgs {
+    error: Error;
+    reset: () => void;
+}
+interface JuneErrorBoundaryProps {
+    children?: ReactNode;
+    fallback?: ReactNode | ((args: FallbackArgs) => ReactNode);
+    onError?: (error: Error, info: ErrorInfo) => void;
+    /** When any value changes, a caught error is cleared and children re-render. */
+    resetKeys?: readonly unknown[];
+}
+interface State {
+    error: Error | null;
+}
+declare class JuneErrorBoundary extends Component<JuneErrorBoundaryProps, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    componentDidUpdate(prev: JuneErrorBoundaryProps): void;
+    reset: () => void;
+    render(): ReactNode;
+}
+
+/** How prose around the OpenUI program is drawn. */
+type TextFormat = "plain" | "markdown";
+type JuneRendererProps = Omit<OpenUIRendererProps, "library" | "response" | "isStreaming" | "onAction" | "onError" | "className" | "style"> & {
+    library: OpenUILibrary;
+    /** Accumulated model output. OpenUI does the incremental parsing. */
+    response: string | null;
+    isStreaming?: boolean;
+    /** Allow prose around OpenUI statements (default true). */
+    mixedContent?: boolean;
+    /**
+     * "plain" (default): each prose paragraph is a `<p class="june-text">`.
+     * "markdown": prose keeps its line breaks and code blocks and is drawn as Markdown.
+     */
+    textFormat?: TextFormat;
+    /** Custom renderer for prose segments. Overrides `textFormat`'s default drawing. */
+    renderText?: (text: string, index: number) => ReactNode;
+    /**
+     * Rewrite common model mistakes after streaming ends (default true):
+     * Grid and shorthand Card calls, and charts or tables left off root.
+     * Set false to hand the program to OpenUI unchanged.
+     */
+    repair?: boolean;
+    /** Omit to inherit the host app's look. "light" | "dark" | "system" opt in to June's colors. */
+    theme?: JuneThemeMode;
+    /** CSS variable overrides: one map, or `{ light, dark }`. */
+    themeVars?: JuneThemeInput;
+    className?: string;
+    style?: CSSProperties;
+    actions?: JuneActionMap;
+    confirmAction?: ConfirmAction;
+    parseActionEvent?: ActionEventParser;
+    /** Raw OpenUI action event (called for every action, before June actions). */
+    onAction?: (event: OpenUIActionEvent) => void;
+    /** Raw OpenUI errors (called with [] when they resolve). */
+    onError?: (errors: unknown[]) => void;
+    /** Structured errors: parse, render, action, document and export failures. */
+    onJuneError?: (error: JuneError) => void;
+    /** Document editor callbacks and store. Memoize this object. */
+    documents?: JuneDocumentOptions;
+    /**
+     * Called with an updated OpenUI program when the user edits a document (body or title).
+     * The matching `DocumentEditor(id, title, content)` call is rewritten with the new title and
+     * the body as Markdown; nothing else in the program changes. Store the value and pass it back
+     * as `response` to keep your program (and any "OpenUI Lang" view) in sync with the editor.
+     */
+    onResponseChange?: (response: string, change: ResponseChangeInfo) => void;
+    /** Debounce for onResponseChange in ms (default 300). */
+    responseChangeDelay?: number;
+    loadingFallback?: ReactNode;
+    emptyFallback?: ReactNode;
+    errorFallback?: ReactNode | ((args: FallbackArgs) => ReactNode);
+    resetKeys?: readonly unknown[];
+};
+/**
+ * Renders a model response: prose segments plus one OpenUI program, inside June's theme root,
+ * runtime context, document bridge and error boundary. Requires an explicit `library`.
+ */
+declare function JuneRenderer(props: JuneRendererProps): react.JSX.Element;
+
+interface MarkdownTextProps {
+    text: string;
+    className?: string;
+}
+/**
+ * Renders a prose segment as Markdown with OpenUI's MarkDownRenderer (react-markdown: no raw HTML).
+ * Until it loads, the text shows as a plain paragraph.
+ */
+declare function MarkdownText({ text, className }: MarkdownTextProps): react.JSX.Element;
+
+interface SplitResponse {
+    /** Prose before the first OpenUI statement. */
+    before: string[];
+    /** All OpenUI statements joined, so one Renderer resolves every reference. */
+    ui: string;
+    /** Prose after (or between) statements. */
+    after: string[];
+    /** True when the input is already pure OpenUI Lang (no prose, no code fences). */
+    pure: boolean;
+}
+interface SplitOptions {
+    /** Hold back a trailing half-typed identifier so it doesn't flash as prose. */
+    streaming?: boolean;
+    /**
+     * Keep prose as Markdown (default false):
+     * - lines inside a paragraph are joined with "\n" instead of " ";
+     * - fenced code blocks tagged with another language (```python) are kept whole, as prose.
+     * Fences without a language, or tagged `openui` / `openui-lang`, still hold OpenUI Lang.
+     */
+    markdown?: boolean;
+}
+/**
+ * Separates model prose from OpenUI Lang statements. Multi-line statements,
+ * `$state` variables and ``` fences are handled. This does not parse OpenUI
+ * Lang; OpenUI's Renderer still does all parsing. Pure function, no React.
+ */
+declare function splitResponse(source: string, options?: SplitOptions): SplitResponse;
+
+/**
+ * Rewrites OpenUI programs the library cannot paint, then hands the result to
+ * the existing renderer. A program that is already valid is returned unchanged.
+ *
+ * Two cases currently produce an empty assistant bubble:
+ * - `Grid(...)` and `Card("title", "value")` are not components in the library.
+ * - A bar chart, line chart, or table that is never referenced from `root` is
+ *   dropped, so mixed replies render only the root node.
+ */
+declare function normalizeProgram(source: string): string;
+
+interface MixedContentOptions {
+    /** Split prose from OpenUI statements (default true). False passes the response through. */
+    mixedContent?: boolean;
+    isStreaming?: boolean;
+    /** Rewrite common model mistakes once streaming ends (default true). */
+    repair?: boolean;
+    /** Keep prose as Markdown: line breaks and foreign code fences survive (default false). */
+    markdown?: boolean;
+}
+interface MixedContent {
+    /** Prose before the OpenUI program. */
+    before: string[];
+    /** The OpenUI program to hand to the renderer (repaired when allowed), or null/"" when none. */
+    ui: string | null;
+    /** Prose after (or between) statements. */
+    after: string[];
+    hasUi: boolean;
+    hasText: boolean;
+}
+/**
+ * Turns an accumulated model response into prose segments and one OpenUI program.
+ * Pure and synchronous: the renderer memoizes it per response.
+ */
+declare function resolveMixedContent(response: string | null, options?: MixedContentOptions): MixedContent;
+
+/**
+ * Extra information June keeps next to a component. OpenUI ignores it.
+ * `metadata` is free-form: use it for docs, tooling or feature flags.
+ */
+interface JuneComponentMeta {
+    /**
+     * Parent components whose child list should accept this one, as OpenUI `extend` slots:
+     * `"Card"` (parent with a single slot) or `"Card.children"`. Lets the model place the
+     * component inside those parents, and lists it there in the generated prompt.
+     */
+    slots?: readonly string[];
+    metadata?: Readonly<Record<string, unknown>>;
+}
+/** Props given to a `render` function: OpenUI's renderer props (`props`, `renderNode`, `statementId`). */
+type JuneRenderProps<P> = ComponentRenderProps<P>;
+interface DefineComponentBase<S extends $ZodObject> extends JuneComponentMeta {
+    /** Name used in OpenUI Lang, e.g. `card = CustomCard("Title", "Body")`. PascalCase. */
+    name: string;
+    /**
+     * What the component is for. Shown to the model in the generated system prompt,
+     * so write it for the model: when to use it and what the arguments mean.
+     */
+    description: string;
+    /**
+     * Zod object schema for the props. Key order is the positional argument order in
+     * OpenUI Lang. Use `import { z } from "zod/v4"` (or `"zod"` on Zod 4).
+     */
+    schema: S;
+}
+/** A plain React component: receives the validated props directly. */
+interface WithComponent<S extends $ZodObject> extends DefineComponentBase<S> {
+    component: ComponentType<z.infer<S>>;
+    render?: never;
+}
+/** Full OpenUI control: receives `{ props, renderNode, statementId }` (needed to draw child nodes). */
+interface WithRender<S extends $ZodObject> extends DefineComponentBase<S> {
+    render: (args: JuneRenderProps<z.infer<S>>) => ReactNode;
+    component?: never;
+}
+type DefineComponentOptions<S extends $ZodObject> = WithComponent<S> | WithRender<S>;
+/**
+ * A component ready for the registry. It *is* an OpenUI `DefinedComponent`, so it can also be
+ * passed straight to OpenUI's `createLibrary` or `library.extend`.
+ */
+type JuneComponent<S extends $ZodObject = $ZodObject> = DefinedComponent<S> & {
+    readonly june: JuneComponentMeta;
+};
+/** Any component the registry accepts: June's or one made with OpenUI's `defineComponent`. */
+type AnyComponentDefinition = DefinedComponent<any>;
+/** Infers the props type of a component definition. */
+type ComponentProps<C> = C extends DefinedComponent<infer S> ? z.infer<S> : never;
+/** Checks the parts of a definition OpenUI needs. Throws a `JuneError("LIBRARY_ERROR")` with a fix. */
+declare function validateComponentDefinition(definition: {
+    name?: unknown;
+    description?: unknown;
+    schema?: unknown;
+    component?: unknown;
+    render?: unknown;
+}): void;
+/**
+ * Defines a component the model can use in OpenUI Lang.
+ *
+ * ```tsx
+ * const CustomCard = defineComponent({
+ *   name: "CustomCard",
+ *   description: "A card with a title and a description.",
+ *   schema: z.object({ title: z.string(), description: z.string() }),
+ *   component: ({ title, description }) => <section><h3>{title}</h3><p>{description}</p></section>,
+ * });
+ * ```
+ *
+ * OpenUI validates the model's arguments against `schema` before your component renders.
+ */
+declare function defineComponent<S extends $ZodObject>(options: DefineComponentOptions<S>): JuneComponent<S>;
+/** True when the value was made by June's `defineComponent`. */
+declare function isJuneComponent(value: unknown): value is JuneComponent;
+
+interface RegisterOptions {
+    /** Replace a component that already exists (built-in or registered). Default false. */
+    override?: boolean;
+}
+interface ComponentRegistryOptions {
+    /**
+     * Library to extend, e.g. June's default library or OpenUI's `openuiLibrary`.
+     * Omit to start empty (then set `root`).
+     */
+    base?: OpenUILibrary;
+    /** Root component name. Only used when there is no `base`. */
+    root?: string;
+    /** Components to add. Names must be new. */
+    components?: readonly AnyComponentDefinition[];
+    /** Components that replace existing ones with the same name. */
+    overrides?: readonly AnyComponentDefinition[];
+    /** Names to remove from `base`. */
+    remove?: readonly string[];
+}
+type Listener = () => void;
+/**
+ * The set of components the OpenUI renderer can draw.
+ *
+ * Built on OpenUI's own `library.extend` (add / override / remove), so the result is a normal
+ * OpenUI library: pass `registry.library` anywhere a library is expected, and call
+ * `registry.prompt()` to generate the model's system prompt from the same components.
+ *
+ * Changes are validated immediately: a bad registration throws `JuneError("LIBRARY_ERROR")`
+ * and leaves the registry unchanged. `library` keeps the same reference until something changes,
+ * which matters because OpenUI memoizes parsing by library identity.
+ */
+declare class ComponentRegistry {
+    private readonly base;
+    private readonly root;
+    private added;
+    private overridden;
+    private removed;
+    private cached;
+    private listeners;
+    constructor(options?: ComponentRegistryOptions);
+    /** The OpenUI library for the current set of components. Stable until the registry changes. */
+    get library(): OpenUILibrary;
+    /** Adds one or more components. Set `override: true` to replace an existing name. */
+    register(components: AnyComponentDefinition | readonly AnyComponentDefinition[], options?: RegisterOptions): this;
+    /** Replaces existing components by name (same as `register(c, { override: true })`). */
+    override(components: AnyComponentDefinition | readonly AnyComponentDefinition[]): this;
+    /**
+     * Removes a component. A registered component is dropped; an overridden built-in goes back to
+     * the original; a built-in is removed from the library.
+     */
+    unregister(name: string): this;
+    /** Drops every change and returns to the base library. */
+    reset(): this;
+    has(name: string): boolean;
+    get(name: string): AnyComponentDefinition | undefined;
+    /** June metadata (`slots`, `metadata`) of a component, when it was made with June's defineComponent. */
+    getMeta(name: string): JuneComponentMeta | undefined;
+    /** Every component name in the library. */
+    names(): string[];
+    /** Names added or overridden through this registry. */
+    customNames(): string[];
+    /** The system prompt for these components (OpenUI's `library.prompt`). Usually called on the server. */
+    prompt(options?: PromptOptions): string;
+    /** For `useSyncExternalStore`: called after every change. */
+    subscribe: (listener: Listener) => (() => void);
+    getSnapshot: () => OpenUILibrary;
+    private exists;
+    private applyRegister;
+    private applyRemove;
+    /** Applies changes atomically: on error the previous state is restored and the error rethrown. */
+    private transaction;
+    private changed;
+    private notify;
+    private build;
+    private rebuild;
+}
+/** Creates a component registry. See {@link ComponentRegistry}. */
+declare function createComponentRegistry(options?: ComponentRegistryOptions): ComponentRegistry;
+
+/**
+ * Returns the registry's current OpenUI library and re-renders when components are registered,
+ * overridden or removed at runtime.
+ */
+declare function useRegistryLibrary(registry: ComponentRegistry): OpenUILibrary;
+
+/** Re-export of OpenUI's component definer under a June name. */
+declare const defineJuneComponent: typeof defineComponent$1;
+type OpenUILibraryOptions = Parameters<typeof createLibrary>[0];
+type JuneLibraryOptions = OpenUILibraryOptions & {
+    /** If set, only these component names are kept (allowlist). */
+    allow?: readonly string[];
+    /** Component names to remove (applied after allow). */
+    deny?: readonly string[];
+};
+/**
+ * Thin wrapper over OpenUI's createLibrary that validates names and
+ * supports allow/deny lists. Create the library once at module scope so its
+ * reference stays stable.
+ */
+declare function createJuneLibrary(options: JuneLibraryOptions): ReturnType<typeof createLibrary>;
+
+interface JuneContextValue {
+    mode: JuneThemeMode;
+    theme: JuneResolvedTheme;
+}
+/** `{ mode, theme }` of the nearest June root; `theme` is the resolved "light" or "dark". */
+declare function useJuneTheme(): JuneContextValue;
+
+interface JuneRuntimeValue {
+    /** True while the response is still streaming. Custom components use it to defer heavy work. */
+    isStreaming: boolean;
+}
+declare const JuneRuntimeContext: react.Context<JuneRuntimeValue>;
+/** Runtime state of the surrounding June renderer (for custom components). */
+declare function useJuneRuntime(): JuneRuntimeValue;
+
+/** Resolves "system" to the OS preference and follows its changes. */
+declare function useResolvedTheme(mode: JuneThemeMode): JuneResolvedTheme;
+interface JuneThemeProviderProps {
+    /**
+     * Omit to inherit the host app's look: no colors, fonts or color-scheme are applied.
+     * "light" | "dark" | "system" opt in to June's text colors.
+     */
+    mode?: JuneThemeMode;
+    /**
+     * CSS variable overrides: one map for both modes ({ "--june-accent": "#0ea5e9" }),
+     * or one per mode ({ light: {...}, dark: {...} }).
+     */
+    vars?: JuneThemeInput;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+/** The `.june-ui-root` element: applies theme variables and provides `useJuneTheme()`. */
+declare function JuneThemeProvider({ mode, vars, className, style, children }: JuneThemeProviderProps): react.JSX.Element;
+
+/** Colors only. June never sets fonts, radii or backgrounds. */
+declare const lightTheme: JuneThemeVars;
+
+declare const darkTheme: JuneThemeVars;
+
+/** True when `input` is `{ light?, dark? }` rather than a flat variable map. */
+declare function isThemeSet(input: JuneThemeInput | undefined): input is JuneThemeSet;
+/** The variables for one resolved mode. */
+declare function resolveThemeVars(input: JuneThemeInput | undefined, mode: JuneResolvedTheme): JuneThemeVars | undefined;
+/**
+ * Builds a full theme from June's palettes plus your overrides. Pass the result as `themeVars`.
+ *
+ * ```ts
+ * const brand = createTheme({ light: { "--june-accent": "#0ea5e9" }, dark: { "--june-accent": "#38bdf8" } });
+ * <JuneUI theme="system" themeVars={brand} ... />
+ * ```
+ */
+declare function createTheme(overrides?: JuneThemeSet): Required<JuneThemeSet>;
+
+type StreamStatus = "idle" | "streaming" | "done" | "error" | "aborted";
+type StreamChunk = string | Uint8Array;
+type StreamSource = ReadableStream<Uint8Array> | ReadableStream<string> | AsyncIterable<StreamChunk>;
+interface ConsumeStreamOptions {
+    signal?: AbortSignal;
+    /** Called per decoded chunk with the new text and the full text so far. */
+    onText?: (delta: string, accumulated: string) => void;
+    /** Resolve with "" instead of throwing STREAM_EMPTY. */
+    allowEmpty?: boolean;
+}
+interface SseOptions {
+    /** Map an SSE frame to text. Return null/"" to skip. Default: the raw data. */
+    extract?: (data: string, event: string) => string | null | undefined;
+    /** Frame data that ends the stream. Default "[DONE]". Use null to disable. */
+    doneSentinel?: string | null;
+}
+type FetchStreamOptions = RequestInit & {
+    sse?: boolean | SseOptions;
+};
+interface JuneStreamState {
+    response: string;
+    isStreaming: boolean;
+    status: StreamStatus;
+    error: JuneError | null;
+}
+
+type StreamStarter = StreamSource | ((signal: AbortSignal) => StreamSource | Promise<StreamSource>);
+interface UseJuneStreamOptions {
+    allowEmpty?: boolean;
+    onError?: (error: JuneError) => void;
+    onComplete?: (text: string) => void;
+}
+interface UseJuneStreamResult extends JuneStreamState {
+    start: (source: StreamStarter) => Promise<string | null>;
+    startFetch: (input: RequestInfo | URL, options?: FetchStreamOptions) => Promise<string | null>;
+    abort: () => void;
+    reset: () => void;
+}
+/**
+ * Accumulates a stream into `response`, with state updates coalesced to
+ * roughly one per frame, abort support, and cleanup on unmount.
+ * Starting a new stream cancels the previous one.
+ */
+declare function useJuneStream(options?: UseJuneStreamOptions): UseJuneStreamResult;
+
+declare function toAsyncIterable(source: StreamSource, signal?: AbortSignal): AsyncIterable<StreamChunk>;
+/**
+ * Reads a stream to completion, decoding bytes safely (multi-byte characters
+ * split across chunks are handled) and accumulating text. Does not parse
+ * OpenUI Lang; parsing stays with OpenUI's Renderer.
+ */
+declare function consumeStream(source: StreamSource, options?: ConsumeStreamOptions): Promise<string>;
+
+/** fetch() wrapper that returns a StreamSource, with structured errors. */
+declare function fetchStream(input: RequestInfo | URL, options?: FetchStreamOptions): Promise<StreamSource>;
+
+/** Converts a Server-Sent Events byte/text stream into an async iterable of text. */
+declare function sseToText(source: StreamSource, options?: SseOptions & {
+    signal?: AbortSignal;
+}): AsyncGenerator<string, void, undefined>;
+/**
+ * Builds an `extract` function that reads a string at a dotted JSON path,
+ * e.g. jsonFieldExtractor("choices.0.delta.content").
+ */
+declare function jsonFieldExtractor(path: string): (data: string) => string | null;
+
+declare const DOCUMENT_COMPONENT_DESCRIPTION = "Custom component. An editable document. DocumentEditor(documentId, title, content, documentType?, status?, editable?, exportFormats?). Place it in the root container (Card or Stack). \"content\" is the full document body as one Markdown string. Reuse documentId when revising the same document. Use it only when the user asks to create or revise a document.";
+/** Standalone editor. While a June response is still streaming, shows a placeholder instead of mounting Tiptap. */
+declare function DocumentEditor(props: DocumentEditorProps): react.JSX.Element;
+declare const JuneDocumentEditorComponent: _openuidev_react_lang.DefinedComponent<z.ZodObject<{
+    documentId: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+    documentType: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    editable: z.ZodOptional<z.ZodBoolean>;
+    exportFormats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+type Extendable = Library & {
+    extend: NonNullable<Library["extend"]>;
+};
+/**
+ * Returns a library that contains every component of `library` plus DocumentEditor.
+ * On Zod 4.1+ it also joins Card's children. Zod 3.25 (what the app bundles) has no
+ * `util.mergeDefs`, and OpenUI's slot clone calls that, so the slot step is skipped
+ * there. The component is still registered and can be rendered.
+ */
+declare function withDocumentEditor(library: Extendable): Required<_openuidev_lang_core.Library<_openuidev_react_lang.ComponentRenderer<any>, _openuidev_lang_core.DefinedAction<any, string>>>;
+
+declare const JuneDocumentContext: react.Context<JuneDocumentOptions>;
+declare function useDocumentOptions(): JuneDocumentOptions;
+
+/** Provides document options (and edit write-back) to every DocumentEditor below it. */
+declare function DocumentBridge({ children, ...options }: DocumentBridgeOptions & {
+    children?: ReactNode;
+}): react.JSX.Element;
+
+/**
+ * Rewrites the arguments of a `DocumentEditor(documentId, title, content, ...)` call inside an
+ * OpenUI Lang program, leaving every other character of the program untouched.
+ */
+interface DocumentProgramUpdate {
+    title?: string;
+    /** New document body (Markdown or a Tiptap JSON string). */
+    content?: string;
+}
+/**
+ * Finds the DocumentEditor call whose first argument equals `documentId` and replaces its title
+ * and/or content. Returns the new program, or null when no matching call was found.
+ */
+declare function updateDocumentInProgram(program: string, documentId: string, update: DocumentProgramUpdate, componentName?: string): string | null;
+/** Reads the current title and content of a DocumentEditor call, or null. */
+declare function readDocumentFromProgram(program: string, documentId: string, componentName?: string): {
+    title: string;
+    content: string;
+} | null;
+
+declare function mergeDocuments(base: DocJSON, local: DocJSON, incoming: DocJSON): {
+    doc: DocJSON;
+    conflicts: number;
+};
+
+interface ExportContext {
+    documentId: string;
+    title: string;
+    json: DocJSON;
+    /** File name without extension. */
+    basename: string;
+}
+interface ExportResult {
+    filename: string;
+    mimeType: string;
+    blob?: Blob;
+    text?: string;
+    /** True when the exporter delivered the file itself, for example the print dialog for PDF. */
+    handled?: boolean;
+}
+type DocumentExporter = (context: ExportContext) => ExportResult | Promise<ExportResult>;
+/** Adds or replaces an export format. */
+declare function registerDocumentExporter(format: string, exporter: DocumentExporter): void;
+declare function listDocumentExporters(): string[];
+declare function exportDocument(format: string, doc: {
+    documentId: string;
+    title: string;
+    json: DocJSON;
+}): Promise<ExportResult>;
+/** Starts a browser download for results that carry a Blob. */
+declare function downloadResult(result: ExportResult): void;
+/** Copies rich text and plain text. Returns false if the browser refuses. */
+declare function copyDocumentToClipboard(doc: {
+    title: string;
+    json: DocJSON;
+}): Promise<boolean>;
+
+interface DocumentInstructionOptions {
+    /** Examples of document types for your product. Default covers common business documents. */
+    documentTypes?: string[];
+    /** Extra rules appended after the built-in ones (tone, legal disclaimers, language, ...). */
+    extraRules?: string[];
+    /** Name of the component in your library. Default "DocumentEditor". */
+    componentName?: string;
+}
+/** Rules for the model. Pass them through your backend to any agent. */
+declare function getDocumentEditorRules(options?: DocumentInstructionOptions): string[];
+/** Text block you can paste into any agent's system prompt. */
+declare function getDocumentEditorInstructions(options?: DocumentInstructionOptions): string;
+/**
+ * Options for OpenUI's `library.prompt(options)`. Merge these with your own PromptOptions.
+ * Example: library.prompt({ ...documentPromptOptions(), preamble: "..." })
+ */
+declare function documentPromptOptions(options?: DocumentInstructionOptions): {
+    additionalRules: string[];
+    examples: string[];
+};
+
+/**
+ * Serialises the documents the user currently has (including their edits) as Markdown,
+ * ready to attach to the next message so the agent can edit the right text.
+ */
+declare function serializeDocumentsForAgent(options?: {
+    store?: DocumentStore;
+    ids?: string[];
+}): Promise<string>;
+
+type ApprovalChoice = "approve" | "reject" | "edit";
+type ToolApprovalStatus = "pending" | "approved" | "rejected" | "running" | "completed" | "failed";
+/** A tool call waiting for the user's decision. */
+interface ToolApprovalRequest {
+    /** Unique id. `useToolApproval().request` creates one when omitted. */
+    id: string;
+    /** Tool or action name, e.g. "send_email". */
+    tool: string;
+    /** What the call will do, in words the user understands. */
+    description?: string;
+    /** The arguments the agent wants to call the tool with. */
+    arguments?: unknown;
+    risk?: "low" | "medium" | "high";
+    /** What kind of change the tool makes. */
+    sideEffect?: "read" | "write" | "destructive";
+    /** Choices offered. Default ["approve", "reject"]. Add "edit" to let the user change the arguments. */
+    options?: readonly ApprovalChoice[];
+    /** Free-form data for custom approval UIs. */
+    metadata?: Readonly<Record<string, unknown>>;
+}
+interface ToolApprovalDecision {
+    choice: ApprovalChoice;
+    /** Parsed JSON the user entered, when `choice` is "edit". */
+    editedArguments?: unknown;
+}
+interface ToolApprovalEntry {
+    request: ToolApprovalRequest;
+    status: ToolApprovalStatus;
+    decision?: ToolApprovalDecision;
+    /** Error text when `status` is "failed". */
+    error?: string;
+}
+
+interface ToolApprovalLabels {
+    approve: string;
+    reject: string;
+    edit: string;
+    save: string;
+    cancel: string;
+    invalidJson: string;
+    status: Record<Exclude<ToolApprovalStatus, "pending">, string>;
+    sideEffect: Record<NonNullable<ToolApprovalRequest["sideEffect"]>, string>;
+    risk: (risk: NonNullable<ToolApprovalRequest["risk"]>) => string;
+}
+declare const defaultToolApprovalLabels: ToolApprovalLabels;
+interface ToolApprovalProps {
+    request: ToolApprovalRequest;
+    /** Default "pending": shows the choices. Any other status shows a status line instead. */
+    status?: ToolApprovalStatus;
+    onDecide?: (decision: ToolApprovalDecision) => void;
+    /** Disables the buttons (for example while another decision is being sent). */
+    disabled?: boolean;
+    /** Error text shown when status is "failed". */
+    error?: string;
+    labels?: Partial<ToolApprovalLabels>;
+    /** Custom drawing of the arguments. Default: formatted JSON. */
+    renderArguments?: (args: unknown) => ReactNode;
+    className?: string;
+}
+/**
+ * Asks the user to approve, reject or edit a tool call. Styled only through `june-approval*`
+ * classes and June theme variables: restyle with CSS, or build your own UI on `useToolApproval`.
+ */
+declare function ToolApproval({ request, status, onDecide, disabled, error, labels: labelOverrides, renderArguments, className, }: ToolApprovalProps): react.JSX.Element;
+
+type ToolApprovalInput = Omit<ToolApprovalRequest, "id"> & {
+    id?: string;
+};
+interface UseToolApprovalResult {
+    /** Every request seen, oldest first, with its status. */
+    entries: ToolApprovalEntry[];
+    /** Only the requests still waiting for a decision. */
+    pending: ToolApprovalEntry[];
+    /** Shows a request and resolves with the user's decision. */
+    request: (input: ToolApprovalInput) => Promise<ToolApprovalDecision>;
+    /** Records a decision (call from your UI; `ToolApprovalList` does this for you). */
+    decide: (id: string, decision: ToolApprovalDecision) => void;
+    /** Updates the status after the decision, e.g. "running", then "completed" or "failed". */
+    setStatus: (id: string, status: ToolApprovalStatus, error?: string) => void;
+    /** Removes one entry, or all when no id is given. Pending ones resolve as rejected. */
+    dismiss: (id?: string) => void;
+    /**
+     * Plug into `<JuneUI confirmAction={...}>`: sensitive June actions then ask through this UI.
+     * Resolves true on approve (or edit), false on reject.
+     */
+    confirmAction: ConfirmAction;
+}
+/**
+ * State for human-in-the-loop tool approval. Render `entries` with `<ToolApproval>` (or
+ * `<ToolApprovalList approvals={...}>`), and `await request(...)` wherever a decision is needed.
+ * Requests still pending on unmount resolve as rejected.
+ */
+declare function useToolApproval(): UseToolApprovalResult;
+
+interface ToolApprovalListProps {
+    approvals: Pick<UseToolApprovalResult, "entries" | "decide">;
+    /** Show only pending requests (default false: decided ones stay, with their status). */
+    pendingOnly?: boolean;
+    /** Replace the default card. */
+    renderItem?: (entry: ToolApprovalEntry, decide: UseToolApprovalResult["decide"]) => ReactNode;
+    labels?: ToolApprovalProps["labels"];
+    className?: string;
+}
+/** Renders every request from `useToolApproval()` and wires its buttons. */
+declare function ToolApprovalList({ approvals, pendingOnly, renderItem, labels, className }: ToolApprovalListProps): react.JSX.Element | null;
+
+/**
+ * LangGraph adapter: turns a LangGraph run stream (SSE from the LangGraph server API, e.g.
+ * `POST /threads/{thread_id}/runs/stream`) into the plain text June renders.
+ *
+ * Supported stream modes:
+ * - `messages-tuple`: `event: messages`, data `[messageChunk, metadata]`; each chunk is a delta.
+ * - `messages`: `event: messages/partial`, data `[message, ...]`; each message is the full text so
+ *   far, so only the new part is emitted.
+ * Subgraph events (`messages|<namespace>`) are handled the same way. Other events are skipped.
+ *
+ * Pure functions, no React, no network: pair them with `fetchStream` / `useJuneStream`.
+ */
+
+interface LangGraphExtractorOptions {
+    /** Only keep messages produced by these graph nodes (`metadata.langgraph_node`). Default: all. */
+    nodes?: readonly string[];
+}
+/** Text of a LangChain message `content`: a string, or the `text` of its text blocks. */
+declare function messageContentToText(content: unknown): string;
+/**
+ * Creates an `extract` function for `sseToText` / `fetchStream({ sse: { extract } })`.
+ * Stateful (it remembers how much of each partial message was emitted): create one per stream.
+ */
+declare function createLangGraphExtractor(options?: LangGraphExtractorOptions): (data: string, event: string) => string | null;
+/**
+ * Options to spread into `startFetch` / `fetchStream` for a LangGraph run stream.
+ * Call it for every run: the extractor inside is stateful.
+ *
+ * ```ts
+ * stream.startFetch(`${api}/threads/${threadId}/runs/stream`, {
+ *   method: "POST",
+ *   headers: { "Content-Type": "application/json" },
+ *   body: JSON.stringify({ assistant_id: "agent", input, stream_mode: ["messages-tuple"] }),
+ *   ...langGraphStreamOptions({ nodes: ["agent"] }),
+ * });
+ * ```
+ */
+declare function langGraphStreamOptions(options?: LangGraphExtractorOptions): {
+    sse: SseOptions;
+};
+/**
+ * Reads interrupt values from a LangGraph `updates` event (data `{ "__interrupt__": [{ value }] }`).
+ * Returns [] for anything else. Use it in your own SSE handling to drive human-in-the-loop UI.
+ */
+declare function readLangGraphInterrupts(data: string, event?: string): unknown[];
+/**
+ * Best-effort mapping of an interrupt value to approval requests. Understands the
+ * `{ action_requests: [{ name, args, description }], review_configs: [{ action_name, allowed_decisions }] }`
+ * shape used by LangChain's human-in-the-loop middleware. For your own interrupt payloads, build
+ * `ToolApprovalRequest`s yourself. Returns [] when the value does not match.
+ */
+declare function interruptToApprovalRequests(value: unknown, idPrefix?: string): ToolApprovalRequest[];
+
+export { ALL_EXPORT_FORMATS, type ActionEventParser, type ActionOutcome, type AnyComponentDefinition, type ApprovalChoice, type ComponentProps, ComponentRegistry, type ComponentRegistryOptions, type ConfirmAction, type ConsumeStreamOptions, DOCUMENT_COMPONENT_DESCRIPTION, type DefineComponentOptions, type DocJSON, type DocNode, DocumentBridge, type DocumentBridgeOptions, type DocumentChange, type DocumentConflict, DocumentEditor, type DocumentEditorProps, type DocumentExportEvent, type DocumentExportFormat, type DocumentExporter, type DocumentInstructionOptions, type DocumentProgramUpdate, type DocumentRecord, type DocumentSavePayload, type DocumentSnapshot, type DocumentStore, type ExportContext, type ExportResult, type FallbackArgs, type FetchStreamOptions, type IncomingDocument, type JuneAction, type JuneActionContext, type JuneActionDefinition, type JuneActionMap, type JuneComponent, type JuneComponentMeta, type JuneContextValue, JuneDocumentContext, JuneDocumentEditorComponent, type JuneDocumentOptions, JuneError, JuneErrorBoundary, type JuneErrorBoundaryProps, type JuneErrorCode, type JuneErrorOptions, type JuneLibraryOptions, type JuneRenderProps, JuneRenderer, type JuneRendererProps, type JuneResolvedTheme, JuneRuntimeContext, type JuneRuntimeValue, type JuneStreamState, type JuneThemeInput, type JuneThemeMode, JuneThemeProvider, type JuneThemeProviderProps, type JuneThemeSet, type JuneThemeToken, type JuneThemeVars, type LangGraphExtractorOptions, MarkdownText, type MarkdownTextProps, type MixedContent, type MixedContentOptions, type OpenUIActionEvent, type OpenUILibrary, type OpenUIRendererProps, type ParsedActionEvent, type PendingUpdate, type ReceiveOutcome, type RegisterOptions, type ResolveChoice, type ResponseChangeInfo, type RunActionOptions, type SchemaLike, type SplitOptions, type SplitResponse, type SseOptions, type StreamChunk, type StreamSource, type StreamStarter, type StreamStatus, type TextFormat, ToolApproval, type ToolApprovalDecision, type ToolApprovalEntry, type ToolApprovalInput, type ToolApprovalLabels, ToolApprovalList, type ToolApprovalListProps, type ToolApprovalProps, type ToolApprovalRequest, type ToolApprovalStatus, type UseJuneStreamOptions, type UseJuneStreamResult, type UseToolApprovalResult, consumeStream, copyDocumentToClipboard, createActionHandler, createComponentRegistry, createDocumentStore, createJuneLibrary, createLangGraphExtractor, createTheme, darkTheme, defaultParseActionEvent, defaultToolApprovalLabels, defineComponent, defineJuneAction, defineJuneComponent, documentPromptOptions, downloadResult, exportDocument, fetchStream, getDefaultDocumentStore, getDocumentEditorInstructions, getDocumentEditorRules, interruptToApprovalRequests, isDocumentEcho, isJuneComponent, isJuneError, isThemeSet, jsonFieldExtractor, langGraphStreamOptions, lightTheme, listDocumentExporters, mergeDocuments, messageContentToText, normalizeProgram, readDocumentFromProgram, readLangGraphInterrupts, registerDocumentExporter, rememberDocumentEcho, resolveMixedContent, resolveThemeVars, runAction, serializeDocumentsForAgent, splitResponse, sseToText, toAsyncIterable, toJuneError, updateDocumentInProgram, useDocumentBridge, useDocumentOptions, useJuneRuntime, useJuneStream, useJuneTheme, useRegistryLibrary, useResolvedTheme, useToolApproval, validateComponentDefinition, withDocumentEditor };