@june-ai/june-ui 0.0.0-stage → 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,256 @@
+import * as react from 'react';
+import { ComponentProps, Component, ReactNode, ErrorInfo, CSSProperties } from 'react';
+import { Renderer, createLibrary, defineComponent } from '@openuidev/react-lang';
+
+type JuneErrorCode = "PARSE_ERROR" | "RENDER_ERROR" | "STREAM_ERROR" | "STREAM_ABORTED" | "STREAM_EMPTY" | "NETWORK_ERROR" | "ACTION_ERROR" | "ACTION_VALIDATION_ERROR" | "ACTION_REJECTED" | "LIBRARY_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.
+ */
+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;
+
+type JuneThemeVars = Record<string, string>;
+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;
+    /**
+     * Render prose around OpenUI statements (default true). The response may be
+     * plain OpenUI Lang, or prose + OpenUI Lang, optionally inside ``` fences.
+     * Set false to hand the response to OpenUI untouched.
+     */
+    mixedContent?: boolean;
+    /** Custom renderer for prose segments. Default: <p className="june-text">. */
+    renderText?: (text: string, index: number) => ReactNode;
+    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, and action failures. */
+    onJuneError?: (error: JuneError) => void;
+    loadingFallback?: ReactNode;
+    emptyFallback?: ReactNode;
+    errorFallback?: ReactNode | ((args: FallbackArgs) => ReactNode);
+    resetKeys?: readonly unknown[];
+};
+declare function JuneRenderer(props: JuneRendererProps): react.JSX.Element;
+
+declare function useResolvedTheme(mode: JuneThemeMode): JuneResolvedTheme;
+interface JuneThemeProviderProps {
+    mode?: JuneThemeMode;
+    /** CSS variable overrides, e.g. { "--june-accent": "#0ea5e9" }. */
+    vars?: JuneThemeVars;
+    className?: string;
+    style?: CSSProperties;
+    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;
+
+/** 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.
+ */
+declare function useJuneStream(options?: UseJuneStreamOptions): UseJuneStreamResult;
+
+/**
+ * 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;
+
+type JuneUIProps = Omit<JuneRendererProps, "library"> & {
+    /** Defaults to OpenUI's built-in library (same behaviour as 0.1.0). */
+    library?: OpenUILibrary;
+};
+declare function JuneUI({ library, ...props }: JuneUIProps): react.JSX.Element;
+
+export { type ActionEventParser, type ActionOutcome, type ConfirmAction, type ConsumeStreamOptions, type FallbackArgs, type FetchStreamOptions, type JuneAction, type JuneActionContext, type JuneActionDefinition, type JuneActionMap, JuneError, JuneErrorBoundary, type JuneErrorBoundaryProps, type JuneErrorCode, type JuneErrorOptions, type JuneLibraryOptions, JuneRenderer, type JuneRendererProps, type JuneResolvedTheme, type JuneStreamState, type JuneThemeMode, JuneThemeProvider, type JuneThemeProviderProps, type JuneThemeVars, JuneUI, type JuneUIProps, type OpenUIActionEvent, type OpenUILibrary, type OpenUIRendererProps, type ParsedActionEvent, type RunActionOptions, type SchemaLike, type SseOptions, type StreamChunk, type StreamSource, type StreamStarter, type StreamStatus, type UseJuneStreamOptions, type UseJuneStreamResult, consumeStream, createActionHandler, createJuneLibrary, darkTheme, defaultParseActionEvent, defineJuneAction, defineJuneComponent, fetchStream, isJuneError, jsonFieldExtractor, lightTheme, runAction, sseToText, toJuneError, useJuneStream, useJuneTheme, useResolvedTheme };

package/dist/index.d.ts

@@ -0,0 +1,256 @@
+import * as react from 'react';
+import { ComponentProps, Component, ReactNode, ErrorInfo, CSSProperties } from 'react';
+import { Renderer, createLibrary, defineComponent } from '@openuidev/react-lang';
+
+type JuneErrorCode = "PARSE_ERROR" | "RENDER_ERROR" | "STREAM_ERROR" | "STREAM_ABORTED" | "STREAM_EMPTY" | "NETWORK_ERROR" | "ACTION_ERROR" | "ACTION_VALIDATION_ERROR" | "ACTION_REJECTED" | "LIBRARY_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.
+ */
+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;
+
+type JuneThemeVars = Record<string, string>;
+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;
+    /**
+     * Render prose around OpenUI statements (default true). The response may be
+     * plain OpenUI Lang, or prose + OpenUI Lang, optionally inside ``` fences.
+     * Set false to hand the response to OpenUI untouched.
+     */
+    mixedContent?: boolean;
+    /** Custom renderer for prose segments. Default: <p className="june-text">. */
+    renderText?: (text: string, index: number) => ReactNode;
+    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, and action failures. */
+    onJuneError?: (error: JuneError) => void;
+    loadingFallback?: ReactNode;
+    emptyFallback?: ReactNode;
+    errorFallback?: ReactNode | ((args: FallbackArgs) => ReactNode);
+    resetKeys?: readonly unknown[];
+};
+declare function JuneRenderer(props: JuneRendererProps): react.JSX.Element;
+
+declare function useResolvedTheme(mode: JuneThemeMode): JuneResolvedTheme;
+interface JuneThemeProviderProps {
+    mode?: JuneThemeMode;
+    /** CSS variable overrides, e.g. { "--june-accent": "#0ea5e9" }. */
+    vars?: JuneThemeVars;
+    className?: string;
+    style?: CSSProperties;
+    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;
+
+/** 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.
+ */
+declare function useJuneStream(options?: UseJuneStreamOptions): UseJuneStreamResult;
+
+/**
+ * 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;
+
+type JuneUIProps = Omit<JuneRendererProps, "library"> & {
+    /** Defaults to OpenUI's built-in library (same behaviour as 0.1.0). */
+    library?: OpenUILibrary;
+};
+declare function JuneUI({ library, ...props }: JuneUIProps): react.JSX.Element;
+
+export { type ActionEventParser, type ActionOutcome, type ConfirmAction, type ConsumeStreamOptions, type FallbackArgs, type FetchStreamOptions, type JuneAction, type JuneActionContext, type JuneActionDefinition, type JuneActionMap, JuneError, JuneErrorBoundary, type JuneErrorBoundaryProps, type JuneErrorCode, type JuneErrorOptions, type JuneLibraryOptions, JuneRenderer, type JuneRendererProps, type JuneResolvedTheme, type JuneStreamState, type JuneThemeMode, JuneThemeProvider, type JuneThemeProviderProps, type JuneThemeVars, JuneUI, type JuneUIProps, type OpenUIActionEvent, type OpenUILibrary, type OpenUIRendererProps, type ParsedActionEvent, type RunActionOptions, type SchemaLike, type SseOptions, type StreamChunk, type StreamSource, type StreamStarter, type StreamStatus, type UseJuneStreamOptions, type UseJuneStreamResult, consumeStream, createActionHandler, createJuneLibrary, darkTheme, defaultParseActionEvent, defineJuneAction, defineJuneComponent, fetchStream, isJuneError, jsonFieldExtractor, lightTheme, runAction, sseToText, toJuneError, useJuneStream, useJuneTheme, useResolvedTheme };