@adecore/agents-react 0.22.0 → 0.23.0

package/dist/chat/ui/diff/diff-source-budget.js

@@ -0,0 +1,47 @@
+// Diff preparation is synchronous; cap source work before creating lines or hunks.
+const SOURCE_BUDGET = { rows: 20000, characters: 2000000, lineLength: 1000000 };
+const PATCH_BUDGET = { rows: 50000, characters: 4000000, lineLength: 1000001 };
+const LEGACY_BUDGET = { rows: 400, characters: 100000, lineLength: 10000 };
+export function textFitsBudget(text, budget) {
+    if (text.length > budget.characters) {
+        return false;
+    }
+    let rows = text.length === 0 ? 0 : 1;
+    let length = 0;
+    for (let index = 0; index < text.length; index++) {
+        if (text.charCodeAt(index) === 10) {
+            if (index < text.length - 1 && ++rows > budget.rows) {
+                return false;
+            }
+            length = 0;
+        }
+        else if (++length > budget.lineLength) {
+            return false;
+        }
+    }
+    return rows <= budget.rows;
+}
+export function diffSourceBudget(before, after) {
+    return textFitsBudget(before, SOURCE_BUDGET) && textFitsBudget(after, SOURCE_BUDGET);
+}
+export function patchSourceBudget(patch) {
+    return textFitsBudget(patch, PATCH_BUDGET);
+}
+export function legacyDiffBudget(before, after, patch = '') {
+    // Combined sources and patch must fit one small legacy render, including trailing blank lines.
+    if (before.length + after.length + patch.length > LEGACY_BUDGET.characters) {
+        return false;
+    }
+    let rows = 2;
+    for (const text of [before, after, patch]) {
+        if (!textFitsBudget(text, LEGACY_BUDGET)) {
+            return false;
+        }
+        for (let index = 0; index < text.length; index++) {
+            if (text.charCodeAt(index) === 10 && ++rows > LEGACY_BUDGET.rows) {
+                return false;
+            }
+        }
+    }
+    return true;
+}

package/dist/chat/ui/diff/editor-edit-model.d.ts

@@ -0,0 +1,8 @@
+import { type DiffDocument } from '@adecore/merge';
+export declare const EDITOR_DIFF_WORK = 4000000;
+export declare const EDITOR_DIFF_LIMITS: {
+    rows: number;
+    characters: number;
+    lineLength: number;
+};
+export declare function canRenderEditorDiff(document: DiffDocument): boolean;

package/dist/chat/ui/diff/editor-edit-model.js

@@ -0,0 +1,19 @@
+import { diffRows } from '@adecore/merge';
+// Larger rendering tiers need native production measurements before this gate expands.
+export const EDITOR_DIFF_WORK = 4_000_000;
+export const EDITOR_DIFF_LIMITS = { rows: 2000, characters: 2000000, lineLength: 10000 };
+export function canRenderEditorDiff(document) {
+    let rows = 0;
+    let characters = 0;
+    for (const row of diffRows(document, 'unified')) {
+        if (row.kind === 'gap') {
+            continue;
+        }
+        const text = row.new === undefined ? document.sides.old[row.old.index] : document.sides.new[row.new.index];
+        characters += text.length + (rows > 0 ? 1 : 0);
+        if (++rows > EDITOR_DIFF_LIMITS.rows || characters > EDITOR_DIFF_LIMITS.characters || text.length > EDITOR_DIFF_LIMITS.lineLength) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/chat/ui/diff/review-plan.d.ts

@@ -0,0 +1,28 @@
+import type { ChatFileChange } from '@adecore/agent-contracts';
+import type { FileChange } from '../../logic/tools.js';
+import type { DiffContents } from '../full-diff.js';
+export interface ReviewEntry {
+    readonly key: string;
+    readonly path: string;
+    readonly change: {
+        readonly kind: 'edit';
+        readonly edit: FileChange;
+    } | {
+        readonly kind: 'patch';
+        readonly patch: ChatFileChange;
+        readonly contents?: DiffContents;
+    };
+}
+export interface ReviewBudget {
+    readonly editors: number;
+    readonly rows: number;
+    readonly characters: number;
+}
+export declare const REVIEW_BUDGET: ReviewBudget;
+export type ReviewSlot = 'editor' | 'deferred';
+export declare function reviewEntries(patches: readonly ChatFileChange[], edits: readonly FileChange[]): readonly ReviewEntry[];
+export declare function reviewSize(entry: ReviewEntry, budget?: ReviewBudget): {
+    rows: number;
+    characters: number;
+};
+export declare function planReview(entries: readonly ReviewEntry[], promoted: string | null, budget?: ReviewBudget): ReadonlyMap<string, ReviewSlot>;

package/dist/chat/ui/diff/review-plan.js

@@ -0,0 +1,48 @@
+export const REVIEW_BUDGET = { editors: 3, rows: 2000, characters: 2000000 };
+export function reviewEntries(patches, edits) {
+    return [
+        ...patches.map((patch, index) => ({ key: `patch:${index}:${patch.path}`, path: patch.path, change: { kind: 'patch', patch } })),
+        ...edits.map((edit, index) => ({ key: `edit:${index}:${edit.path}`, path: edit.path, change: { kind: 'edit', edit } }))
+    ];
+}
+export function reviewSize(entry, budget = REVIEW_BUDGET) {
+    const texts = entry.change.kind === 'edit' ? [entry.change.edit.before, entry.change.edit.after] : [entry.change.patch.diff];
+    const characters = texts.reduce((sum, text) => sum + text.length, 0);
+    if (characters > budget.characters) {
+        return { rows: budget.rows + 1, characters };
+    }
+    let rows = 0;
+    for (const text of texts) {
+        if (text.length > 0) {
+            rows++;
+        }
+        for (let index = text.indexOf('\n'); index >= 0; index = text.indexOf('\n', index + 1)) {
+            if (++rows > budget.rows) {
+                return { rows, characters };
+            }
+        }
+    }
+    return { rows, characters };
+}
+export function planReview(entries, promoted, budget = REVIEW_BUDGET) {
+    const priority = entries.find((entry) => entry.key === promoted);
+    const ordered = priority === undefined ? entries : [priority, ...entries.filter((entry) => entry !== priority)];
+    const slots = new Map();
+    let editors = 0;
+    let rows = 0;
+    let characters = 0;
+    for (const entry of ordered) {
+        const size = reviewSize(entry, budget);
+        // The first review keeps its own omission and error handling, even when the group estimate exceeds the budget.
+        if (editors === 0 || (editors < budget.editors && rows + size.rows <= budget.rows && characters + size.characters <= budget.characters)) {
+            slots.set(entry.key, 'editor');
+            editors++;
+            rows += size.rows;
+            characters += size.characters;
+        }
+        else {
+            slots.set(entry.key, 'deferred');
+        }
+    }
+    return slots;
+}

package/dist/chat/ui/diff/review-settle.d.ts

@@ -0,0 +1,5 @@
+export declare const ReviewSettleContext: import("react").Context<{
+    readonly key: string;
+    settle(key: string): void;
+} | null>;
+export declare function useReviewSettled(): void;

package/dist/chat/ui/diff/review-settle.js

@@ -0,0 +1,12 @@
+import { createContext, useContext, useEffect } from 'react';
+export const ReviewSettleContext = createContext(null);
+export function useReviewSettled() {
+    const scope = useContext(ReviewSettleContext);
+    const key = scope?.key;
+    const settle = scope?.settle;
+    useEffect(() => {
+        if (key !== undefined) {
+            settle?.(key);
+        }
+    }, [key, settle]);
+}

package/dist/chat/ui/diff/syntax-runtime.d.ts

@@ -0,0 +1,18 @@
+import type { Highlighter, ThemeRegistration } from 'shiki';
+import { type DiffSyntaxDocument, type DiffSyntaxTokens } from '@adecore/editor/shiki-worker';
+export interface DiffSyntaxSession {
+    request(index: number): Promise<DiffSyntaxTokens | null>;
+    cancel(): void;
+    dispose(): void;
+}
+export interface DiffSyntaxRuntime {
+    open(document: DiffSyntaxDocument): DiffSyntaxSession;
+    dispose(): void;
+}
+export interface DiffSyntaxRuntimeOptions {
+    workerFactory?: () => Worker;
+    themes: readonly ThemeRegistration[];
+    highlighter?: () => Promise<Highlighter>;
+}
+export declare function diffSyntaxRuntime(): DiffSyntaxRuntime;
+export declare function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): DiffSyntaxRuntime;

package/dist/chat/ui/diff/syntax-runtime.js

@@ -0,0 +1,184 @@
+import { createSyntaxService } from '@adecore/editor/shiki-worker';
+import { chatHost } from '../../../host.js';
+let nextGeneration = 0;
+let shared;
+export function diffSyntaxRuntime() {
+    const code = chatHost().code;
+    return (shared ??= createDiffSyntaxRuntime({ workerFactory: code.syntaxWorker, themes: code.custom, highlighter: code.highlighter }));
+}
+export function createDiffSyntaxRuntime(options) {
+    const sessions = new Map();
+    let worker;
+    let fallback;
+    let highlighter;
+    let started = false;
+    let stopped = false;
+    const settle = (session) => {
+        for (const pending of session.pending.values()) {
+            pending.resolve(null);
+        }
+        session.pending.clear();
+    };
+    const stopWorker = () => {
+        worker?.removeEventListener('message', onMessage);
+        worker?.removeEventListener('error', onError);
+        worker?.removeEventListener('messageerror', onError);
+        worker?.terminate();
+        worker = undefined;
+    };
+    const loadHighlighter = () => {
+        highlighter ??= import('shiki').then(({ createHighlighter }) => createHighlighter({ langs: [], themes: [] }));
+        return highlighter;
+    };
+    const startFallback = () => {
+        stopWorker();
+        if (fallback !== undefined || stopped) {
+            return;
+        }
+        fallback = createSyntaxService({ highlighter: options.highlighter ?? loadHighlighter, send: receive });
+        dispatch({ type: 'start', themes: options.themes, maxLines: 100000 });
+        for (const [generation, session] of sessions) {
+            session.sent = false;
+            for (const index of session.pending.keys()) {
+                request(generation, session, index);
+            }
+        }
+    };
+    const onError = (event) => {
+        event.preventDefault();
+        startFallback();
+    };
+    const onMessage = (event) => {
+        receive(event.data);
+    };
+    const initialize = () => {
+        if (started || stopped) {
+            return;
+        }
+        started = true;
+        if (options.workerFactory !== undefined) {
+            try {
+                worker = options.workerFactory();
+                worker.addEventListener('message', onMessage);
+                worker.addEventListener('error', onError);
+                worker.addEventListener('messageerror', onError);
+                dispatch({ type: 'start', themes: options.themes, maxLines: 100000 });
+                return;
+            }
+            catch {
+                startFallback();
+            }
+        }
+        else {
+            startFallback();
+        }
+    };
+    const dispatch = (message) => {
+        if (stopped) {
+            return;
+        }
+        if (worker !== undefined) {
+            try {
+                worker.postMessage(message);
+            }
+            catch {
+                startFallback();
+            }
+        }
+        else if (fallback !== undefined) {
+            void fallback.handle(message).catch(() => {
+                for (const session of sessions.values()) {
+                    settle(session);
+                }
+            });
+        }
+    };
+    const request = (generation, session, index, resend = false) => {
+        const document = !session.sent || resend ? session.definition : undefined;
+        session.sent = true;
+        dispatch({ type: 'request', generation, index, ...(document ? { document } : {}) });
+    };
+    const receive = (message) => {
+        if (stopped || message.type === 'ready') {
+            return;
+        }
+        if (message.type === 'error') {
+            if (worker !== undefined) {
+                startFallback();
+            }
+            else {
+                for (const session of sessions.values()) {
+                    settle(session);
+                }
+            }
+            return;
+        }
+        const session = sessions.get(message.generation);
+        const pending = session?.pending.get(message.index);
+        if (session === undefined || pending === undefined) {
+            return;
+        }
+        if (message.type === 'failed' && message.reason === 'missing' && !pending.resent) {
+            pending.resent = true;
+            request(message.generation, session, message.index, true);
+            return;
+        }
+        session.pending.delete(message.index);
+        pending.resolve(message.type === 'tokens' ? message : null);
+    };
+    return {
+        open(document) {
+            const generation = ++nextGeneration;
+            const session = { definition: document, pending: new Map(), sent: false };
+            sessions.set(generation, session);
+            return {
+                request(index) {
+                    if (stopped || !sessions.has(generation)) {
+                        return Promise.resolve(null);
+                    }
+                    const existing = session.pending.get(index);
+                    if (existing !== undefined) {
+                        return existing.promise;
+                    }
+                    let resolve;
+                    const promise = new Promise((done) => {
+                        resolve = done;
+                    });
+                    session.pending.set(index, { promise, resolve, resent: false });
+                    const initialized = started;
+                    initialize();
+                    // Fallback initialization replays pending requests, including this first one.
+                    if (initialized || worker !== undefined) {
+                        request(generation, session, index);
+                    }
+                    return promise;
+                },
+                cancel() {
+                    settle(session);
+                    if (started) {
+                        dispatch({ type: 'cancel', generation });
+                    }
+                },
+                dispose() {
+                    settle(session);
+                    sessions.delete(generation);
+                    if (started) {
+                        dispatch({ type: 'dispose', generation });
+                    }
+                }
+            };
+        },
+        dispose() {
+            stopped = true;
+            for (const session of sessions.values()) {
+                settle(session);
+            }
+            sessions.clear();
+            stopWorker();
+            fallback?.dispose();
+            if (options.highlighter === undefined) {
+                void highlighter?.then((loaded) => loaded.dispose(), () => undefined);
+            }
+        }
+    };
+}

package/dist/chat/ui/diff/use-review-stack.d.ts

@@ -0,0 +1,8 @@
+import { type ReviewEntry, type ReviewSlot } from './review-plan.js';
+export interface ReviewStack {
+    readonly slots: ReadonlyMap<string, ReviewSlot>;
+    readonly ready: ReadonlySet<string>;
+    promote(key: string): void;
+    settle(key: string): void;
+}
+export declare function useReviewStack(entries: readonly ReviewEntry[]): ReviewStack;

package/dist/chat/ui/diff/use-review-stack.js

@@ -0,0 +1,30 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { planReview } from './review-plan.js';
+export function useReviewStack(entries) {
+    const [promoted, setPromoted] = useState(null);
+    const slots = useMemo(() => planReview(entries, promoted), [entries, promoted]);
+    const selected = [...slots].filter(([, slot]) => slot === 'editor').map(([key]) => key);
+    const [admitted, setAdmitted] = useState(() => selected.slice(0, 1));
+    const retained = admitted.filter((key) => selected.includes(key));
+    const live = retained.length === 0 ? selected.slice(0, 1) : retained;
+    if (live.length !== admitted.length || live.some((key, index) => key !== admitted[index])) {
+        setAdmitted(live);
+    }
+    const [settled, setSettled] = useState(() => new Set());
+    if ([...settled].some((key) => !selected.includes(key))) {
+        setSettled(new Set([...settled].filter((key) => selected.includes(key))));
+    }
+    const settle = useCallback((key) => {
+        setSettled((previous) => (previous.has(key) ? previous : new Set([...previous, key])));
+    }, []);
+    const allSettled = live.every((key) => settled.has(key));
+    const next = selected.find((key) => !live.includes(key));
+    useEffect(() => {
+        if (next === undefined || !allSettled) {
+            return;
+        }
+        const frame = window.requestAnimationFrame(() => setAdmitted((previous) => [...previous, next]));
+        return () => window.cancelAnimationFrame(frame);
+    }, [next, allSettled]);
+    return { slots, ready: new Set(live), promote: setPromoted, settle };
+}

package/dist/chat/ui/diff-syntax.d.ts

@@ -0,0 +1,19 @@
+import type { LineToken } from '@adecore/editor';
+import { type DiffSyntaxDocument } from '@adecore/editor/shiki-worker';
+import type { DiffDocument } from '@adecore/merge';
+import { type DiffSyntaxRuntime } from './diff/syntax-runtime.js';
+export { createDiffSyntaxRuntime, diffSyntaxRuntime } from './diff/syntax-runtime.js';
+export type { DiffSyntaxRuntime, DiffSyntaxRuntimeOptions, DiffSyntaxSession } from './diff/syntax-runtime.js';
+export interface DiffSyntaxMapping {
+    readonly documents: Readonly<Record<'old' | 'new', DiffSyntaxDocument>>;
+    locate(side: 'old' | 'new', index: number): {
+        readonly block: number;
+        readonly line: number;
+    } | undefined;
+}
+export interface DiffSourceTokenSession {
+    get(side: 'old' | 'new', index: number): readonly LineToken[] | null | undefined;
+    subscribe(listener: () => void): () => void;
+    dispose(): void;
+}
+export declare function diffSourceTokens(document: DiffDocument, mapping: DiffSyntaxMapping, runtime?: DiffSyntaxRuntime): DiffSourceTokenSession;

package/dist/chat/ui/diff-syntax.js

@@ -0,0 +1,63 @@
+import { lineTokensOf } from '@adecore/editor/shiki-worker';
+import { diffSyntaxRuntime } from './diff/syntax-runtime.js';
+export { createDiffSyntaxRuntime, diffSyntaxRuntime } from './diff/syntax-runtime.js';
+/* Structurally accepts the editor's source mapping without depending on its React renderer. */
+export function diffSourceTokens(document, mapping, runtime = diffSyntaxRuntime()) {
+    const sides = { old: runtime.open(mapping.documents.old), new: runtime.open(mapping.documents.new) };
+    const cache = { old: new Map(), new: new Map() };
+    const pending = { old: new Set(), new: new Set() };
+    const listeners = new Set();
+    let disposed = false;
+    return {
+        get(side, index) {
+            const location = mapping.locate(side, index);
+            if (disposed || location === undefined || document.sides[side][index] === undefined) {
+                return null;
+            }
+            const { block, line } = location;
+            const known = cache[side].get(block);
+            if (known !== undefined) {
+                return known[line] ?? null;
+            }
+            if (!pending[side].has(block)) {
+                pending[side].add(block);
+                const text = mapping.documents[side].blocks[block].split('\n');
+                const publish = (lines) => {
+                    if (disposed) {
+                        return;
+                    }
+                    pending[side].delete(block);
+                    cache[side].set(block, lines);
+                    for (const listener of [...listeners]) {
+                        listener();
+                    }
+                };
+                const count = text.length;
+                void sides[side].request(block).then((packet) => {
+                    if (!disposed) {
+                        publish(text.map((text, line) => (packet === null || packet.lines.length !== count + 1 ? null : lineTokensOf(packet, line, text))));
+                    }
+                }, () => publish(text.map(() => null)));
+            }
+            return undefined;
+        },
+        subscribe(listener) {
+            if (!disposed) {
+                listeners.add(listener);
+            }
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        dispose() {
+            disposed = true;
+            listeners.clear();
+            sides.old.dispose();
+            sides.new.dispose();
+            cache.old.clear();
+            cache.new.clear();
+            pending.old.clear();
+            pending.new.clear();
+        }
+    };
+}

package/dist/chat/ui/intelligent-ui/UiBlockFrame.js

@@ -2,7 +2,7 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useId, useLayoutEffect, useRef, useState } from 'react';
 import clsx from 'clsx';
 import { useTranslation } from 'react-i18next';
-import { Lock, Radio, TriangleAlert, Wrench } from 'lucide-react';
+import { Info, Lock, Radio, TriangleAlert } from 'lucide-react';
 import { Icon, Skeleton, Spinner, Tooltip, useTickingText } from '@adecore/ui';
 import { formatAgo, formatMoment } from '@adecore/ui/format';
 import { uiBlockHead, uiReasonText } from './node-text.js';
@@ -36,7 +36,7 @@ function LivePart({ live }) {
     return hint === null ? body : _jsx(Tooltip, { label: hint, children: body });
 }
 /*
- * The line under a block, only when it has something to say: live, answered, repaired or drawn as
+ * The line under a block, only when it has something to say: live, answered, noted or drawn as
  * text, in that order. A hairline of the soft border runs the full width of the card over it.
  */
 function UiBlockFooter({ live = null, answered = null, fixes = NO_FIXES, shownAsText = null }) {
@@ -46,7 +46,7 @@ function UiBlockFooter({ live = null, answered = null, fixes = NO_FIXES, shownAs
     if (live === null && answered === null && fixes.length === 0 && shownAsText === null) {
         return null;
     }
-    return (_jsxs("div", { className: "-mx-2.25 mt-2.25 -mb-2.25 flex flex-col gap-1.5 border-t border-border-soft px-4.25 py-2 text-xs text-text-faint", children: [_jsxs("div", { className: "flex flex-wrap items-center gap-x-3 gap-y-1", children: [live !== null && _jsx(LivePart, { live: live }), answered !== null && (_jsxs("span", { className: "flex items-center gap-1.5", children: [_jsx("span", { children: t('blocks.answered', { label: answered.label }) }), _jsx("span", { "aria-hidden": true, children: "\u00B7" }), _jsx("time", { dateTime: new Date(answered.at).toISOString(), children: formatMoment(answered.at) })] })), fixes.length > 0 && (_jsxs("button", { type: "button", "aria-expanded": fixesOpen, "aria-controls": listId, className: "flex items-center gap-1.5 rounded-sm hover:text-text-muted", onClick: () => setFixesOpen(!fixesOpen), children: [_jsx(Icon, { icon: Wrench, size: 12 }), t('blocks.fixes', { count: fixes.length })] })), shownAsText !== null && (_jsxs("span", { className: "flex items-center gap-1.5", children: [_jsx("span", { children: t('blocks.shownAsText') }), _jsx("span", { "aria-hidden": true, children: "\u00B7" }), _jsx("span", { children: shownAsText })] }))] }), fixes.length > 0 && (_jsx("ul", { id: listId, hidden: !fixesOpen, className: "flex flex-col gap-0.5 text-text-muted", children: fixes.map((fix, index) => (_jsxs("li", { className: "flex gap-2", children: [_jsx("span", { className: "shrink-0 font-mono", children: fix.code }), _jsx("span", { className: "min-w-0", children: fix.message })] }, index))) }))] }));
+    return (_jsxs("div", { className: "-mx-2.25 mt-2.25 -mb-2.25 flex flex-col gap-1.5 border-t border-border-soft px-4.25 py-2 text-xs text-text-faint", children: [_jsxs("div", { className: "flex flex-wrap items-center gap-x-3 gap-y-1", children: [live !== null && _jsx(LivePart, { live: live }), answered !== null && (_jsxs("span", { className: "flex items-center gap-1.5", children: [_jsx("span", { children: t('blocks.answered', { label: answered.label }) }), _jsx("span", { "aria-hidden": true, children: "\u00B7" }), _jsx("time", { dateTime: new Date(answered.at).toISOString(), children: formatMoment(answered.at) })] })), fixes.length > 0 && (_jsxs("button", { type: "button", "aria-expanded": fixesOpen, "aria-controls": listId, className: "flex items-center gap-1.5 rounded-sm hover:text-text-muted", onClick: () => setFixesOpen(!fixesOpen), children: [_jsx(Icon, { icon: Info, size: 12 }), t('blocks.notes', { count: fixes.length })] })), shownAsText !== null && (_jsxs("span", { className: "flex items-center gap-1.5", children: [_jsx("span", { children: t('blocks.shownAsText') }), _jsx("span", { "aria-hidden": true, children: "\u00B7" }), _jsx("span", { children: shownAsText })] }))] }), fixes.length > 0 && (_jsx("ul", { id: listId, hidden: !fixesOpen, className: "flex flex-col gap-0.5 text-text-muted", children: fixes.map((fix, index) => (_jsxs("li", { className: "flex gap-2", children: [_jsx("span", { className: "shrink-0 font-mono", children: fix.code }), _jsx("span", { className: "min-w-0", children: fix.message })] }, index))) }))] }));
 }
 const RELEASE_MS = 200;
 /*

package/dist/chat/ui/intelligent-ui/UiFallbackPart.js

@@ -7,5 +7,5 @@ import { Markdown } from '../Markdown.js';
  */
 export function UiFallbackPart({ fallback, problem }) {
     const { t } = useTranslation('agent-chat');
-    return (_jsxs("div", { className: "flex flex-col gap-1 rounded-md bg-surface-hover p-2", children: [_jsx("span", { className: "text-xs text-text-faint", children: problem.kind === 'unknown' ? t('blocks.unknownComponent', { component: problem.component }) : t('blocks.renderFailed') }), fallback !== '' && _jsx(Markdown, { text: fallback, fileLinks: false })] }));
+    return (_jsxs("div", { className: "flex flex-col gap-1 rounded-md bg-surface-hover p-2", children: [_jsx("span", { className: "text-xs text-text-faint", children: problem.kind === 'unknown' ? t('blocks.unknownComponent', { component: problem.component }) : t('blocks.renderFailed') }), fallback !== '' && (_jsx("div", { className: "min-w-0 wrap-anywhere", children: _jsx(Markdown, { text: fallback, fileLinks: false }) }))] }));
 }

package/dist/chat/ui/intelligent-ui/chart-data.d.ts

@@ -1,16 +1,36 @@
 import type { UiProps } from '@adecore/intelligent-ui';
 export declare const UI_CHART_SERIES = 6;
 export declare const UI_CHART_ROWS = 60;
+type ChartKind = UiProps<'Chart'>['kind'];
 export interface UiChartSeries {
     key: string;
     values: (number | null)[];
 }
-export interface UiChartData {
+export interface UiChartValues {
     labels: string[];
     series: UiChartSeries[];
+}
+export interface UiChartData extends UiChartValues {
+    kind: ChartKind;
     min: number;
     max: number;
     truncated: boolean;
+    total: number;
+    omitted: string[];
 }
-export declare function uiChartData(data: UiProps<'Chart'>['data'], kind: UiProps<'Chart'>['kind']): UiChartData | null;
+export declare function uiChartValues(data: UiProps<'Chart'>['data']): UiChartValues;
+export declare function uiChartRange(min: number, max: number): {
+    low: number;
+    high: number;
+} | null;
+export declare function uiChartData(data: UiProps<'Chart'>['data'], kind: ChartKind): UiChartData | null;
+export declare const UI_CHART_CHARACTER = 7.5;
+export declare function uiChartCharacter(rootFontSize: number): number;
+export declare function uiChartTextWidth(text: string, character?: number): number;
+export declare function uiChartText(text: string, room: number, character?: number): string;
+export declare function uiChartAxis(ticks: readonly string[], width: number, character?: number): {
+    axisWidth: number;
+    tickTexts: string[];
+};
 export declare function niceCeiling(value: number): number;
+export {};