@codingame/monaco-vscode-katex-common 30.0.0 → 31.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatContentParts.d.ts

@@ -1,7 +1,6 @@
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ChatTreeItem, IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 import { IChatRendererContent, IChatRequestViewModel, IChatResponseViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel";
-import { CodeBlockModelCollection } from "../../../common/widget/codeBlockModelCollection.js";
 import { DiffEditorPool, EditorPool } from "./chatContentCodePools.js";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
@@ -16,7 +15,7 @@ export interface IChatContentPart extends IDisposable {
      */
     codeblocksPartId?: string;
     /**
-     * Codeblocks that were rendered by this part into CodeBlockModelCollection.
+     * Codeblocks that were rendered by this part.
      */
     codeblocks?: IChatCodeBlockInfo[];
     /**
@@ -42,7 +41,6 @@ export interface IChatContentPartRenderContext {
     readonly codeBlockStartIndex: number;
     readonly treeStartIndex: number;
     readonly diffEditorPool: DiffEditorPool;
-    readonly codeBlockModelCollection: CodeBlockModelCollection;
     readonly currentWidth: IObservable<number>;
     readonly onDidChangeVisibility: Event<boolean>;
     readonly inlineTextModels: InlineTextModelCollection;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatDiffBlockPart.js

@@ -1,8 +1,8 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { hashAsync } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
-import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
@@ -76,17 +76,46 @@ let MarkdownDiffBlockPart = class MarkdownDiffBlockPart extends Disposable {
             path: `/chat-diff-modified-${data.codeBlockIndex}-${generateUuid()}`
         }));
         const languageSelection = this.languageService.createById(data.languageId);
-        this._register(
-            this.modelService.createModel(data.beforeContent, languageSelection, originalUri, false)
-        );
-        this._register(
-            this.modelService.createModel(data.afterContent, languageSelection, modifiedUri, false)
-        );
+        const originalModel = this.modelService.createModel(data.beforeContent, languageSelection, originalUri, false);
+        const modifiedModel = this.modelService.createModel(data.afterContent, languageSelection, modifiedUri, false);
+        const cts = ( new CancellationTokenSource());
+        let referencesSettled = false;
+        let disposeRequested = false;
+        let didDisposeModels = false;
+        const disposeModels = () => {
+            if (didDisposeModels) {
+                return;
+            }
+            didDisposeModels = true;
+            originalModel.dispose();
+            modifiedModel.dispose();
+        };
+        this._register(toDisposable(() => {
+            disposeRequested = true;
+            cts.dispose(true);
+            if (referencesSettled) {
+                disposeModels();
+            }
+        }));
         const modelsPromise = Promise.all([
             this.textModelService.createModelReference(originalUri),
             this.textModelService.createModelReference(modifiedUri)
         ]).then(([originalRef, modifiedRef]) => {
-            return ( new SimpleDiffEditorModel(originalRef, modifiedRef));
+            referencesSettled = true;
+            const model = ( new SimpleDiffEditorModel(originalRef, modifiedRef));
+            if (disposeRequested) {
+                model.dispose();
+                disposeModels();
+                return undefined;
+            }
+            return model;
+        }, error => {
+            referencesSettled = true;
+            disposeModels();
+            if (disposeRequested) {
+                return undefined;
+            }
+            throw error;
         });
         const compareData = {
             element: data.element,
@@ -99,6 +128,9 @@ let MarkdownDiffBlockPart = class MarkdownDiffBlockPart extends Disposable {
                 done: true
             },
             diffData: modelsPromise.then(async model => {
+                if (!model) {
+                    return undefined;
+                }
                 this.modelRef.value = model;
                 const diffData = {
                     original: model.original,
@@ -108,7 +140,7 @@ let MarkdownDiffBlockPart = class MarkdownDiffBlockPart extends Disposable {
                 return diffData;
             })
         };
-        this.comparePart.object.render(compareData, currentWidth, CancellationToken.None);
+        this.comparePart.object.render(compareData, currentWidth, cts.token);
         this.element = this.comparePart.object.element;
     }
     layout(width) {

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatDisabledClaudeHooksContentPart.js

@@ -24,13 +24,13 @@ let ChatDisabledClaudeHooksContentPart = class ChatDisabledClaudeHooksContentPar
         const icon = $(".chat-disabled-claude-hooks-icon");
         icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.info));
         const enableLink = createMarkdownCommandLink({
-            text: ( localize(6726, "Enable")),
+            text: ( localize(6812, "Enable")),
             id: "workbench.action.openSettings",
             arguments: [PromptsConfig.USE_CLAUDE_HOOKS],
-            tooltip: ( localize(6727, "Open settings to enable Claude Code hooks"))
+            tooltip: ( localize(6813, "Open settings to enable Claude Code hooks"))
         });
         const message = ( localize(
-            6728,
+            6814,
             "Claude Code hooks are available for this workspace. {0}",
             enableLink
         ));

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatExtensionsContentPart.js

@@ -30,7 +30,7 @@ let ChatExtensionsContentPart = class ChatExtensionsContentPart extends Disposab
         append(
             loadingElement,
             $(ThemeIcon.asCSSSelector(ThemeIcon.modify(Codicon.loading, "spin"))),
-            $("span.loading-message", undefined, ( localize(6729, "Loading extensions...")))
+            $("span.loading-message", undefined, ( localize(6815, "Loading extensions...")))
         );
         const extensionsList = append(this.domNode, $(".extensions-list"));
         const list = this._register(

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatHookContentPart.js

@@ -20,7 +20,7 @@ let ChatHookContentPart = class ChatHookContentPart extends ChatCollapsibleConte
         const isStopped = !!hookPart.stopReason;
         const isWarning = !!hookPart.systemMessage;
         const toolName = hookPart.toolDisplayName;
-        const title = isStopped ? (toolName ? ( localize(6730, "Blocked {0} - {1} hook", toolName, hookTypeLabel)) : ( localize(6731, "Blocked by {0} hook", hookTypeLabel))) : (toolName ? ( localize(6732, "Warning for {0} - {1} hook", toolName, hookTypeLabel)) : ( localize(6733, "Warning from {0} hook", hookTypeLabel)));
+        const title = isStopped ? (toolName ? ( localize(6816, "Blocked {0} - {1} hook", toolName, hookTypeLabel)) : ( localize(6817, "Blocked by {0} hook", hookTypeLabel))) : (toolName ? ( localize(6818, "Warning for {0} - {1} hook", toolName, hookTypeLabel)) : ( localize(6819, "Warning from {0} hook", hookTypeLabel)));
         super(title, context, undefined, hoverService, configurationService);
         this.hookPart = hookPart;
         this.icon = isStopped ? Codicon.error : isWarning ? Codicon.warning : Codicon.check;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/animations/animation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Animation strategy for incremental rendering. Applied as a post-processing
+ * decoration after the markdown has been correctly rendered.
+ *
+ * Animation is separate from buffering — it controls *how* rendered
+ * content appears, while buffering controls *when* we render.
+ */
+export interface IIncrementalRenderingAnimation {
+    /**
+     * Apply entrance animation to newly appeared DOM children.
+     *
+     * @param children The live HTMLCollection of the container's children.
+     * @param fromIndex Index of the first new child to animate.
+     * @param currentCount Total number of children currently in the DOM.
+     * @param elapsed Milliseconds since the animation batch started.
+     */
+    animate(children: HTMLCollection, fromIndex: number, currentCount: number, elapsed: number): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/animations/animationRegistry.d.ts

@@ -0,0 +1,15 @@
+import { IIncrementalRenderingAnimation } from "./animation.js";
+/**
+ * Registry of all available animation styles.
+ * To add a new animation, add an entry here.
+ */
+export declare const ANIMATION_STYLES: {
+    readonly none: () => IIncrementalRenderingAnimation;
+    readonly fade: () => IIncrementalRenderingAnimation;
+    readonly rise: () => IIncrementalRenderingAnimation;
+    readonly blur: () => IIncrementalRenderingAnimation;
+    readonly scale: () => IIncrementalRenderingAnimation;
+    readonly slide: () => IIncrementalRenderingAnimation;
+    readonly reveal: () => IIncrementalRenderingAnimation;
+};
+export type AnimationStyleName = keyof typeof ANIMATION_STYLES;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/animations/animationRegistry.js

@@ -0,0 +1,16 @@
+
+import { BlockAnimation } from './blockAnimations.js';
+
+const ANIMATION_STYLES = {
+    none: () => ({
+        animate() {}
+    }),
+    fade: () => ( new BlockAnimation("fade")),
+    rise: () => ( new BlockAnimation("rise")),
+    blur: () => ( new BlockAnimation("blur")),
+    scale: () => ( new BlockAnimation("scale")),
+    slide: () => ( new BlockAnimation("slide")),
+    reveal: () => ( new BlockAnimation("reveal"))
+};
+
+export { ANIMATION_STYLES };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/animations/blockAnimations.d.ts

@@ -0,0 +1,13 @@
+import { IIncrementalRenderingAnimation } from "./animation.js";
+/** Duration of the animation applied to newly rendered blocks. */
+export declare const ANIMATION_DURATION_MS = 600;
+/**
+ * Block-level CSS animation styles: fade, rise, blur, scale, slide,
+ * and lineFade. Each applies a CSS class and staggered timing
+ * variables to new top-level children so they reveal sequentially.
+ */
+export declare class BlockAnimation implements IIncrementalRenderingAnimation {
+    private readonly _style;
+    constructor(_style: "fade" | "rise" | "blur" | "scale" | "slide" | "reveal");
+    animate(children: HTMLCollection, fromIndex: number, currentCount: number, elapsed: number): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/animations/blockAnimations.js

@@ -0,0 +1,33 @@
+
+
+const ANIMATION_DURATION_MS = 600;
+const STAGGER_DELAY_MS = 150;
+class BlockAnimation {
+    constructor(_style) {
+        this._style = _style;
+    }
+    animate(children, fromIndex, currentCount, elapsed) {
+        const className = `chat-smooth-animate-${this._style}`;
+        for (let i = fromIndex; i < currentCount; i++) {
+            const child = children[i];
+            if (!child.classList) {
+                continue;
+            }
+            const staggerOffset = (i - fromIndex) * STAGGER_DELAY_MS;
+            const childDelay = -elapsed + staggerOffset;
+            child.classList.add(className);
+            child.style.setProperty('--chat-smooth-duration', `${ANIMATION_DURATION_MS}ms`);
+            child.style.setProperty('--chat-smooth-delay', `${childDelay}ms`);
+            child.addEventListener('animationend', (e) => {
+                if (e.target !== child) {
+                    return;
+                }
+                child.classList.remove(className);
+                child.style.removeProperty('--chat-smooth-duration');
+                child.style.removeProperty('--chat-smooth-delay');
+            }, { once: true });
+        }
+    }
+}
+
+export { ANIMATION_DURATION_MS, BlockAnimation };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/buffer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A buffering strategy determines how much incoming markdown content
+ * must accumulate before a render is triggered.
+ *
+ * Buffering is separate from animation — it controls *when* we render,
+ * while animation controls *how* rendered content appears.
+ */
+export interface IIncrementalRenderingBuffer {
+    /**
+     * Given the full markdown string and the markdown that was last
+     * rendered to the real DOM, return `true` if the buffer should
+     * be handled entirely within _flushRender (e.g. shadow measurement).
+     * In that case the orchestrator should pass everything through
+     * without updating `_renderedMarkdown`.
+     */
+    readonly handlesFlush: boolean;
+    /**
+     * Determine the renderable prefix of `fullMarkdown`. The returned
+     * string must be a prefix of `fullMarkdown` (or `fullMarkdown`
+     * itself). Content beyond the returned prefix stays buffered.
+     *
+     * @param fullMarkdown The complete markdown accumulated so far.
+     * @param lastRendered The markdown last rendered to the DOM.
+     * @returns The prefix to render now.
+     */
+    getRenderable(fullMarkdown: string, lastRendered: string): string;
+    /**
+     * For buffers that handle flushing themselves (e.g. line buffer
+     * with shadow DOM measurement), this is called during
+     * `_flushRender` to decide whether to commit the pending content.
+     *
+     * @param markdown The pending markdown to potentially commit.
+     * @returns The markdown to actually commit, or `undefined` to skip.
+     */
+    filterFlush?(markdown: string): string | undefined;
+    /**
+     * Whether the buffer needs another rAF frame to continue revealing
+     * content (e.g. typewriter drip-feeding words). When `true`, the
+     * orchestrator re-schedules a render after the current flush.
+     */
+    readonly needsNextFrame?: boolean;
+    /**
+     * Called when the buffer is no longer needed.
+     */
+    dispose?(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/bufferRegistry.d.ts

@@ -0,0 +1,11 @@
+import { IIncrementalRenderingBuffer } from "./buffer.js";
+/**
+ * Registry of all available buffering strategies.
+ * To add a new buffer, add an entry here.
+ */
+export declare const BUFFER_MODES: {
+    readonly off: (_domNode: HTMLElement) => IIncrementalRenderingBuffer;
+    readonly word: (_domNode: HTMLElement) => IIncrementalRenderingBuffer;
+    readonly paragraph: (_domNode: HTMLElement) => IIncrementalRenderingBuffer;
+};
+export type BufferModeName = keyof typeof BUFFER_MODES;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/bufferRegistry.js

@@ -0,0 +1,12 @@
+
+import { OffBuffer } from './offBuffer.js';
+import { ParagraphBuffer } from './paragraphBuffer.js';
+import { WordBuffer } from './wordBuffer.js';
+
+const BUFFER_MODES = {
+    off: _domNode => ( new OffBuffer()),
+    word: _domNode => ( new WordBuffer()),
+    paragraph: _domNode => ( new ParagraphBuffer())
+};
+
+export { BUFFER_MODES };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/offBuffer.d.ts

@@ -0,0 +1,9 @@
+import { IIncrementalRenderingBuffer } from "./buffer.js";
+/**
+ * No buffering — renders everything immediately as tokens arrive.
+ * Content is still rAF-coalesced by the orchestrator.
+ */
+export declare class OffBuffer implements IIncrementalRenderingBuffer {
+    readonly handlesFlush = false;
+    getRenderable(fullMarkdown: string, _lastRendered: string): string;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/offBuffer.js

@@ -0,0 +1,12 @@
+
+
+class OffBuffer {
+    constructor() {
+        this.handlesFlush = false;
+    }
+    getRenderable(fullMarkdown, _lastRendered) {
+        return fullMarkdown;
+    }
+}
+
+export { OffBuffer };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/paragraphBuffer.d.ts

@@ -0,0 +1,23 @@
+import { IIncrementalRenderingBuffer } from "./buffer.js";
+/**
+ * Finds the last `\n\n` block boundary that is NOT inside an open
+ * fenced code block. This prevents splitting a render in the middle
+ * of a code fence, which would cause the code block element to update
+ * in place (same DOM index) without triggering a new-child animation.
+ *
+ * The scan counts backtick-fence openings/closings from the start of
+ * the string. A `\n\n` is only a valid boundary when the fence depth
+ * is 0 (i.e. outside any code block).
+ *
+ * @internal Exported for testing.
+ */
+export declare function lastBlockBoundary(text: string): number;
+/**
+ * Buffers content at paragraph boundaries (`\n\n` outside code fences).
+ * This avoids rendering partially formed blocks — text mid-paragraph,
+ * incomplete list groups, or half a code fence.
+ */
+export declare class ParagraphBuffer implements IIncrementalRenderingBuffer {
+    readonly handlesFlush = false;
+    getRenderable(fullMarkdown: string, lastRendered: string): string;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/paragraphBuffer.js

@@ -0,0 +1,37 @@
+
+
+const MAX_BUFFERED_CHARS = 4000;
+function lastBlockBoundary(text) {
+    let lastValid = -1;
+    let inFence = false;
+    for (let i = 0; i < text.length; i++) {
+        if ((i === 0 || text[i - 1] === '\n') &&
+            ((text[i] === '`' && text[i + 1] === '`' && text[i + 2] === '`') ||
+                (text[i] === '~' && text[i + 1] === '~' && text[i + 2] === '~'))) {
+            inFence = !inFence;
+            i += 2;
+            continue;
+        }
+        if (!inFence && text[i] === '\n' && text[i + 1] === '\n') {
+            lastValid = i;
+        }
+    }
+    return lastValid;
+}
+class ParagraphBuffer {
+    constructor() {
+        this.handlesFlush = false;
+    }
+    getRenderable(fullMarkdown, lastRendered) {
+        const lastBlock = lastBlockBoundary(fullMarkdown);
+        let renderable = lastBlock === -1
+            ? lastRendered
+            : fullMarkdown.slice(0, lastBlock + 2);
+        if (fullMarkdown.length - renderable.length > MAX_BUFFERED_CHARS) {
+            renderable = fullMarkdown;
+        }
+        return renderable;
+    }
+}
+
+export { ParagraphBuffer, lastBlockBoundary };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/wordBuffer.d.ts

@@ -0,0 +1,34 @@
+import { IIncrementalRenderingBuffer } from "./buffer.js";
+/**
+ * Word buffer: drip-feeds words at a rate matching the model's
+ * token production speed, similar to the original 50ms progressive
+ * render but driven by rAF for smoother output.
+ *
+ * The reveal rate is set externally via {@link setRate} from the
+ * model's `impliedWordLoadRate` estimate. Words are revealed based
+ * on elapsed time since the last render, so the output speed
+ * naturally matches the model's generation speed.
+ */
+export declare class WordBuffer implements IIncrementalRenderingBuffer {
+    readonly handlesFlush = true;
+    /** The full markdown received so far. */
+    private _fullMarkdown;
+    /** Number of words currently revealed to the DOM. */
+    private _revealedWordCount;
+    /** The markdown string last committed to the DOM. */
+    private _lastCommittedMarkdown;
+    /** Whether there are still unrevealed words to show. */
+    private _needsNextFrame;
+    /** Timestamp of the last successful commit. */
+    private _lastCommitTime;
+    /** Estimated word production rate (words/sec). */
+    private _rate;
+    get needsNextFrame(): boolean;
+    /**
+     * Set the estimated word production rate from the model's
+     * `impliedWordLoadRate`. Called by the orchestrator.
+     */
+    setRate(rate: number | undefined, isComplete: boolean): void;
+    getRenderable(fullMarkdown: string, _lastRendered: string): string;
+    filterFlush(markdown: string): string | undefined;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/buffers/wordBuffer.js

@@ -0,0 +1,68 @@
+
+import { getNWords } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatWordCounter';
+
+const MIN_RATE = 40;
+const MAX_RATE = 2000;
+const MIN_RATE_AFTER_COMPLETE = 80;
+const DEFAULT_RATE = 8;
+class WordBuffer {
+    constructor() {
+        this.handlesFlush = true;
+        this._fullMarkdown = '';
+        this._revealedWordCount = 0;
+        this._lastCommittedMarkdown = '';
+        this._needsNextFrame = false;
+        this._lastCommitTime = 0;
+        this._rate = DEFAULT_RATE;
+    }
+    get needsNextFrame() {
+        return this._needsNextFrame;
+    }
+    setRate(rate, isComplete) {
+        if (isComplete) {
+            this._rate = typeof rate === 'number'
+                ? Math.max(rate, MIN_RATE_AFTER_COMPLETE)
+                : MIN_RATE_AFTER_COMPLETE;
+        }
+        else {
+            this._rate = typeof rate === 'number'
+                ? Math.min(Math.max(rate, MIN_RATE), MAX_RATE)
+                : DEFAULT_RATE;
+        }
+    }
+    getRenderable(fullMarkdown, _lastRendered) {
+        this._fullMarkdown = fullMarkdown;
+        return fullMarkdown;
+    }
+    filterFlush(markdown) {
+        this._fullMarkdown = markdown;
+        const now = Date.now();
+        if (this._lastCommitTime === 0) {
+            this._lastCommitTime = now;
+            this._revealedWordCount = 1;
+        }
+        else {
+            const elapsed = now - this._lastCommitTime;
+            const newWords = Math.floor(elapsed / 1000 * this._rate);
+            if (newWords > 0) {
+                this._revealedWordCount += newWords;
+                this._lastCommitTime = now;
+            }
+        }
+        const result = getNWords(this._fullMarkdown, this._revealedWordCount);
+        if (result.isFullString) {
+            this._needsNextFrame = false;
+            this._revealedWordCount = result.returnedWordCount;
+            this._lastCommittedMarkdown = this._fullMarkdown;
+            return this._fullMarkdown;
+        }
+        this._needsNextFrame = true;
+        if (result.value.length <= this._lastCommittedMarkdown.length) {
+            return undefined;
+        }
+        this._lastCommittedMarkdown = result.value;
+        return result.value;
+    }
+}
+
+export { WordBuffer };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatIncrementalRendering/chatIncrementalRendering.d.ts

@@ -0,0 +1,77 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+/**
+ * Incremental markdown streaming renderer — rAF-batched, append-only.
+ *
+ * Orchestrates two independent concerns:
+ * - **Buffering** (when to render): controlled by an {@link IIncrementalRenderingBuffer}.
+ * - **Animation** (how it appears): controlled by an {@link IIncrementalRenderingAnimation}.
+ *
+ * The renderer works *with* the existing markdown rendering pipeline.
+ * Each update re-renders through the standard `doRenderMarkdown()` path,
+ * so code blocks, tables, KaTeX, and all markdown features render correctly.
+ *
+ * If the new markdown is NOT a pure append, `tryMorph()` returns `false`
+ * and the caller falls back to a full re-render.
+ */
+export declare class IncrementalDOMMorpher extends Disposable {
+    private readonly _domNode;
+    private readonly _configService;
+    private _lastMarkdown;
+    /**
+     * The markdown that was last rendered to the DOM. May lag behind
+     * `_lastMarkdown` while content is being buffered.
+     */
+    private _renderedMarkdown;
+    /**
+     * High-water mark: the number of top-level children that have been
+     * fully revealed. Children at indices >= this value are "new"
+     * and get animated on each render.
+     */
+    private _revealedChildCount;
+    /**
+     * Timestamp when children at indices >= `_revealedChildCount`
+     * first appeared. 0 means no animation is in progress.
+     */
+    private _animationStartTime;
+    /**
+     * The total child count at the end of the most recent render in
+     * the current animation batch.
+     */
+    private _batchChildCount;
+    private _rafScheduled;
+    private _pendingMarkdown;
+    private _rafHandle;
+    private _renderCallback;
+    private _buffer;
+    private _animation;
+    constructor(_domNode: HTMLElement, _configService: IConfigurationService);
+    private _createBuffer;
+    private _createAnimation;
+    /**
+     * Register the callback that performs the actual markdown re-render.
+     */
+    setRenderCallback(cb: (newMarkdown: string) => void): void;
+    /**
+     * Forward the stream's word-rate estimate to the active buffer
+     * (word buffer or line buffer).
+     */
+    updateStreamRate(rate: number, isComplete: boolean): void;
+    /**
+     * Seeds the renderer with the initial markdown string.
+     *
+     * @param animateInitial When `true`, the children already in the
+     *   DOM receive the entrance animation.
+     */
+    seed(markdown: string, animateInitial?: boolean): void;
+    /**
+     * Attempts an incremental DOM update via rAF-batched re-render.
+     *
+     * @returns `true` if absorbed, `false` if a full re-render is needed.
+     */
+    tryMorph(newMarkdown: string): boolean;
+    private _scheduleRender;
+    private _flushRender;
+    private _animateNewChildren;
+    dispose(): void;
+}