@adecore/agents-react 0.22.1 → 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/rows/WorkRows.js

@@ -16,8 +16,10 @@ import { formatClockDuration, formatElapsedShort } from '@adecore/ui/format';
 import { Icon, Spinner, useTickingText } from '@adecore/ui';
 import { ROW_GUTTER, toolIcon } from '../icons.js';
 import { AnsiOutput } from '../AnsiOutput.js';
-// The diff renderers carry shiki; they only load once a thread shows a file change.
-const EditDiff = lazyNamed(() => import('../EditDiff.js'), 'default');
+import { DiffStack, ReviewStackView } from '../diff/DiffStack.js';
+import { reviewEntries } from '../diff/review-plan.js';
+import { useReviewStack } from '../diff/use-review-stack.js';
+// A checkpoint opens its renderer only when a file is expanded.
 const UnifiedDiff = lazyNamed(() => import('../UnifiedDiff.js'), 'default');
 const OUTPUT_LIMIT = 4000;
 function clip(text) {
@@ -42,7 +44,7 @@ function ChangedFileLine({ path, open, onToggle, trailing, children }) {
 function ToolBody({ tool }) {
     const patches = unifiedChanges(tool);
     const changes = patches.length > 0 ? [] : fileChanges(tool.name, tool.input);
-    return (_jsxs("div", { className: "mt-1.5 mb-2 ml-6 overflow-hidden rounded-md border border-border bg-surface-raised", children: [patches.length > 0 ? (_jsx(DiffSuspense, { children: patches.map((change, index) => (_jsx(UnifiedDiff, { change: change }, index))) })) : changes.length > 0 ? (_jsx(DiffSuspense, { children: changes.map((change, index) => (_jsx(EditDiff, { change: change }, index))) })) : (_jsx("pre", { className: "max-h-64 overflow-auto px-3 py-2 font-mono text-code text-text-muted select-text", children: clip(JSON.stringify(tool.input, null, 2) ?? '') })), tool.output !== null && tool.output !== '' && patches.length === 0 && (_jsx("pre", { "data-find-field": "output", className: clsx('max-h-64 overflow-auto whitespace-pre-wrap border-t border-border px-3 py-2 font-mono text-code select-text', tool.state === 'error' ? 'text-chat-removed' : 'text-chat-output'), children: _jsx(AnsiOutput, { text: tool.output, limit: OUTPUT_LIMIT }) }))] }));
+    return (_jsxs("div", { className: "mt-1.5 mb-2 ml-6 overflow-hidden rounded-md border border-border bg-surface-raised", children: [patches.length + changes.length > 0 ? (_jsx(DiffStack, { entries: reviewEntries(patches, changes) })) : (_jsx("pre", { className: "max-h-64 overflow-auto px-3 py-2 font-mono text-code text-text-muted select-text", children: clip(JSON.stringify(tool.input, null, 2) ?? '') })), tool.output !== null && tool.output !== '' && patches.length === 0 && (_jsx("pre", { "data-find-field": "output", className: clsx('max-h-64 overflow-auto whitespace-pre-wrap border-t border-border px-3 py-2 font-mono text-code select-text', tool.state === 'error' ? 'text-chat-removed' : 'text-chat-output'), children: _jsx(AnsiOutput, { text: tool.output, limit: OUTPUT_LIMIT }) }))] }));
 }
 /*
  * One settled tool call: a line, and its input and output behind it. An image the call looked at is
@@ -139,9 +141,13 @@ export function ChangedFilesRow({ tools, diff, checkpoint, baseMoved, chatId, tu
     }
     return _jsx(ProviderChangedFiles, { tools: tools, open: open, setOpen: setOpen, revealNonce: revealNonce });
 }
+function ProviderReviewFiles({ reviews, open, setOpen }) {
+    const { t } = useTranslation('agent-chat');
+    const stack = useReviewStack(reviews.filter(({ path }) => open[path] === true).flatMap(({ reviews }) => reviews));
+    return reviews.map(({ path, count, reviews }) => (_jsx(ChangedFileLine, { path: path, open: open[path] === true, onToggle: () => setOpen((previous) => ({ ...previous, [path]: !previous[path] })), trailing: _jsx("span", { className: "text-text-faint", children: t('work.edits', { count }) }), children: _jsx(ReviewStackView, { entries: reviews, stack: stack }) }, path)));
+}
 /* The fallback card, built from what the CLI itself reported about its edits. */
 function ProviderChangedFiles({ tools, open, setOpen, revealNonce }) {
-    const { t } = useTranslation('agent-chat');
     const byPath = new Map();
     const entryFor = (path) => {
         const existing = byPath.get(path);
@@ -164,7 +170,12 @@ function ProviderChangedFiles({ tools, open, setOpen, revealNonce }) {
             entryFor(change.path || tool.id).edits.push(change);
         }
     }
-    return (_jsx(ChangedFilesCard, { count: byPath.size, revealNonce: revealNonce, children: [...byPath].map(([path, entry]) => (_jsx(ChangedFileLine, { path: path, open: open[path] === true, onToggle: () => setOpen((o) => ({ ...o, [path]: !o[path] })), trailing: _jsx("span", { className: "text-text-faint", children: t('work.edits', { count: entry.edits.length + entry.patches.length }) }), children: _jsxs(DiffSuspense, { children: [entry.patches.map((change, index) => (_jsx(UnifiedDiff, { change: change }, `patch-${index}`))), entry.edits.map((change, index) => (_jsx(EditDiff, { change: change }, `edit-${index}`)))] }) }, path))) }));
+    const reviews = [...byPath].map(([path, entry]) => ({
+        path,
+        count: entry.patches.length + entry.edits.length,
+        reviews: reviewEntries(entry.patches, entry.edits)
+    }));
+    return (_jsx(ChangedFilesCard, { count: byPath.size, revealNonce: revealNonce, children: _jsx(ProviderReviewFiles, { reviews: reviews, open: open, setOpen: setOpen }) }));
 }
 /* "Working for 00:14". */
 export function WorkingRow({ startedAt }) {

package/dist/chat/ui/use-diff-source-tokens.d.ts

@@ -0,0 +1,4 @@
+import { type DiffSourceTokens } from '@adecore/editor-react';
+import type { DiffDocument } from '@adecore/merge';
+import { type DiffSyntaxRuntime } from './diff-syntax.js';
+export declare function useDiffSourceTokens(document: DiffDocument, language: string, theme: string, runtime?: DiffSyntaxRuntime): DiffSourceTokens;

package/dist/chat/ui/use-diff-source-tokens.js

@@ -0,0 +1,40 @@
+import { useLayoutEffect, useMemo } from 'react';
+import { diffSyntaxDocument } from '@adecore/editor-react';
+import { diffSourceTokens } from './diff-syntax.js';
+function createSourceBinding(document, language, theme, runtime) {
+    const mapping = diffSyntaxDocument(document, language, theme);
+    const listeners = new Set();
+    let source;
+    const current = () => {
+        if (source === undefined) {
+            source = diffSourceTokens(document, mapping, runtime);
+            source.subscribe(() => {
+                for (const listener of [...listeners]) {
+                    listener();
+                }
+            });
+        }
+        return source;
+    };
+    return {
+        tokens: {
+            get: (side, index) => (mapping.locate(side, index) === undefined ? null : current().get(side, index)),
+            subscribe(listener) {
+                listeners.add(listener);
+                return () => {
+                    listeners.delete(listener);
+                };
+            }
+        },
+        release() {
+            // StrictMode replays effects with the same memo; the next read opens fresh sessions.
+            source?.dispose();
+            source = undefined;
+        }
+    };
+}
+export function useDiffSourceTokens(document, language, theme, runtime) {
+    const binding = useMemo(() => createSourceBinding(document, language, theme, runtime), [document, language, theme, runtime]);
+    useLayoutEffect(() => () => binding.release(), [binding]);
+    return binding.tokens;
+}

package/dist/host.d.ts

@@ -1,7 +1,8 @@
 import type { ComponentProps, ComponentType, ReactNode, RefObject } from 'react';
 import type { Extension } from '@codemirror/state';
 import type { EditorView } from '@codemirror/view';
-import type { ThemeRegistration } from 'shiki';
+import type { Highlighter, ThemeRegistration } from 'shiki';
+import type { EditorEngine } from '@adecore/editor';
 import type { AgentKind, ChatCheckpointDiff, ChatConfigurePayload, ChatItem, ChatSubagentItem, ChatUiChoicePayload, ChatUiQueryPayload, ChatUiQueryReading, ChatUiLinkPayload, ChatUiLinkReading } from '@adecore/agent-contracts';
 import type { TimelineRow } from './chat/logic/timeline.js';
 import type { FindReveal } from './chat/ui/find-reveal.js';
@@ -163,6 +164,10 @@ export interface ChatHost {
         custom: ReadonlyArray<ThemeRegistration & {
             name: string;
         }>;
+        syntaxWorker?: () => Worker;
+        legacyDiffWorker?: () => Worker;
+        highlighter?: () => Promise<Highlighter>;
+        editor?: () => Promise<EditorEngine>;
     };
     useStreaming(): 'words' | 'blocks' | 'whole';
     useSendDelivery(): 'queue' | 'steer';

package/dist/lazy.d.ts

@@ -2,5 +2,7 @@ import { type ComponentProps, type ComponentType } from 'react';
 type Loader = () => Promise<unknown>;
 export declare function setLazyPrefetch(next: (load: Loader) => void): void;
 export declare function onLazyOpenError(listener: (error: unknown) => void): () => void;
-export declare function lazyNamed<Module extends Record<Name, ComponentType<any>>, Name extends keyof Module>(load: () => Promise<Module>, name: Name): ComponentType<ComponentProps<Module[Name]>>;
+export declare function lazyNamed<Module extends Record<Name, ComponentType<any>>, Name extends keyof Module>(load: () => Promise<Module>, name: Name, options?: {
+    readonly prefetch?: boolean;
+}): ComponentType<ComponentProps<Module[Name]>>;
 export {};

package/dist/lazy.js

@@ -28,15 +28,17 @@ export function onLazyOpenError(listener) {
  * is here the component is drawn straight away, since `React.lazy` suspends for a tick even on a
  * module the prefetcher already fetched.
  */
-export function lazyNamed(load, name) {
+export function lazyNamed(load, name, options) {
     let loaded = null;
     const open = async () => {
         const component = (await load())[name];
         loaded ??= component;
         return component;
     };
-    loaders.push(open);
-    register?.(open);
+    if (options?.prefetch !== false) {
+        loaders.push(open);
+        register?.(open);
+    }
     // Only a render loads through here; a prefetch calls `open` itself, so its failures report nothing.
     const Lazy = lazy(async () => {
         try {