@june-ai/june-ui 0.2.7 → 0.2.9

package/dist/index.d.ts

@@ -1,548 +1,103 @@
+import { JuneRendererProps, AnyComponentDefinition, OpenUILibrary, ComponentRegistry, RegisterOptions } from './entry-core.js';
+export { ALL_EXPORT_FORMATS, ActionEventParser, ActionOutcome, ApprovalChoice, ComponentProps, ComponentRegistryOptions, ConfirmAction, ConsumeStreamOptions, DOCUMENT_COMPONENT_DESCRIPTION, DefineComponentOptions, DocJSON, DocNode, DocumentBridge, DocumentBridgeOptions, DocumentChange, DocumentConflict, DocumentEditor, DocumentEditorProps, DocumentExportEvent, DocumentExportFormat, DocumentExporter, DocumentInstructionOptions, DocumentProgramUpdate, DocumentRecord, DocumentSavePayload, DocumentSnapshot, DocumentStore, ExportContext, ExportResult, FallbackArgs, FetchStreamOptions, IncomingDocument, JuneAction, JuneActionContext, JuneActionDefinition, JuneActionMap, JuneComponent, JuneComponentMeta, JuneContextValue, JuneDocumentContext, JuneDocumentEditorComponent, JuneDocumentOptions, JuneError, JuneErrorBoundary, JuneErrorBoundaryProps, JuneErrorCode, JuneErrorOptions, JuneLibraryOptions, JuneRenderProps, JuneRenderer, JuneResolvedTheme, JuneRuntimeContext, JuneRuntimeValue, JuneStreamState, JuneThemeInput, JuneThemeMode, JuneThemeProvider, JuneThemeProviderProps, JuneThemeSet, JuneThemeToken, JuneThemeVars, LangGraphExtractorOptions, MarkdownText, MarkdownTextProps, MixedContent, MixedContentOptions, OpenUIActionEvent, OpenUIRendererProps, ParsedActionEvent, PendingUpdate, ReceiveOutcome, ResolveChoice, ResponseChangeInfo, RunActionOptions, SchemaLike, SplitOptions, SplitResponse, SseOptions, StreamChunk, StreamSource, StreamStarter, StreamStatus, TextFormat, ToolApproval, ToolApprovalDecision, ToolApprovalEntry, ToolApprovalInput, ToolApprovalLabels, ToolApprovalList, ToolApprovalListProps, ToolApprovalProps, ToolApprovalRequest, ToolApprovalStatus, UseJuneStreamOptions, UseJuneStreamResult, 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 } from './entry-core.js';
 import * as react from 'react';
-import { ComponentProps, Component, ReactNode, ErrorInfo, CSSProperties } from 'react';
-import * as _openuidev_react_lang from '@openuidev/react-lang';
-import { Renderer, createLibrary, defineComponent, Library } from '@openuidev/react-lang';
-import * as _openuidev_lang_core from '@openuidev/lang-core';
-import { z } from 'zod/v4';
+import { ReactNode } from 'react';
+import { PromptOptions } from '@openuidev/react-lang';
+import 'zod/v4';
+import 'zod/v4/core';
+import '@openuidev/lang-core';
 
-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;
-
-/** Props of OpenUI's real Renderer. Derived, never hand-copied. */
-type OpenUIRendererProps = ComponentProps<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 JuneThemeMode = "light" | "dark" | "system";
-type JuneResolvedTheme = "light" | "dark";
-
-/** 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.
+ * Props that can be set once (on a `createJuneUI` instance or a `JuneUIProvider`) instead of on
+ * every `<JuneUI>`. Props passed to `<JuneUI>` itself always win.
  */
-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 JuneUIDefaults = Partial<Pick<JuneRendererProps, "mixedContent" | "textFormat" | "renderText" | "repair" | "theme" | "themeVars" | "className" | "actions" | "confirmAction" | "parseActionEvent" | "onAction" | "onJuneError" | "documents" | "loadingFallback" | "emptyFallback" | "errorFallback" | "toolProvider">>;
+
+interface CreateJuneUIOptions {
+    /** Your components, made with `defineComponent`. Names must be new. */
+    components?: readonly AnyComponentDefinition[];
+    /** Components that replace built-ins with the same name. */
+    overrides?: readonly AnyComponentDefinition[];
+    /** Built-in component names to remove. */
+    remove?: readonly string[];
+    /** Library to start from. Default: June's library (OpenUI components + DocumentEditor). */
+    baseLibrary?: OpenUILibrary;
+    /** Default props for every `<JuneUI>` that uses this instance. */
+    defaults?: JuneUIDefaults;
+}
+/** An isolated June setup: its own component registry and default props. */
+interface JuneUIInstance {
+    readonly registry: ComponentRegistry;
+    /** The OpenUI library for the current components (stable until they change). */
+    readonly library: OpenUILibrary;
+    readonly defaults: JuneUIDefaults;
+    /** Adds components at runtime. Mounted `<JuneUI>`s re-render. */
+    register(components: AnyComponentDefinition | readonly AnyComponentDefinition[], options?: RegisterOptions): JuneUIInstance;
+    /** The model's system prompt for these components. Generate it on the server and send it to the model. */
+    prompt(options?: PromptOptions): 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.
+ * Creates a June instance. Call it once, at module scope.
+ *
+ * ```tsx
+ * const june = createJuneUI({ components: [CustomCard] });
+ * <JuneUI june={june} response={response} isStreaming={isStreaming} />
+ * ```
  */
-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;
-}
+declare function createJuneUI(options?: CreateJuneUIOptions): JuneUIInstance;
 
-type JuneThemeVars = Record<string, string>;
-/** Colors only. June never sets fonts, radii or backgrounds. */
-declare const lightTheme: JuneThemeVars;
-
-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;
-}
-
-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;
-    /** Custom renderer for prose segments. Default: <p className="june-text">. */
-    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;
-    themeVars?: JuneThemeVars;
-    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;
+type JuneUIProps = Omit<JuneRendererProps, "library"> & {
     /**
-     * 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.
+     * Component library. Takes precedence over `june`. Default: the `june` instance, then the
+     * nearest `JuneUIProvider`, then June's default registry (OpenUI components + DocumentEditor
+     * + anything added with `registerComponent`).
      */
-    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[];
+    library?: OpenUILibrary;
+    /** Instance from `createJuneUI`: its components and default props. */
+    june?: JuneUIInstance;
 };
-interface ResponseChangeInfo {
-    documentId: string;
-    title: string;
-    /** The document body written into the program, as Markdown. */
-    markdown: string;
-    source: DocumentChange["source"];
-}
-declare function JuneRenderer(props: JuneRendererProps): 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 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, e.g. { "--june-accent": "#0ea5e9" }. */
-    vars?: JuneThemeVars;
-    className?: string;
-    style?: CSSProperties;
+/** Renders a model response (Markdown/prose and OpenUI Lang) with June's component library. */
+declare function JuneUI({ library, june, ...props }: JuneUIProps): react.JSX.Element;
+
+interface JuneUIContextValue {
+    june?: JuneUIInstance;
+    defaults?: JuneUIDefaults;
+}
+interface JuneUIProviderProps {
+    /** Instance from `createJuneUI`. Every `<JuneUI>` below uses its components and defaults. */
+    june?: JuneUIInstance;
+    /** Extra default props, applied over the instance's defaults. Memoize this object. */
+    defaults?: JuneUIDefaults;
     children?: ReactNode;
 }
-declare function JuneThemeProvider({ mode, vars, className, style, children, }: JuneThemeProviderProps): react.JSX.Element;
-
-declare const darkTheme: JuneThemeVars;
-
-interface JuneContextValue {
-    mode: JuneThemeMode;
-    theme: JuneResolvedTheme;
-}
-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>;
-declare function useJuneRuntime(): JuneRuntimeValue;
-
-/** Re-export of OpenUI's component definer under a June name. */
-declare const defineJuneComponent: typeof defineComponent;
-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>;
-
-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.
+ * Shares one June setup with every `<JuneUI>` below it — useful for a chat that renders a
+ * `<JuneUI>` per message. Props passed to a `<JuneUI>` still win.
  */
-declare function useJuneStream(options?: UseJuneStreamOptions): UseJuneStreamResult;
+declare function JuneUIProvider({ june, defaults, children }: JuneUIProviderProps): react.JSX.Element;
+/** The nearest `JuneUIProvider`'s value, or null. */
+declare function useJuneUIContext(): JuneUIContextValue | null;
 
 /**
- * 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.
+ * June's default library: the OpenUI chat library, plus Stack, Modal and DocumentEditor.
+ * Root is Card, matching the chat language. Created once so its reference stays stable.
  */
-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>;
+declare const juneLibrary: OpenUILibrary;
 /**
- * Builds an `extract` function that reads a string at a dotted JSON path,
- * e.g. jsonFieldExtractor("choices.0.delta.content").
+ * The registry `<JuneUI>` renders with when it gets no `library` or `june` instance.
+ * `registerComponent` adds to it, so registered components appear in every default `<JuneUI>`.
  */
-declare function jsonFieldExtractor(path: string): (data: string) => string | null;
-
-/** 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;
-
-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 JuneUIProps = Omit<JuneRendererProps, "library"> & {
-    /** Defaults to June's library: OpenUI's components plus DocumentEditor. */
-    library?: OpenUILibrary;
-};
-declare function JuneUI({ library, ...props }: JuneUIProps): react.JSX.Element;
-
+declare const defaultRegistry: ComponentRegistry;
 /**
- * June's default library: every OpenUI component plus DocumentEditor.
- * Created once so its reference stays stable.
+ * Adds components to the default registry used by `<JuneUI>`. Call once at startup, at module scope.
+ * Throws `JuneError("LIBRARY_ERROR")` when a name is taken, unless `override` is true.
+ *
+ * For isolated setups (several libraries, tests, micro-frontends) prefer `createJuneUI`.
  */
-declare const juneLibrary: Required<_openuidev_lang_core.Library<_openuidev_react_lang.ComponentRenderer<any>, _openuidev_lang_core.DefinedAction<any, string>>>;
+declare function registerComponent(components: AnyComponentDefinition | readonly AnyComponentDefinition[], options?: {
+    override?: boolean;
+}): ComponentRegistry;
+/** Removes a component from the default registry (see `ComponentRegistry.unregister`). */
+declare function unregisterComponent(name: string): ComponentRegistry;
 
-export { ALL_EXPORT_FORMATS, type ActionEventParser, type ActionOutcome, type ConfirmAction, type ConsumeStreamOptions, type DocJSON, type DocNode, 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 JuneAction, type JuneActionContext, type JuneActionDefinition, type JuneActionMap, JuneDocumentContext, JuneDocumentEditorComponent, type JuneDocumentOptions, JuneError, JuneErrorBoundary, type JuneErrorBoundaryProps, type JuneErrorCode, type JuneErrorOptions, type JuneLibraryOptions, JuneRenderer, type JuneRendererProps, type JuneResolvedTheme, JuneRuntimeContext, type JuneStreamState, type JuneThemeMode, JuneThemeProvider, type JuneThemeProviderProps, type JuneThemeVars, JuneUI, type JuneUIProps, type OpenUIActionEvent, type OpenUILibrary, type OpenUIRendererProps, type ParsedActionEvent, type ResponseChangeInfo, type RunActionOptions, type SchemaLike, type SseOptions, type StreamChunk, type StreamSource, type StreamStarter, type StreamStatus, type UseJuneStreamOptions, type UseJuneStreamResult, consumeStream, copyDocumentToClipboard, createActionHandler, createDocumentStore, createJuneLibrary, darkTheme, defaultParseActionEvent, defineJuneAction, defineJuneComponent, documentPromptOptions, downloadResult, exportDocument, fetchStream, getDefaultDocumentStore, getDocumentEditorInstructions, getDocumentEditorRules, isDocumentEcho, isJuneError, jsonFieldExtractor, juneLibrary, lightTheme, listDocumentExporters, mergeDocuments, readDocumentFromProgram, registerDocumentExporter, rememberDocumentEcho, runAction, serializeDocumentsForAgent, sseToText, toJuneError, updateDocumentInProgram, useDocumentOptions, useJuneRuntime, useJuneStream, useJuneTheme, useResolvedTheme, withDocumentEditor };
+export { AnyComponentDefinition, ComponentRegistry, type CreateJuneUIOptions, JuneRendererProps, JuneUI, type JuneUIContextValue, type JuneUIDefaults, type JuneUIInstance, type JuneUIProps, JuneUIProvider, type JuneUIProviderProps, OpenUILibrary, RegisterOptions, createJuneUI, defaultRegistry, juneLibrary, registerComponent, unregisterComponent, useJuneUIContext };