@openclaw/diffs 2026.9.4 → 2026.9.6

package/node_modules/@pierre/diffs/dist/renderers/FileRenderer.d.ts

@@ -1,8 +1,11 @@
 import { Element, ElementContent } from "../node_modules/.pnpm/@types_hast@3.0.4/node_modules/@types/hast/index.js";
-import { BaseCodeOptions, DiffsHighlighter, DiffsTextDocument, FileContents, FileHeaderRenderMode, HighlightedToken, LineAnnotation, RenderFileOptions, RenderRange, ThemedFileResult } from "../types.js";
+import { BaseCodeOptions, DiffsHighlighter, FileContents, FileHeaderRenderMode, HighlightedToken, LineAnnotation, RenderFileOptions, RenderRange, ThemedFileResult } from "../types.js";
+import { TextDocument } from "../editor/textDocument.js";
 import { WorkerPoolManager } from "../worker/WorkerPoolManager.js";
+import "../worker/index.js";
 //#region src/renderers/FileRenderer.d.ts
 interface FileRenderResult {
+  file: FileContents;
   gutterAST: ElementContent[];
   contentAST: ElementContent[];
   preAST: Element;
@@ -20,18 +23,22 @@ interface FileRendererOptions extends BaseCodeOptions {
 }
 declare class FileRenderer<LAnnotation = undefined> {
   options: FileRendererOptions;
+  private annotationSlotName;
   private onRenderUpdate?;
   private workerManager?;
   readonly __id: string;
   private highlighter;
+  private file;
   private renderCache;
+  private pendingHighlightResult;
   private computedLang;
   private lineAnnotations;
   private lineCache;
   private pendingStructuralRows;
   private textDocumentCache;
   private editSessionActive;
-  constructor(options?: FileRendererOptions, onRenderUpdate?: (() => unknown) | undefined, workerManager?: WorkerPoolManager | undefined);
+  get fileCache(): FileContents | undefined;
+  constructor(options?: FileRendererOptions, annotationSlotName?: (annotation: LineAnnotation<LAnnotation>) => string, onRenderUpdate?: (() => unknown) | undefined, workerManager?: WorkerPoolManager | undefined);
   setOptions(options: FileRendererOptions): void;
   mergeOptions(options: Partial<FileRendererOptions>): void;
   setLineAnnotations(lineAnnotations: LineAnnotation<LAnnotation>[]): void;
@@ -39,29 +46,38 @@ declare class FileRenderer<LAnnotation = undefined> {
   /**
    * Enter edit-session mode: rendering happens locally with the token
    * transformer forced on, and worker-pool requests/results are suspended
-   * for this renderer. Called on every editor attach, including a re-attach
-   * after recycle.
+   * for this renderer. Called on initial editor association and whenever its
+   * rendering resumes after recycle.
    */
-  beginEditSession(): void;
-  /** Leave edit-session mode. Rendering returns to the pool when one works. */
-  endEditSession(): void;
+  beginEditSession(file: FileContents, externalFile?: FileContents): void;
+  /**
+   * Leave edit-session mode. Rendering returns to the pool when one works.
+   * When `settledFile` has the content the cache already shows, the cache
+   * adopts it as its identity so the next render treats it as current
+   * instead of a new file.
+   */
+  endEditSession(settledFile?: FileContents): void;
   /**
    * Ensures that the DOM is compatible with editor render updates
    */
   editorRenderReady(): boolean;
   recycle(): void;
-  private syncEditedContentsToFile;
-  hasUnkeyedFileContentsChanged(file: FileContents): boolean;
-  private invalidateChangedUnkeyedFile;
   clearRenderCache(): void;
   hydrate(file: FileContents): void;
   private getLocalHighlightTheme;
   getEffectiveCodeOptions(): Pick<BaseCodeOptions, 'theme' | 'tokenizeMaxLineLength'>;
   private getRenderOptions;
+  /**
+   * Returns the file that the next synchronous render can commit without
+   * changing the current render cache. Virtualized layouts use this to stay
+   * aligned with the DOM while a replacement highlight is still pending.
+   */
+  getFileForNextRender(file: FileContents): FileContents;
+  private canRenderFile;
   getOrCreateLineCache(file: FileContents): string[];
   getLineCount(file: FileContents): number;
   updateRenderCache(dirtyLines: Map<number, Array<HighlightedToken>>, themeType: 'dark' | 'light', lineCountChangeInFlight?: boolean): void;
-  applyDocumentChange(textDocument: DiffsTextDocument): void;
+  applyDocumentChange(textDocument: TextDocument<'file', LAnnotation>): void;
   renderFile(file?: FileContents | undefined, renderRange?: RenderRange): FileRenderResult | undefined;
   asyncRender(file: FileContents, renderRange?: RenderRange): Promise<FileRenderResult>;
   private asyncHighlight;
@@ -76,6 +92,7 @@ declare class FileRenderer<LAnnotation = undefined> {
   onHighlightSuccess(file: FileContents, result: ThemedFileResult, options: RenderFileOptions, highlighted?: boolean): void;
   private applyHighlightResult;
   private getMatchingWorkerResultCache;
+  private getReadyRenderResult;
   private hasHighlightedRenderCache;
   onHighlightError(error: unknown): void;
   private getTokenizeMaxLength;

package/node_modules/@pierre/diffs/dist/renderers/FileRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileRenderer.d.ts","names":[],"sources":["../../src/renderers/FileRenderer.ts"],"mappings":";;;;UAqEiB,gBAAA;EACf,SAAA,EAAW,cAAA;EACX,UAAA,EAAY,cAAA;EACZ,MAAA,EAAQ,OAAA;EACR,SAAA,EAAW,OAAA;EACX,GAAA;EACA,UAAA;EACA,WAAA;EACA,aAAA;EACA,QAAA;EACA,YAAA;EACA,WAAA;AAAA;AAAA,UAkBe,mBAAA,SAA4B,eAAe;EAC1D,gBAAA,GAAmB,oBAAA;AAAA;AAAA,cAKR,YAAA;EAmBF,OAAA,EAAS,mBAAA;EAAA,QACR,cAAA;EAAA,QACA,aAAA;EAAA,SApBD,IAAA;EAAA,QAED,WAAA;EAAA,QACA,WAAA;EAAA,QACA,YAAA;EAAA,QACA,eAAA;EAAA,QACA,SAAA;EAAA,QACA,qBAAA;EAAA,QACA,iBAAA;EAAA,QAOA,iBAAA;EAER,WAAA,CACS,OAAA,GAAS,mBAAA,EACR,cAAA,gCACA,aAAA,GAAgB,iBAAA;EASnB,UAAA,CAAW,OAAA,EAAS,mBAAA;EAIpB,YAAA,CAAa,OAAA,EAAS,OAAA,CAAQ,mBAAA;EAI9B,kBAAA,CACL,eAAA,EAAiB,cAAA,CAAe,WAAA;EAU3B,OAAA;EAtDP;;;AAAuC;AAKzC;;EA6DS,gBAAA;EA1CW;EA+CX,cAAA;EA7CmB;;;EAoDnB,iBAAA;EAQA,OAAA;EAAA,QAsBC,wBAAA;EAcD,6BAAA,CAA8B,IAAA,EAAM,YAAA;EAAA,QAUnC,4BAAA;EAQD,gBAAA;EAgBA,OAAA,CAAQ,IAAA,EAAM,YAAA;EAAA,QAmCb,sBAAA;EAQD,uBAAA,IAA2B,IAAA,CAChC,eAAA;EAAA,QAeM,gBAAA;EAkCD,oBAAA,CAAqB,IAAA,EAAM,YAAA;EAiB3B,YAAA,CAAa,IAAA,EAAM,YAAA;EAKnB,iBAAA,CACL,UAAA,EAAY,GAAA,SAAY,KAAA,CAAM,gBAAA,IAC9B,SAAA,oBACA,uBAAA;EA4EK,mBAAA,CAAoB,YAAA,EAAc,iBAAA;EAoGlC,UAAA,CACL,IAAA,GAAM,YAAA,cACN,WAAA,GAAa,WAAA,GACZ,gBAAA;EAoJG,WAAA,CACJ,IAAA,EAAM,YAAA,EACN,WAAA,GAAa,WAAA,GACZ,OAAA,CAAQ,gBAAA;EAAA,QAKG,cAAA;EAAA,QA2BN,yBAAA;EAAA,QAYA,iBAAA;EAAA,QA8FA,YAAA;EASD,cAAA,CAAe,MAAA,EAAQ,gBAAA;EAIvB,aAAA,CACL,MAAA,EAAQ,gBAAA,EACR,QAAA,GAAU,cAAA,KACT,OAAA;EAWI,aAAA,CAAc,MAAA,EAAQ,gBAAA,GAAmB,cAAA;EAWzC,iBAAA,CACL,QAAA,EAAU,cAAA,IACV,eAAA;EAcW,qBAAA,IAAyB,OAAA,CAAQ,gBAAA;EAYvC,kBAAA,CACL,IAAA,EAAM,YAAA,EACN,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,iBAAA,EACT,WAAA;EAAA,QAQM,oBAAA;EAAA,QA2BA,4BAAA;EAAA,QAcA,yBAAA;EAaD,gBAAA,CAAiB,KAAA;EAAA,QAIhB,oBAAA;EAAA,QAIA,gBAAA;AAAA"}
+{"version":3,"file":"FileRenderer.d.ts","names":[],"sources":["../../src/renderers/FileRenderer.ts"],"mappings":";;;;;;UAiFiB;EACf,MAAM;EACN,WAAW;EACX,YAAY;EACZ,QAAQ;EACR,WAAW;EACX;EACA;EACA;EACA;EACA;EACA;EACA;;UAkBe,4BAA4B;EAC3C,mBAAmB;;cAKR,aAAa;EAmCf,SAAS;UACR;UAGA;UACA;WAvCD;UAED;UAIA;UAEA;UAGA;UAEA;UACA;UACA;UACA;UACA;UAUA;MAEG,aAAa;EAIxB,YACS,UAAS,qBACR,sBACN,YAAY,eAAe,yBAErB,8CACA,gBAAgB;EASnB,WAAW,SAAS;EAIpB,aAAa,SAAS,QAAQ;EAI9B,mBACL,iBAAiB,eAAe;EAU3B;;;;;;;EAYA,iBACL,MAAM,cACN,eAAe;;;;;;;EAqEV,eAAe,cAAc;;;;EAkB7B;EAQA;EAgBA;EAMA,QAAQ,MAAM;UAqCb;EAQD,2BAA2B,KAChC;UAeM;;;;;;EAuCD,qBAAqB,MAAM,eAAe;UAyBzC;EAiCD,qBAAqB,MAAM;EAgB3B,aAAa,MAAM;EAKnB,kBACL,YAAY,YAAY,MAAM,oBAC9B,6BACA;EAiFK,oBACL,cAAc,qBAAqB;EAsG9B,WACL,OAAM,0BACN,cAAa,cACZ;EAwIG,YACJ,MAAM,cACN,cAAa,cACZ,QAAQ;UAMG;UA2BN;UAYA;UA+FA;EASD,eAAe,QAAQ;EAIvB,cACL,QAAQ,kBACR,WAAU,mBACT;EAWI,cAAc,QAAQ,mBAAmB;EAWzC,kBACL,UAAU,kBACV;EAcW,yBAAyB,QAAQ;EAYvC,mBACL,MAAM,cACN,QAAQ,kBACR,SAAS,mBACT;UAQM;UAqCA;UAgBA;UAoBA;EAaD,iBAAiB;UAIhB;UAIA"}

package/node_modules/@pierre/diffs/dist/renderers/FileRenderer.js

@@ -1,11 +1,11 @@
 import { DEFAULT_RENDER_RANGE, DEFAULT_THEMES } from "../constants.js";
-import { areFilesEqual } from "../utils/areFilesEqual.js";
-import { getFileAnnotations, shouldRenderFileAnnotations } from "../utils/includesFileAnnotations.js";
-import { createGutterGap, createGutterItem, createGutterWrapper, createHastElement } from "../utils/hast_utils.js";
 import { areLanguagesAttached } from "../highlighter/languages/areLanguagesAttached.js";
-import { getHighlighterIfLoaded, getSharedHighlighter } from "../highlighter/shared_highlighter.js";
 import { getThemes } from "../utils/getThemes.js";
 import { areThemesAttached } from "../highlighter/themes/areThemesAttached.js";
+import { getHighlighterIfLoaded, getSharedHighlighter } from "../highlighter/shared_highlighter.js";
+import { areFileTargetsEqual } from "../utils/areFileTargetsEqual.js";
+import { getFileAnnotations, shouldRenderFileAnnotations } from "../utils/includesFileAnnotations.js";
+import { createGutterGap, createGutterItem, createGutterWrapper, createHastElement } from "../utils/hast_utils.js";
 import { hasResolvedThemes } from "../highlighter/themes/hasResolvedThemes.js";
 import { applyLineTextWithNewline } from "../utils/applyLineTextWithNewline.js";
 import { areFileRenderOptionsEqual } from "../utils/areFileRenderOptionsEqual.js";
@@ -18,6 +18,7 @@ import { createPreElement } from "../utils/createPreElement.js";
 import { getFiletypeFromFileName } from "../utils/getFiletypeFromFileName.js";
 import { getHighlighterOptions } from "../utils/getHighlighterOptions.js";
 import { getLineAnnotationName } from "../utils/getLineAnnotationName.js";
+import { isDefaultRenderRange } from "../utils/isDefaultRenderRange.js";
 import { isFilePlainText } from "../utils/isFilePlainText.js";
 import { renderFileWithHighlighter } from "../utils/renderFileWithHighlighter.js";
 import { toHtml } from "hast-util-to-html";
@@ -28,19 +29,26 @@ function isLineCacheForFile(lineCache, file) {
 let instanceId = -1;
 var FileRenderer = class {
 	options;
+	annotationSlotName;
 	onRenderUpdate;
 	workerManager;
 	__id = `file-renderer:${++instanceId}`;
 	highlighter;
+	file;
 	renderCache;
+	pendingHighlightResult;
 	computedLang = "text";
 	lineAnnotations = {};
 	lineCache;
 	pendingStructuralRows;
 	textDocumentCache = /* @__PURE__ */ new WeakMap();
 	editSessionActive = false;
-	constructor(options = { theme: DEFAULT_THEMES }, onRenderUpdate, workerManager) {
+	get fileCache() {
+		return this.renderCache?.file;
+	}
+	constructor(options = { theme: DEFAULT_THEMES }, annotationSlotName = getLineAnnotationName, onRenderUpdate, workerManager) {
 		this.options = options;
+		this.annotationSlotName = annotationSlotName;
 		this.onRenderUpdate = onRenderUpdate;
 		this.workerManager = workerManager;
 		if (workerManager?.isWorkingPool() !== true) this.highlighter = areThemesAttached(options.theme ?? DEFAULT_THEMES) ? getHighlighterIfLoaded() : void 0;
@@ -70,15 +78,56 @@ var FileRenderer = class {
 	/**
 	* Enter edit-session mode: rendering happens locally with the token
 	* transformer forced on, and worker-pool requests/results are suspended
-	* for this renderer. Called on every editor attach, including a re-attach
-	* after recycle.
+	* for this renderer. Called on initial editor association and whenever its
+	* rendering resumes after recycle.
 	*/
-	beginEditSession() {
+	beginEditSession(file, externalFile) {
+		const { editSessionActive: wasAlreadyActive, renderCache } = this;
 		this.editSessionActive = true;
+		if (!wasAlreadyActive) this.pendingHighlightResult = void 0;
+		this.file = file;
+		if (renderCache == null) return;
+		if (wasAlreadyActive && renderCache.file === file) return;
+		const { options } = this.getRenderOptions(file);
+		const cacheBelongsToSession = renderCache.file === file;
+		const cacheBelongsToExternal = externalFile != null && areFileTargetsEqual(renderCache.file, externalFile);
+		const { result } = renderCache;
+		if (!renderCache.highlighted || result == null || !areFileRenderOptionsEqual(renderCache.options, options) || !cacheBelongsToSession && !cacheBelongsToExternal) {
+			this.clearRenderCache();
+			this.lineCache = void 0;
+			this.textDocumentCache = /* @__PURE__ */ new WeakMap();
+			return;
+		}
+		if (cacheBelongsToSession) return;
+		this.renderCache = {
+			...renderCache,
+			file,
+			result: {
+				...result,
+				code: [...result.code]
+			}
+		};
+		const { lineCache } = this;
+		if (lineCache != null && externalFile != null && isLineCacheForFile(lineCache, externalFile)) this.lineCache = {
+			cacheKey: void 0,
+			file,
+			sourceContents: file.contents,
+			lines: lineCache.lines
+		};
+		else this.lineCache = void 0;
 	}
-	/** Leave edit-session mode. Rendering returns to the pool when one works. */
-	endEditSession() {
+	/**
+	* Leave edit-session mode. Rendering returns to the pool when one works.
+	* When `settledFile` has the content the cache already shows, the cache
+	* adopts it as its identity so the next render treats it as current
+	* instead of a new file.
+	*/
+	endEditSession(settledFile) {
 		this.editSessionActive = false;
+		this.pendingHighlightResult = void 0;
+		const { renderCache } = this;
+		if (settledFile == null || renderCache == null || renderCache.file === settledFile || !areFileTargetsEqual(renderCache.file, settledFile)) return;
+		renderCache.file = settledFile;
 	}
 	/**
 	* Ensures that the DOM is compatible with editor render updates
@@ -91,39 +140,24 @@ var FileRenderer = class {
 		this.highlighter = void 0;
 		this.workerManager?.cleanUpTasks(this);
 		this.lineCache = void 0;
+		this.file = void 0;
 		this.endEditSession();
 		this.textDocumentCache = /* @__PURE__ */ new WeakMap();
 	}
-	syncEditedContentsToFile() {
-		const { renderCache, lineCache } = this;
-		if (renderCache?.isDirty !== true || lineCache == null || !isLineCacheForFile(lineCache, renderCache.file)) return;
-		renderCache.file.contents = lineCache.lines.join("");
-	}
-	hasUnkeyedFileContentsChanged(file) {
-		const { lineCache } = this;
-		return file.cacheKey == null && lineCache != null && lineCache.file === file && lineCache.sourceContents !== file.contents;
-	}
-	invalidateChangedUnkeyedFile(file) {
-		if (!this.hasUnkeyedFileContentsChanged(file)) return;
-		this.workerManager?.cleanUpTasks(this);
-		this.clearRenderCache();
-		this.lineCache = void 0;
-		this.textDocumentCache = /* @__PURE__ */ new WeakMap();
-	}
 	clearRenderCache() {
-		this.syncEditedContentsToFile();
 		this.pendingStructuralRows = void 0;
-		const renderCache = this.renderCache;
 		this.renderCache = void 0;
-		if (renderCache != null && renderCache.isDirty === true && renderCache.file.cacheKey != null) this.workerManager?.evictFileFromCache(renderCache.file.cacheKey);
+		this.pendingHighlightResult = void 0;
 	}
 	hydrate(file) {
+		this.file = file;
 		const { options } = this.getRenderOptions(file);
 		const massiveFile = isFileMassive(this.getOrCreateLineCache(file).length, this.getTokenizeMaxLength());
 		let cache = this.workerManager?.getFileResultCache(file);
 		if (cache != null && !areFileRenderOptionsEqual(options, cache.options)) cache = void 0;
 		this.renderCache ??= {
 			file,
+			hydrated: true,
 			options,
 			highlighted: !massiveFile && !isFilePlainText(file),
 			result: massiveFile ? void 0 : cache?.result,
@@ -168,7 +202,7 @@ var FileRenderer = class {
 			options,
 			forceHighlight: true
 		};
-		if (!areFilesEqual(file, renderCache.file) || !areFileRenderOptionsEqual(options, renderCache.options)) return {
+		if (!areFileTargetsEqual(file, renderCache.file) || !areFileRenderOptionsEqual(options, renderCache.options)) return {
 			options,
 			forceHighlight: true
 		};
@@ -177,8 +211,30 @@ var FileRenderer = class {
 			forceHighlight: false
 		};
 	}
+	/**
+	* Returns the file that the next synchronous render can commit without
+	* changing the current render cache. Virtualized layouts use this to stay
+	* aligned with the DOM while a replacement highlight is still pending.
+	*/
+	getFileForNextRender(file) {
+		const { options } = this.getRenderOptions(file);
+		if (this.getReadyRenderResult(file, options) != null) return file;
+		const { renderCache } = this;
+		if (renderCache == null) return file;
+		if (areFileTargetsEqual(renderCache.file, file)) return renderCache.file;
+		const lines = linesFromFileContents(file.contents);
+		const forcePlainText = file.contents.length === 0 || isFilePlainText(file) || isFileMassive(lines.length, this.getTokenizeMaxLength());
+		return this.canRenderFile(file, options, forcePlainText) ? file : renderCache.file;
+	}
+	canRenderFile(file, options, forcePlainText) {
+		const { renderCache } = this;
+		if (renderCache == null || areFileTargetsEqual(renderCache.file, file)) return true;
+		if (forcePlainText) return renderCache.result == null && renderCache.hydrated !== true || this.workerManager?.isWorkingPool() === true || this.highlighter != null && areThemesAttached(options.theme);
+		if (renderCache.result == null && renderCache.hydrated !== true) return true;
+		if (!this.editSessionActive && this.workerManager?.isWorkingPool() === true) return !renderCache.highlighted;
+		return this.highlighter != null && areThemesAttached(options.theme);
+	}
 	getOrCreateLineCache(file) {
-		this.invalidateChangedUnkeyedFile(file);
 		let { lineCache } = this;
 		if (lineCache == null || !isLineCacheForFile(lineCache, file)) lineCache = {
 			cacheKey: file.cacheKey,
@@ -195,14 +251,15 @@ var FileRenderer = class {
 	}
 	updateRenderCache(dirtyLines, themeType, lineCountChangeInFlight = false) {
 		this.pendingStructuralRows = void 0;
-		if (this.renderCache == null) return;
-		const { file, result } = this.renderCache;
+		const { renderCache } = this;
+		if (renderCache == null) return;
+		const { file, result } = renderCache;
 		if (result == null) return;
 		const pendingStructuralRows = lineCountChangeInFlight ? /* @__PURE__ */ new Map() : void 0;
 		this.pendingStructuralRows = pendingStructuralRows;
 		const lineCache = this.lineCache != null && isLineCacheForFile(this.lineCache, file) ? this.lineCache : void 0;
 		for (const [line, tokens] of dirtyLines) {
-			if (pendingStructuralRows === void 0 && lineCache != null && line < lineCache.lines.length) {
+			if (pendingStructuralRows == null && lineCache != null && line < lineCache.lines.length) {
 				const lineText = tokens.map((token) => token[2]).join("");
 				lineCache.lines[line] = applyLineTextWithNewline(lineCache.lines[line] ?? "", lineText);
 			}
@@ -241,17 +298,21 @@ var FileRenderer = class {
 					};
 				})
 			};
-			if (pendingStructuralRows !== void 0) pendingStructuralRows.set(line, row);
+			if (pendingStructuralRows != null) pendingStructuralRows.set(line, row);
 			else result.code[line] = row;
 		}
 		result.baseThemeType = themeType;
-		this.renderCache.isDirty = true;
+		renderCache.isDirty = true;
+		if (pendingStructuralRows == null && lineCache != null) {
+			file.contents = lineCache.lines.join("");
+			lineCache.sourceContents = file.contents;
+		}
 	}
 	applyDocumentChange(textDocument) {
-		const pendingStructuralRows = this.pendingStructuralRows;
+		const { pendingStructuralRows, renderCache } = this;
 		this.pendingStructuralRows = void 0;
-		if (this.renderCache == null) return;
-		const { file, result } = this.renderCache;
+		if (renderCache == null) return;
+		const { file, result } = renderCache;
 		if (result == null) return;
 		const previousLines = this.lineCache != null && isLineCacheForFile(this.lineCache, file) ? this.lineCache.lines : linesFromFileContents(file.contents);
 		const nextLines = linesFromFileContents(textDocument.getText());
@@ -293,7 +354,7 @@ var FileRenderer = class {
 					line.properties["data-line-index"] = i;
 				}
 			}
-			this.renderCache.isDirty = true;
+			renderCache.isDirty = true;
 		}
 		this.lineCache = {
 			cacheKey: file.cacheKey,
@@ -302,24 +363,22 @@ var FileRenderer = class {
 			lines: nextLines
 		};
 		this.textDocumentCache.set(file, textDocument);
+		file.contents = textDocument.getText();
 	}
-	renderFile(file = this.renderCache?.file, renderRange = DEFAULT_RENDER_RANGE) {
-		if (file == null) return;
-		this.invalidateChangedUnkeyedFile(file);
-		if (this.renderCache?.isDirty === true && !areFilesEqual(file, this.renderCache.file)) {
-			this.clearRenderCache();
-			this.lineCache = void 0;
-			this.textDocumentCache = /* @__PURE__ */ new WeakMap();
+	renderFile(file = this.file, renderRange = DEFAULT_RENDER_RANGE) {
+		this.file = file;
+		if (file == null) {
+			this.pendingHighlightResult = void 0;
+			return;
 		}
 		let { options, forceHighlight } = this.getRenderOptions(file);
-		if (this.renderCache?.isDirty === true && !areFileRenderOptionsEqual(options, this.renderCache.options)) this.clearRenderCache();
-		const cache = this.getMatchingWorkerResultCache(file, options);
-		if (cache != null && !this.hasHighlightedRenderCache(file, options)) {
+		const readyResult = this.getReadyRenderResult(file, options);
+		this.pendingHighlightResult = void 0;
+		if (readyResult != null) {
 			this.renderCache = {
+				...readyResult,
 				file,
-				highlighted: true,
-				renderRange: void 0,
-				...cache
+				renderRange: void 0
 			};
 			forceHighlight = false;
 		}
@@ -333,10 +392,12 @@ var FileRenderer = class {
 		const lines = this.getOrCreateLineCache(file);
 		const hasContent = file.contents.length > 0;
 		const forcePlainText = !hasContent || isFilePlainText(file) || isFileMassive(lines.length, this.getTokenizeMaxLength());
-		const newContent = !areFilesEqual(file, this.renderCache.file);
+		const canRenderFile = this.canRenderFile(file, options, forcePlainText);
+		const newContent = !areFileTargetsEqual(file, this.renderCache.file);
 		const newRenderRange = !areRenderRangesEqual(this.renderCache.renderRange, renderRange);
 		if (!this.editSessionActive && this.workerManager?.isWorkingPool() === true) {
-			if (forcePlainText || this.renderCache.result == null || !this.renderCache.highlighted && (newContent || newRenderRange)) {
+			const preserveHydratedContent = this.renderCache.result == null && this.renderCache.highlighted && !forcePlainText && !newContent && isDefaultRenderRange(renderRange);
+			if (canRenderFile && !preserveHydratedContent && (forcePlainText || this.renderCache.result == null || !this.renderCache.highlighted && (newContent || newRenderRange))) {
 				this.renderCache.file = file;
 				this.renderCache.options = options;
 				this.renderCache.highlighted = false;
@@ -346,10 +407,11 @@ var FileRenderer = class {
 			if (!forcePlainText && hasContent && (!this.renderCache.highlighted || forceHighlight)) this.workerManager.highlightFileAST(this, file);
 		} else {
 			this.computedLang = file.lang ?? getFiletypeFromFileName(file.name);
+			this.highlighter ??= getHighlighterIfLoaded();
 			const hasThemes = this.highlighter != null && areThemesAttached(options.theme);
 			const hasLangs = this.highlighter != null && areLanguagesAttached(this.computedLang);
 			const canHighlight = !forcePlainText && hasLangs;
-			if (this.highlighter != null && hasThemes && (forceHighlight || forcePlainText || !this.renderCache.highlighted && canHighlight || this.renderCache.result == null)) {
+			if (canRenderFile && this.highlighter != null && hasThemes && (forceHighlight || forcePlainText || !this.renderCache.highlighted && canHighlight || this.renderCache.result == null)) {
 				const { result, options } = this.renderFileWithHighlighter(file, this.highlighter, forcePlainText || !hasLangs);
 				this.renderCache = {
 					file,
@@ -360,13 +422,13 @@ var FileRenderer = class {
 				};
 			}
 			if (!hasThemes || !forcePlainText && !hasLangs) this.asyncHighlight(file).then(({ result, options }) => {
-				if (this.renderCache != null) this.renderCache.highlighted = false;
 				this.applyHighlightResult(file, result, options, !forcePlainText);
 			});
 		}
 		return this.renderCache.result != null ? this.processFileResult(this.renderCache.file, renderRange, this.renderCache.result) : void 0;
 	}
 	async asyncRender(file, renderRange = DEFAULT_RENDER_RANGE) {
+		this.file = file;
 		const { result } = await this.asyncHighlight(file);
 		return this.processFileResult(file, renderRange, result);
 	}
@@ -399,7 +461,7 @@ var FileRenderer = class {
 				type: "annotation",
 				hunkIndex: -1,
 				lineIndex: -1,
-				annotations: fileLevelAnnotations.map((annotation) => getLineAnnotationName(annotation))
+				annotations: fileLevelAnnotations.map((annotation) => this.annotationSlotName(annotation))
 			}));
 			rowCount++;
 		}
@@ -425,13 +487,14 @@ var FileRenderer = class {
 					type: "annotation",
 					hunkIndex: 0,
 					lineIndex: lineNumber,
-					annotations: annotations.map((annotation) => getLineAnnotationName(annotation))
+					annotations: annotations.map((annotation) => this.annotationSlotName(annotation))
 				}));
 				rowCount++;
 			}
 		}
 		gutter.properties.style = `grid-row: span ${rowCount}`;
 		return {
+			file,
 			gutterAST: gutter.children ?? [],
 			contentAST: contentArray,
 			preAST: this.createPreElement(totalLines),
@@ -493,16 +556,16 @@ var FileRenderer = class {
 		this.applyHighlightResult(file, result, options, highlighted);
 	}
 	applyHighlightResult(file, result, options, highlighted = true) {
-		if (this.renderCache == null) return;
-		const triggerRenderUpdate = !areFilesEqual(file, this.renderCache.file) || !this.renderCache.highlighted || !areFileRenderOptionsEqual(options, this.renderCache.options);
-		this.renderCache = {
-			file,
+		const { file: currentFile, renderCache } = this;
+		if (currentFile == null || renderCache == null || !areFileTargetsEqual(file, currentFile) || !areFileRenderOptionsEqual(options, this.getRenderOptions(currentFile).options)) return;
+		if (!(renderCache.result == null || !renderCache.highlighted || !areFileRenderOptionsEqual(renderCache.options, options) || !areFileTargetsEqual(renderCache.file, currentFile))) return;
+		this.pendingHighlightResult = {
+			file: currentFile,
 			options,
 			highlighted,
-			result,
-			renderRange: void 0
+			result
 		};
-		if (triggerRenderUpdate) this.onRenderUpdate?.();
+		this.onRenderUpdate?.();
 	}
 	getMatchingWorkerResultCache(file, options) {
 		if (this.editSessionActive) return;
@@ -510,9 +573,20 @@ var FileRenderer = class {
 		if (cache == null || !areFileRenderOptionsEqual(options, cache.options)) return;
 		return cache;
 	}
+	getReadyRenderResult(file, options) {
+		const { pendingHighlightResult } = this;
+		if (pendingHighlightResult != null && areFileTargetsEqual(pendingHighlightResult.file, file) && areFileRenderOptionsEqual(pendingHighlightResult.options, options)) return pendingHighlightResult;
+		const workerCache = this.getMatchingWorkerResultCache(file, options);
+		if (workerCache == null || this.hasHighlightedRenderCache(file, options)) return;
+		return {
+			file,
+			highlighted: true,
+			...workerCache
+		};
+	}
 	hasHighlightedRenderCache(file, options) {
 		const { renderCache } = this;
-		return renderCache?.result != null && renderCache.highlighted && areFilesEqual(file, renderCache.file) && areFileRenderOptionsEqual(options, renderCache.options);
+		return renderCache?.result != null && renderCache.highlighted && areFileTargetsEqual(file, renderCache.file) && areFileRenderOptionsEqual(options, renderCache.options);
 	}
 	onHighlightError(error) {
 		console.error(error);