@aintela/chat 0.2.15

package/dist/src/components/Library/LinearProgressBarWithMarkers.d.ts

@@ -0,0 +1,14 @@
+import { SxProps } from '@mui/material';
+interface Marker {
+    position: number;
+    label: string;
+    color: string;
+}
+export interface LinearProgressBarWithMarkersProps {
+    value: number;
+    valueBuffer: number;
+    markers: Marker[];
+    sx: SxProps;
+}
+declare function LinearProgressBarWithMarkers({ value, valueBuffer, markers, sx }: LinearProgressBarWithMarkersProps): import("react/jsx-runtime").JSX.Element;
+export default LinearProgressBarWithMarkers;

package/dist/src/components/Library/LoadingDots.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+interface LoadingDotsProps {
+    color?: string;
+    size?: number;
+    spacing?: number;
+}
+declare const LoadingDots: React.FC<LoadingDotsProps>;
+export default LoadingDots;

package/dist/src/components/Library/MarkdowmExtended.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+interface MarkdownExtendedProps {
+    text: string;
+    sessionId: string;
+    preStyle?: React.CSSProperties | null;
+    onDrawCodeBlock?: (code: string, className: string) => React.ReactNode;
+    onLinkClicked?: (link: string, content: string | null) => void;
+    mode?: 'compact' | 'full';
+    readingMode?: boolean;
+    partial?: boolean;
+    /**
+     * Heading-style variant.
+     * - `'classic'` (default): bold headings in `theme.palette.primary.main`
+     *   with a colored bottom border. Matches the v1 dashboard-app look.
+     * - `'minimal'`: subtler text-color headings with no border, smaller
+     *   font sizes — for chat / inline content where headings shouldn't
+     *   compete with the surrounding chrome (used by the v2 layout).
+     */
+    variant?: 'classic' | 'minimal';
+}
+/**
+ * Lets a parent subtree opt every nested `MarkdownExtended` into the
+ * minimal heading style without prop-drilling. The explicit `variant`
+ * prop on `MarkdownExtended` always wins.
+ */
+export interface MarkdownExtendedDefaults {
+    variant?: 'classic' | 'minimal';
+}
+export declare const MarkdownExtendedContext: React.Context<MarkdownExtendedDefaults>;
+export declare const useMarkdownExtendedDefaults: () => MarkdownExtendedDefaults;
+declare const MarkdownExtended: React.FC<MarkdownExtendedProps>;
+export default MarkdownExtended;

package/dist/src/components/Library/VizLibrary/Skeletons/ChartSkeleton.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const ChartSkeleton: React.FC;
+export default ChartSkeleton;

package/dist/src/components/Library/VizLibrary/Skeletons/IFrameSkeleton.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const IFrameSkeleton: React.FC;
+export default IFrameSkeleton;

package/dist/src/components/Library/VizLibrary/Skeletons/MetricGroupSkeleton.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface MetricGroupSkeletonProps {
+    metrics?: number;
+    showIcon?: boolean;
+    showChangeRow?: boolean;
+}
+declare const MetricGroupSkeleton: React.FC<MetricGroupSkeletonProps>;
+export default MetricGroupSkeleton;

package/dist/src/components/Library/VizLibrary/Skeletons/MetricSkeleton.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export interface MetricSkeletonProps {
+    showIcon?: boolean;
+    showChangeRow?: boolean;
+}
+declare const MetricSkeleton: React.FC<MetricSkeletonProps>;
+export default MetricSkeleton;

package/dist/src/components/Library/VizLibrary/Skeletons/TableSkeleton.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export interface TableSkeletonProps {
+    columns?: number;
+    rows?: number;
+}
+declare const TableSkeleton: React.FC<TableSkeletonProps>;
+export default TableSkeleton;

package/dist/src/components/Library/VizLibrary/index.d.ts

@@ -0,0 +1,5 @@
+export { default as ChartSkeleton } from './Skeletons/ChartSkeleton';
+export { default as MetricSkeleton } from './Skeletons/MetricSkeleton';
+export { default as MetricGroupSkeleton } from './Skeletons/MetricGroupSkeleton';
+export { default as TableSkeleton } from './Skeletons/TableSkeleton';
+export { default as IFrameSkeleton } from './Skeletons/IFrameSkeleton';

package/dist/src/components/LlmResponseRender/EnvironmentContext.d.ts

@@ -0,0 +1,33 @@
+import { default as React } from 'react';
+export declare const EnvironmentProvider: React.FC<{
+    value: Record<string, unknown>;
+    children: React.ReactNode;
+}>;
+export declare function useEnvironment<T = Record<string, unknown>>(): T;
+/**
+ * Non-throwing variant: returns the surrounding environment, or an empty `{}`
+ * when there's no `EnvironmentProvider` in scope. Use it where an environment
+ * is optional — e.g. the UI-tool dispatcher resolves `env` for actions on
+ * EVERY uiTool part, including chat surfaces that have no provider (there the
+ * action's `env.foo?.()` calls simply no-op). On replay, the surrounding
+ * `InertEnvironmentProvider` already neutralises every callable.
+ */
+export declare function useEnvironmentOptional<T = Record<string, unknown>>(): T;
+/**
+ * Replaces every callable property of the surrounding environment
+ * with a no-op for `children`. Non-callable properties (data, refs,
+ * primitive values) pass through unchanged. Use it to isolate
+ * historical / replayed React subtrees — e.g. completed chat
+ * messages whose body still carries live-TSX side-effect hooks like
+ * `useDashboardPad` — so re-mounting them on session reload cannot
+ * mutate live application state. The subtrees still render, their
+ * components still fetch data, but their side-effect calls dead-end
+ * at this boundary.
+ *
+ * No-throw when there's no parent env: returns an empty record so
+ * `useEnvironment` consumers inside don't blow up either. That
+ * matches the "inert by default" semantics of historical replay.
+ */
+export declare const InertEnvironmentProvider: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/src/components/LlmResponseRender/GeneratingVisualization.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+interface GeneratingVisualizationProps {
+    /**
+     * 0..1 fill progress. Drives the six bar buckets left-to-right —
+     * each bar represents 1/6 of full. The dot tracer above ignores
+     * progress on purpose (it traces the *target* outline so the bars
+     * visibly "catch up" to it as ticks land).
+     */
+    progress?: number;
+    bytes?: number;
+}
+declare const GeneratingVisualization: React.FC<GeneratingVisualizationProps>;
+export default GeneratingVisualization;

package/dist/src/components/LlmResponseRender/LiveJsxBlock.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+/**
+ * Server-emitted sentinel inside a ```liveTsx fence that signals the
+ * block's content should be abandoned (compile failed server-side,
+ * retry incoming). LiveJsxBlock renders nothing when present — the
+ * next ```liveTsx fence opens a fresh block. Keep in sync with the
+ * .NET WSServer's JsxLiveStreamProcessor.
+ */
+export declare const LIVE_TSX_INVALID_SENTINEL = "<!--liveTsx:invalid-->";
+interface LiveJsxBlockProps {
+    /**
+     * Server-compiled JS function body. The .NET WSServer's
+     * `JsxLiveStreamProcessor` runs every closing ```liveTsx fence through
+     * the tsx-sidecar's `build` method (type-check + esbuild transform +
+     * scope-binding rewrite) before it reaches the chat markdown. By the
+     * time we see it here, `code` is already valid JS of the shape:
+     *
+     *   var React = __scope['react'];
+     *   var Box   = __scope['@mui/material'].Box;
+     *   function MyComponent() { return React.createElement(Box, ...); }
+     *   return MyComponent;
+     *
+     * — exactly what `new Function('__scope', code)(scope)` needs to
+     * return the React component. No sucrase, no regex import rewriter,
+     * no main-thread compile pause per block.
+     */
+    code: string;
+    /** Extra scope entries merged on top of the default scope */
+    scope?: Record<string, unknown>;
+    partial: boolean;
+    /**
+     * 0..1 progress hint for partial blocks. Surfaces in the placeholder
+     * (`GeneratingVisualization`) as filled bar buckets — see parseBlocks
+     * for the tick-marker → fraction derivation.
+     */
+    progress?: number;
+    bytes?: number;
+}
+export declare class JsxErrorBoundary extends React.Component<{
+    children: React.ReactNode;
+    fallback: (error: Error) => React.ReactNode;
+}, {
+    error: Error | null;
+}> {
+    state: {
+        error: Error | null;
+    };
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+declare const LiveJsxBlock: React.FC<LiveJsxBlockProps>;
+export default LiveJsxBlock;

package/dist/src/components/LlmResponseRender/LlmResponseRender.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { Interaction } from '../../models/Interaction';
+import { EventBusService } from '../../services/eventBusService';
+interface LlmResponseRenderProps {
+    /** Full LLM response in markdown (may contain ```jsx code blocks) */
+    content: string;
+    sessionId: string;
+    partial: boolean;
+    /** Extra components/values to make available inside JSX blocks */
+    scope?: Record<string, unknown>;
+    eventBusService?: EventBusService;
+    onLinkClicked: (link: string, content: string | null) => void;
+    /** The interaction this text belongs to — used to resolve
+     *  `{{Component:<slotId>}}` tokens to their UI tool part. */
+    message?: Interaction;
+    onGoing?: boolean;
+    friendlyMode?: boolean;
+}
+/**
+ * Renders an LLM markdown response with live JSX previews.
+ *
+ * Regular markdown blocks   → MarkdownExtended (syntax highlighting, icons, etc.)
+ * ```liveTsx blocks    → compiled at runtime with Sucrase and mounted as React components
+ *
+ * Usage:
+ *   <LlmResponseRender content={llmResponse} sessionId={sessionId} />
+ */
+declare const LlmResponseRender: React.FC<LlmResponseRenderProps>;
+export default LlmResponseRender;

package/dist/src/components/LlmResponseRender/index.d.ts

@@ -0,0 +1,6 @@
+export { default as LlmResponseRender } from './LlmResponseRender';
+export { default as LiveJsxBlock, JsxErrorBoundary } from './LiveJsxBlock';
+export { parseContentBlocks, type ContentBlock } from './parseBlocks';
+export { getDefaultJsxScope, extendModuleRegistry, extendDefaultScope } from './jsxScope';
+export { EnvironmentProvider, InertEnvironmentProvider, useEnvironment, useEnvironmentOptional, } from './EnvironmentContext';
+export { LiveTsxConfigProvider, useLiveTsxMaxCharsForFull, LIVE_TSX_DEFAULT_MAX_CHARS_FOR_FULL, } from './liveTsxConfig';

package/dist/src/components/LlmResponseRender/jsxScope.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Extend the module registry with additional exports.
+ * Call once at app startup to inject components that were moved out of the library
+ * but are still imported by LLM-generated code under `@envision/ui-library`.
+ *
+ * Extensions are stored on globalThis so they survive Vite HMR reloads
+ * (module-level variables would be reset when this file is re-evaluated).
+ *
+ * @example
+ * ```ts
+ * import { extendModuleRegistry } from '@envision/ui-library/components';
+ * import { ExamplePad, ExampleCardSketh, PrototypePad } from '@app/components/LlmComponents';
+ *
+ * extendModuleRegistry('@envision/ui-library', { ExamplePad, ExampleCardSketh, PrototypePad });
+ * ```
+ */
+export declare function extendModuleRegistry(specifier: string, exports: Record<string, unknown>): void;
+/**
+ * Extend the bare-identifier scope injected into every compiled liveTsx
+ * block. Use this for components/values that the LLM is allowed to reference
+ * without an explicit `import` (e.g. VizLibrary's Chart/Metric/ContainTable).
+ *
+ * Extensions are stored on globalThis so they survive Vite HMR reloads.
+ *
+ * @example
+ * ```ts
+ * import { extendDefaultScope } from '@envision/ui-library/components';
+ * import * as VizLibrary from '@app/components/VizLibrary';
+ * extendDefaultScope(VizLibrary);
+ * ```
+ */
+export declare function extendDefaultScope(exports: Record<string, unknown>): void;
+export declare function getModuleRegistry(): Promise<Record<string, Record<string, unknown>>>;
+/**
+ * Base scope injected into every compiled LiveJSX block.
+ *
+ * React is always present because Sucrase classic JSX emits
+ * React.createElement() calls. JS globals are included because
+ * `new Function` code does not see the outer lexical environment.
+ */
+export declare function getDefaultJsxScope(): Record<string, unknown>;

package/dist/src/components/LlmResponseRender/liveTsxConfig.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+export declare const LIVE_TSX_DEFAULT_MAX_CHARS_FOR_FULL = 3000;
+/**
+ * Read the host-configured "100%" cap for placeholder progress. Falls
+ * back to {@link LIVE_TSX_DEFAULT_MAX_CHARS_FOR_FULL} when no provider
+ * is mounted above. Consumed inside `LlmResponseRender` and forwarded
+ * to `parseContentBlocks`.
+ */
+export declare function useLiveTsxMaxCharsForFull(): number;
+/**
+ * Wraps any subtree that renders `LlmResponseRender` with a custom
+ * `maxCharsForFull`. Place near the top of a view (e.g. ComposerViewV2)
+ * so every chat surface inside picks up the same hint.
+ */
+export declare const LiveTsxConfigProvider: React.FC<{
+    maxCharsForFull?: number;
+    children: React.ReactNode;
+}>;

package/dist/src/components/LlmResponseRender/parseBlocks.d.ts

@@ -0,0 +1,39 @@
+export type ContentBlock = {
+    type: 'liveTsx' | 'markdown' | 'slot';
+    content?: string;
+    code?: string;
+    /** For `slot` blocks: the SlotId from a UI tool's result, matched to a
+     *  `{{Component:<slotId>}}` token in the assistant text. */
+    slotId?: string;
+    /**
+     * Per-block lifecycle state. False once a closed liveTsx fence has
+     * been parsed out of the chat text (the sidecar's build succeeded
+     * and the compiled JS is safe to mount). True for a "loading"
+     * marker without a paired closing fence, and for the trailing
+     * unclosed fence at the end of streaming text.
+     */
+    partial?: boolean;
+    /**
+     * 0..1 progress hint for partial liveTsx blocks. Derived from the
+     * count of <i data-lt-tick></i> markers the server emits into the
+     * chat text every `STRIDE` chars of TSX body received (see
+     * `LiveTsxProgressStride` in JsxLiveStreamProcessor.cs). Mapped to
+     * `MAX_CHARS_FOR_FULL` and clamped to 1. Consumed by
+     * `GeneratingVisualization` to fill the placeholder's bar buckets.
+     */
+    progress?: number;
+    bytes?: number;
+};
+export declare const DEFAULT_MAX_CHARS_FOR_FULL = 2000;
+/**
+ * Splits a markdown string into sequential content blocks:
+ *  - 'markdown' — regular content (headings, paragraphs, non-JSX code fences, etc.)
+ *  - 'liveTsx'  — fenced code blocks tagged ```liveTsx
+ *
+ * When the text ends with an unclosed ```liveTsx fence (common during streaming),
+ * the partial code is still emitted as a 'liveTsx' block so it goes through
+ * LiveJsxBlock (and skeleton detection) instead of the markdown renderer.
+ */
+export declare function parseContentBlocks(text: string, options?: {
+    maxCharsForFull?: number;
+}): ContentBlock[];

package/dist/src/components/Stopwatch.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+interface StopwatchProps {
+    on: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    showButton?: boolean;
+    startingPoint: Date;
+    stopPoint?: Date;
+    id?: string;
+}
+export declare const Stopwatch: React.FC<StopwatchProps>;
+export default Stopwatch;

package/dist/src/components/index.d.ts

@@ -0,0 +1,30 @@
+export { default as AiChat } from './AiChat/AiChat';
+export { default as ChatPane } from './AiChat/ChatPane/ChatPane';
+export { AiChatProvider } from './AiChat/AiChatProvider';
+export { AiChatDrawer } from './AiChat/AiChatDrawer';
+export { AiChatFloating } from './AiChat/AiChatFloating';
+export { AiChatServiceContext, useAiChatServices, useAiChatSessionStore, } from './AiChat/AiChatContext';
+export type { AiChatContextState as AiChatServices } from './AiChat/AiChatContext';
+export type { AiChatProps, AiChatHandle, AiChatStyleProps, AiChatDrawerProps, AiChatFloatingProps, ConnectionInformation, } from './AiChat/AiChatTypes';
+export type { AiChatState, AiChatStore, SubAgentState } from './AiChat/stateConfiguration';
+export { createAiChatStore } from './AiChat/stateConfiguration';
+export { createAiChatSessionStore } from './AiChat/AiChatSessionStore';
+export { SessionStateManagerService, IDLE_TIMEOUT, WARNING_THRESHOLD, } from './AiChat/sessionStateManagerService';
+export { default as Message } from './AiChat/ChatPane/Message';
+export { default as SubAgentBox } from './AiChat/ChatPane/SubAgentBox';
+export type { SubAgentBoxProps } from './AiChat/ChatPane/SubAgentBox';
+export { classifyPart, DEFAULT_PART_RENDERERS, TextPart, ThoughtPart, FunctionPart, WaitingPart, SuspendedPart, BoxedPart, UiToolDispatcher, } from './AiChat/ChatPane/parts';
+export type { PartKind, PartRendererProps, PartRenderer, PartRendererMap, } from './AiChat/ChatPane/parts';
+export { createUiToolRegistry, parseUiArgs, parseClientOutput } from './AiChat/ChatPane/parts';
+export type { UiToolRegistry, UiToolRegistryBuilder, UiToolContext, UiToolActionContext, UiToolArgs, UiToolRenderFn, UiToolActionFn, UiToolRenderOptions, UiToolActionOptions, UiToolEntry, UiToolRenderEntry, UiToolActionEntry, } from './AiChat/ChatPane/parts';
+export { useContainerWidth, useContainerRectangle } from '../hooks/useContainerWidth';
+export { default as Stopwatch } from './Stopwatch';
+export { default as LoadingDots } from './Library/LoadingDots';
+export { default as MarkdownExtended } from './Library/MarkdowmExtended';
+export { default as ArtifactRender } from './Library/ArtifactRender';
+export { default as LinearBackgroundProgress } from './Library/LinearBackgroundProgress';
+export { default as LinearProgressBarWithMarkers } from './Library/LinearProgressBarWithMarkers';
+export { default as DelayTextComponent } from './Library/DelayTextComponent';
+export { LlmResponseRender, LiveJsxBlock, JsxErrorBoundary, EnvironmentProvider, InertEnvironmentProvider, useEnvironment, useEnvironmentOptional, LiveTsxConfigProvider, useLiveTsxMaxCharsForFull, LIVE_TSX_DEFAULT_MAX_CHARS_FOR_FULL, extendModuleRegistry, extendDefaultScope, getDefaultJsxScope, parseContentBlocks, } from './LlmResponseRender';
+export type { ContentBlock } from './LlmResponseRender';
+export * from './v2';

package/dist/src/components/v2/AgentActivityV2.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+export interface AgentActivityV2Props {
+    /** Hide reasoning rows ("Pensando…"). */
+    hideReasoning?: boolean;
+    /** Maximum visible height before the timeline scrolls. Defaults to 320px. */
+    maxHeight?: number | string;
+    /** Empty state to show when there are no parts to render. */
+    emptyState?: React.ReactNode;
+    /**
+     * Display order. `'chronological'` (default) keeps stream order with
+     * the live row at the bottom and auto-scrolls as new parts arrive;
+     * `'newest-first'` puts the most recent part on top.
+     */
+    order?: 'newest-first' | 'chronological';
+    /**
+     * When true (default) tool rows hide their args/JSON preview line and
+     * only reveal it when the user clicks the row to expand. Set to false
+     * to always show the preview inline.
+     */
+    compact?: boolean;
+    /**
+     * Render a horizontal pill strip at the top to navigate by turn:
+     * an "All turns" pill (merged history) plus one pill per past
+     * interaction. While a turn is in flight the live activities are
+     * shown by default; clicking a pill switches the view. When a turn
+     * closes the panel goes empty until the user picks a pill — i.e.
+     * we don't keep showing the previous turn's stale activities.
+     * Defaults to `false`.
+     */
+    showTurnHistory?: boolean;
+}
+export declare const AgentActivityV2: React.FC<AgentActivityV2Props>;

package/dist/src/components/v2/AiChatFloatingV2.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { AiChatFloatingProps, AiChatHandle } from '../AiChat/AiChatTypes';
+export declare const AiChatFloatingV2: React.ForwardRefExoticComponent<AiChatFloatingProps & React.RefAttributes<AiChatHandle>>;

package/dist/src/components/v2/AiChatV2Pane.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+export interface AiChatV2PaneProps {
+    /** Override the title shown in the header. Defaults to the current session's overview. */
+    title?: string;
+    /** Optional mono-styled subtitle, e.g. "· 14 sem · BI_Master". */
+    subtitle?: string;
+    /** Right-aligned slot, e.g. "Pin no dashboard" chip. */
+    actions?: React.ReactNode;
+    /** Hide the header entirely. */
+    hideHeader?: boolean;
+    /**
+     * Optional content rendered below the prompt input, inside the same
+     * column. Mirrors the `bottomSlot` of the v1 AiChat / AiChatFloating:
+     * the inner ChatPane keeps its own scroll and the slot lives below
+     * it as a fixed-height row. The responsive DataExplorer uses this
+     * to mount `<RunProgressStripV2 />` on mobile.
+     */
+    bottomSlot?: React.ReactNode;
+}
+export declare const AiChatV2Pane: React.FC<AiChatV2PaneProps>;

package/dist/src/components/v2/AppBarV2.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+export declare const APPBAR_V2_HEIGHT = 48;
+export interface AppBarV2Props {
+    /** Logo / brand mark on the far left. */
+    logo?: React.ReactNode;
+    /** Product or app name shown next to the logo. */
+    productName?: string;
+    /** Optional breadcrumb / context node rendered between brand and search. */
+    breadcrumb?: React.ReactNode;
+    /** Right-aligned slot, typically the user-profile menu. */
+    rightAccessory?: React.ReactNode;
+    /** Called when the user clicks the (decorative) search box. */
+    onSearchClick?: () => void;
+    /** Override the search box placeholder text. */
+    searchPlaceholder?: string;
+    /** Hide the search box entirely. */
+    hideSearch?: boolean;
+    /**
+     * Replace the built-in decorative search with a host-provided
+     * node (e.g. <DashboardsAutocompleteV2 />). When provided,
+     * `onSearchClick` and `searchPlaceholder` are ignored.
+     */
+    searchSlot?: React.ReactNode;
+    /**
+     * Hamburger trigger rendered before the logo. Hosts mount this on
+     * the responsive (< lg) breakpoint to open the MobileDrawerV2.
+     */
+    hamburger?: React.ReactNode;
+    /**
+     * Compact mode — the responsive (< lg) chrome. Hides the search
+     * box (no room next to the hamburger), tightens horizontal gaps,
+     * and lets the breadcrumb slot carry just the company chip (the
+     * host decides what to pass). The desktop layout is preserved
+     * when this is `false` (the default).
+     */
+    compact?: boolean;
+}
+export declare const AppBarV2: React.FC<AppBarV2Props>;

package/dist/src/components/v2/AppRailV2.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+export interface AppRailV2View {
+    id: string;
+    label: string;
+    icon: React.ReactNode;
+    /** Route the view navigates to (e.g. '/dashboards'). */
+    to: string;
+    /**
+     * Optional matcher. By default the view is active when pathname starts
+     * with `to`. Use this when two views share a prefix.
+     */
+    isActive?: (pathname: string) => boolean;
+}
+export interface AppRailV2Props {
+    views: AppRailV2View[];
+    /** Logo / brand mark rendered at the top of the rail. */
+    logo?: React.ReactNode;
+    /** Optional content rendered at the bottom (avatar, settings). */
+    footer?: React.ReactNode;
+}
+export declare const AppRailV2: React.FC<AppRailV2Props>;

package/dist/src/components/v2/AppShellV2.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+export interface AppShellV2Props {
+    /** Rendered at the top, full width. Typically <AppBarV2 ... />. */
+    appBar?: React.ReactNode;
+    /** Rendered on the left, full height under the top bar. Typically <AppRailV2 ... />. */
+    rail?: React.ReactNode;
+    /**
+     * Optional content rendered in place of <Outlet />. Useful for tests or
+     * when nesting an alternate router. Defaults to <Outlet />.
+     */
+    children?: React.ReactNode;
+}
+export declare const AppShellV2: React.FC<AppShellV2Props>;

package/dist/src/components/v2/ChatsHistoryV2.d.ts

@@ -0,0 +1,47 @@
+import { default as React } from 'react';
+import { ChatSessionGroup, ChatSessionListItem } from '../../hooks';
+import { ChatSession } from '../../models/ChatSession';
+export interface ChatsHistoryV2Item {
+    id: string;
+    title: string;
+    /** e.g. "agora", "2h", "1d", "5d", "1sem" */
+    time?: string;
+    snippet?: string;
+    /**
+     * Optional session kind. The host distinguishes between regular
+     * data-explorer chats and composer sessions (those that produced
+     * a dashboard) so the row can render a small visual cue and the
+     * click handler can route to the right view.
+     */
+    kind?: 'chat' | 'composer';
+    /**
+     * When true, animate `title` char-by-char whenever it changes.
+     * Host marks the "current working session" with this so the
+     * generated overview reveals itself as if being typed live.
+     */
+    typewriter?: boolean;
+}
+export interface ChatsHistoryV2Props {
+    groups: ChatSessionGroup[];
+    newActiveSession?: ChatSession;
+    activeId?: string;
+    onSelect?: (item: ChatSessionListItem) => void;
+    onNewSession?: () => void;
+    /**
+     * Rename a session. Receives the new title. The host should patch
+     * the session's `overview` (or whatever it shows as the title) and
+     * refresh the list.
+     */
+    onRename?: (id: string, newTitle: string) => void | Promise<void>;
+    /** Delete a session. The host should confirm if it wants extra friction beyond the built-in dialog. */
+    onDelete?: (id: string) => void | Promise<void>;
+    /** Footer slot, typically a small avatar + name. */
+    footer?: React.ReactNode;
+    /** Header brand mark / app name. */
+    header?: React.ReactNode;
+    /** Search box label override. */
+    searchPlaceholder?: string;
+    /** Total count override; defaults to flat sum of items. */
+    totalCount?: number;
+}
+export declare const ChatsHistoryV2: React.FC<ChatsHistoryV2Props>;

package/dist/src/components/v2/LastPromptsV2.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export interface LastPromptsV2Props {
+    /** Receives the selected prompt's text (and optional JSON payload). */
+    onPromptSelected: (promptText: string, promptJson?: string) => void;
+}
+export declare const LastPromptsV2: React.FC<LastPromptsV2Props>;

package/dist/src/components/v2/MobileDrawerV2.d.ts

@@ -0,0 +1,43 @@
+import { default as React } from 'react';
+export interface MobileDrawerV2NavItem {
+    id: string;
+    label: string;
+    to: string;
+    icon: React.ReactNode;
+    isActive?: (pathname: string) => boolean;
+}
+export declare const MOBILE_NAV_DEFAULT: MobileDrawerV2NavItem[];
+export interface MobileDrawerV2Props {
+    /** Controlled open state. */
+    open: boolean;
+    width?: string;
+    /** Fired when the drawer requests to close (backdrop click, ESC, nav tap). */
+    onClose: () => void;
+    /** Override the nav-icon list. Defaults to Dashboards + Data Explorer. */
+    navItems?: MobileDrawerV2NavItem[];
+    /** Brand mark rendered at the top of the drawer. */
+    logo?: React.ReactNode;
+    /** Optional product name shown next to the logo. */
+    productName?: string;
+    /** Bottom-pinned content — typically the UserProfile menu. */
+    userProfile?: React.ReactNode;
+    /**
+     * Sessions list element — typically a self-contained
+     * `<MobileSessionsList />` adapter that fetches its own data.
+     * Rendered between the nav and the user footer when the active
+     * pathname starts with `/data-explorer`. The component is only
+     * mounted when its route is active; passing both slots as JSX
+     * does NOT mount both (React elements are descriptions until
+     * committed).
+     */
+    sessionsList?: React.ReactNode;
+    /**
+     * Dashboards list element — `<MobileDashboardsList />` or
+     * equivalent. Rendered when the active pathname starts with
+     * `/board`.
+     */
+    dashboardsList?: React.ReactNode;
+    /** When true, tapping a nav item also closes the drawer. Defaults true. */
+    closeOnNavigate?: boolean;
+}
+export declare const MobileDrawerV2: React.FC<MobileDrawerV2Props>;