stream-monaco 0.0.41 → 0.0.44

package/dist/index.cjs

@@ -1,4 +1,4 @@
-const require_preloadMonacoWorkers_shared = require('./preloadMonacoWorkers.shared-BT4GsCRM.cjs');
+const require_preloadMonacoWorkers_shared = require('./preloadMonacoWorkers.shared-DpwiD-Ro.cjs');
 
 //#region src/ensureMonacoWorkers.ts
 function ensureMonacoWorkers() {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { RevealStrategy, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, editorWorkerPath, getOrCreateHighlighter, registerMonacoThemes, uniqueWorkerPaths, useMonaco, workerPathByLabel } from "./preloadMonacoWorkers.shared-CtSx-xKA.js";
+import { RevealStrategy, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, editorWorkerPath, getOrCreateHighlighter, registerMonacoThemes, uniqueWorkerPaths, useMonaco, workerPathByLabel } from "./preloadMonacoWorkers.shared-vZJruB3t.js";
 
 //#region src/ensureMonacoWorkers.ts
 function ensureMonacoWorkers() {

package/dist/index.legacy.cjs

@@ -1,4 +1,4 @@
-const require_preloadMonacoWorkers_shared = require('./preloadMonacoWorkers.shared-BT4GsCRM.cjs');
+const require_preloadMonacoWorkers_shared = require('./preloadMonacoWorkers.shared-DpwiD-Ro.cjs');
 const monaco_editor_esm_vs_basic_languages_cpp_cpp = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/cpp/cpp"));
 const monaco_editor_esm_vs_basic_languages_javascript_javascript = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/javascript/javascript"));
 const monaco_editor_esm_vs_basic_languages_powershell_powershell = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/powershell/powershell"));

package/dist/index.legacy.js

@@ -1,4 +1,4 @@
-import { RevealStrategy, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, monaco_shim_exports, processedLanguage, registerMonacoThemes, useMonaco, workerPathByLabel } from "./preloadMonacoWorkers.shared-CtSx-xKA.js";
+import { RevealStrategy, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, monaco_shim_exports, processedLanguage, registerMonacoThemes, useMonaco, workerPathByLabel } from "./preloadMonacoWorkers.shared-vZJruB3t.js";
 import { conf, language } from "monaco-editor/esm/vs/basic-languages/cpp/cpp";
 import { conf as conf$1, language as language$1 } from "monaco-editor/esm/vs/basic-languages/javascript/javascript";
 import { conf as conf$2, language as language$2 } from "monaco-editor/esm/vs/basic-languages/powershell/powershell";

package/dist/{preloadMonacoWorkers.shared-BT4GsCRM.cjs → preloadMonacoWorkers.shared-DpwiD-Ro.cjs}

@@ -527,6 +527,14 @@ function createScrollWatcherForEditor(ed, opts) {
 	return api;
 }
 
+//#endregion
+//#region src/utils/textChunks.ts
+function countLineBreaks(text) {
+	let count = 0;
+	for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) count += 1;
+	return count;
+}
+
 //#endregion
 //#region src/core/diffAppearance.ts
 function parseCssColorRgb(color) {
@@ -4116,6 +4124,8 @@ var DiffEditorManager = class DiffEditorManager {
 		this.createDomDisposable(this.diffHunkDisposables, this.diffHunkUpperNode, "mouseleave", () => this.scheduleHideDiffHunkActions());
 		this.createDomDisposable(this.diffHunkDisposables, this.diffHunkLowerNode, "mouseenter", () => this.cancelScheduledHideDiffHunkActions());
 		this.createDomDisposable(this.diffHunkDisposables, this.diffHunkLowerNode, "mouseleave", () => this.scheduleHideDiffHunkActions());
+		this.createDomDisposable(this.diffHunkDisposables, this.diffHunkUpperNode, "wheel", (event) => this.handleDiffHunkWheel(event, "upper"));
+		this.createDomDisposable(this.diffHunkDisposables, this.diffHunkLowerNode, "wheel", (event) => this.handleDiffHunkWheel(event, "lower"));
 		overlay.append(this.diffHunkUpperNode, this.diffHunkLowerNode);
 		const originalEditor = this.diffEditorView.getOriginalEditor();
 		const modifiedEditor = this.diffEditorView.getModifiedEditor();
@@ -4139,6 +4149,17 @@ var DiffEditorManager = class DiffEditorManager {
 		}));
 		this.diffHunkLineChanges = this.getEffectiveLineChanges();
 	}
+	handleDiffHunkWheel(event, side) {
+		var _editor$setScrollLeft, _editor$getScrollLeft, _editor$setScrollTop, _editor$getScrollTop2;
+		if (Math.abs(event.deltaX) < .5 && Math.abs(event.deltaY) < .5) return;
+		if (!this.diffEditorView) return;
+		const editor = this.isDiffInlineMode() || side === "lower" ? this.diffEditorView.getModifiedEditor() : this.diffEditorView.getOriginalEditor();
+		event.preventDefault();
+		event.stopPropagation();
+		(_editor$setScrollLeft = editor.setScrollLeft) === null || _editor$setScrollLeft === void 0 || _editor$setScrollLeft.call(editor, (((_editor$getScrollLeft = editor.getScrollLeft) === null || _editor$getScrollLeft === void 0 ? void 0 : _editor$getScrollLeft.call(editor)) ?? 0) + event.deltaX);
+		(_editor$setScrollTop = editor.setScrollTop) === null || _editor$setScrollTop === void 0 || _editor$setScrollTop.call(editor, (((_editor$getScrollTop2 = editor.getScrollTop) === null || _editor$getScrollTop2 === void 0 ? void 0 : _editor$getScrollTop2.call(editor)) ?? 0) + event.deltaY);
+		this.hideDiffHunkActions();
+	}
 	cancelScheduledHideDiffHunkActions() {
 		if (this.diffHunkHideTimer != null) {
 			clearTimeout(this.diffHunkHideTimer);
@@ -4418,9 +4439,10 @@ var DiffEditorManager = class DiffEditorManager {
 				shouldAutoScrollDiff: this.shouldAutoScrollDiff
 			});
 			if (!this.diffEditorView) return;
+			if (!(this.diffAutoScroll && this.autoScrollOnUpdate && this.shouldAutoScrollDiff)) return;
 			const hasV = this.hasVerticalScrollbarModified();
 			log("diff", "hasVerticalScrollbarModified ->", hasV);
-			if (!(this.diffAutoScroll && this.autoScrollOnUpdate && this.shouldAutoScrollDiff && hasV)) return;
+			if (!hasV) return;
 			const me = this.diffEditorView.getModifiedEditor();
 			const model = me.getModel();
 			const currentLine = (model === null || model === void 0 ? void 0 : model.getLineCount()) ?? 1;
@@ -4642,7 +4664,7 @@ var DiffEditorManager = class DiffEditorManager {
 		this.diffComputedVersions = null;
 		this.diffPresentationDisposables.push(this.diffEditorView.onDidUpdateDiff(() => {
 			this.diffComputedVersions = this.captureCurrentDiffVersions();
-			this.syncDiffEditorLayoutToContainer();
+			this.scheduleSyncDiffEditorLayoutToContainer();
 			this.scheduleSyncDiffPresentationDecorations();
 		}));
 		this.diffPresentationDisposables.push(oEditor.onDidChangeModelContent(() => {
@@ -4807,6 +4829,7 @@ var DiffEditorManager = class DiffEditorManager {
 	}
 	updateModified(newCode, codeLanguage) {
 		if (!this.diffEditorView || !this.modifiedModel) return;
+		this.syncLastKnownModified();
 		if (codeLanguage) {
 			const lang = processedLanguage(codeLanguage);
 			if (lang && this.modifiedModel.getLanguageId() !== lang) monaco_shim_exports.editor.setModelLanguage(this.modifiedModel, lang);
@@ -4819,7 +4842,7 @@ var DiffEditorManager = class DiffEditorManager {
 		if (tailAppend) this.appendModified(newCode.slice(prev.length), codeLanguage);
 		else {
 			this.flushModifiedAppendBufferSync();
-			const prevAfterFlush = this.modifiedModel.getValue();
+			const prevAfterFlush = this.lastKnownModifiedCode ?? this.modifiedModel.getValue();
 			const prevLine = this.modifiedModel.getLineCount();
 			this.applyMinimalEditToModel(this.modifiedModel, prevAfterFlush, newCode);
 			const newLine = this.modifiedModel.getLineCount();
@@ -5069,6 +5092,7 @@ var DiffEditorManager = class DiffEditorManager {
 		}
 		const { original, modified, lang } = this.pendingDiffUpdate;
 		this.pendingDiffUpdate = null;
+		this.syncLastKnownModified();
 		this.flushOriginalAppendBufferSync();
 		this.flushModifiedAppendBufferSync();
 		if (lang) {
@@ -5089,7 +5113,7 @@ var DiffEditorManager = class DiffEditorManager {
 			else this.applyMinimalEditToModel(o, prevO, original);
 			this.lastKnownOriginalCode = original;
 		}
-		const prevM = m.getValue();
+		const prevM = this.lastKnownModifiedCode;
 		const prevMLineCount = m.getLineCount();
 		const modifiedTailAppend = prevM !== modified && modified.startsWith(prevM) && prevM.length < modified.length;
 		const hasContentChange = prevO !== original || prevM !== modified;
@@ -5130,6 +5154,33 @@ var DiffEditorManager = class DiffEditorManager {
 		this.preserveNativeDiffDecorationsOnStaleAppend = true;
 		this.appendToModel(this.modifiedModel, text);
 	}
+	splitAppendTextForProgressiveFlush(text, maxChunkChars = 12e3, maxChunkLines = 200) {
+		if (!text || text.length <= maxChunkChars) return [text];
+		const chunks = [];
+		let start = 0;
+		let lineCount = 0;
+		let lastSafeEnd = 0;
+		for (let i = 0; i < text.length; i++) {
+			if (text.charCodeAt(i) === 10) {
+				lineCount += 1;
+				lastSafeEnd = i + 1;
+			}
+			if (i - start + 1 < maxChunkChars && lineCount < maxChunkLines) continue;
+			let end = lastSafeEnd > start ? lastSafeEnd : i + 1;
+			if (end < text.length) {
+				const prev = text.charCodeAt(end - 1);
+				const next = text.charCodeAt(end);
+				if (prev >= 55296 && prev <= 56319 && next >= 56320 && next <= 57343) end += 1;
+			}
+			chunks.push(text.slice(start, end));
+			start = end;
+			i = end - 1;
+			lineCount = 0;
+			lastSafeEnd = start;
+		}
+		if (start < text.length) chunks.push(text.slice(start));
+		return chunks.length ? chunks : [text];
+	}
 	async flushAppendBufferDiff() {
 		if (!this.diffEditorView) return;
 		if (this.appendBufferOriginalDiff.length === 0 && this.appendBufferModifiedDiff.length === 0) return;
@@ -5150,17 +5201,16 @@ var DiffEditorManager = class DiffEditorManager {
 			return;
 		}
 		let parts = this.appendBufferModifiedDiff.splice(0);
+		if (parts.length === 0) {
+			this.eagerlyGrowDiffContainerHeight();
+			return;
+		}
 		const prevLineInit = model.getLineCount();
 		const totalText = parts.join("");
 		const totalChars = totalText.length;
-		if (parts.length === 1 && totalChars > 5e3) {
-			const lines = totalText.split(/\r?\n/);
-			const chunkSize = 200;
-			const chunks = [];
-			for (let i = 0; i < lines.length; i += chunkSize) chunks.push(`${lines.slice(i, i + chunkSize).join("\n")}\n`);
-			if (chunks.length > 1) parts = chunks;
-		}
-		const applyChunked = parts.length > 1 && (totalChars > 2e3 || model.getLineCount && model.getLineCount() + 0 - prevLineInit > 50);
+		const totalLineBreaks = countLineBreaks(totalText);
+		if (parts.length === 1 && totalChars > 5e3) parts = this.splitAppendTextForProgressiveFlush(totalText);
+		const applyChunked = parts.length > 1 && (totalChars > 2e3 || totalLineBreaks > 50);
 		log("diff", "flushAppendBufferDiff start", {
 			partsCount: parts.length,
 			totalChars,
@@ -5179,6 +5229,8 @@ var DiffEditorManager = class DiffEditorManager {
 		} catch {}
 		if (applyChunked) {
 			log("diff", "flushAppendBufferDiff applying chunked", { partsLen: parts.length });
+			if (this.lastKnownModifiedCode == null) this.lastKnownModifiedCode = model.getValue();
+			let currentLength = this.lastKnownModifiedCode.length;
 			let idx = 0;
 			for (const part of parts) {
 				if (!part) continue;
@@ -5188,17 +5240,9 @@ var DiffEditorManager = class DiffEditorManager {
 					partLen: part.length,
 					prevLine
 				});
-				const lastColumn$1 = model.getLineMaxColumn(prevLine);
-				const range$1 = new monaco_shim_exports.Range(prevLine, lastColumn$1, prevLine, lastColumn$1);
 				this.preserveNativeDiffDecorationsOnStaleAppend = true;
-				this.runAsProgrammaticModifiedContentChange(() => {
-					model.applyEdits([{
-						range: range$1,
-						text: part,
-						forceMoveMarkers: true
-					}]);
-				});
-				this.lastKnownModifiedCode = model.getValue();
+				this.appendToModel(model, part, currentLength);
+				currentLength += part.length;
 				const newLine$1 = model.getLineCount();
 				this.lastKnownModifiedLineCount = newLine$1;
 				await new Promise((resolve) => typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame(resolve) : setTimeout(resolve, 0));
@@ -5224,23 +5268,15 @@ var DiffEditorManager = class DiffEditorManager {
 					newLine: newLine$1
 				});
 			}
+			this.lastKnownModifiedCode = model.getValue();
 			if (suppressedByFlush) watcherApi.setSuppressed(false);
 			return;
 		}
 		const text = totalText;
 		this.appendBufferModifiedDiff.length = 0;
 		prevLine = model.getLineCount();
-		const lastColumn = model.getLineMaxColumn(prevLine);
-		const range = new monaco_shim_exports.Range(prevLine, lastColumn, prevLine, lastColumn);
 		this.preserveNativeDiffDecorationsOnStaleAppend = true;
-		this.runAsProgrammaticModifiedContentChange(() => {
-			model.applyEdits([{
-				range,
-				text,
-				forceMoveMarkers: true
-			}]);
-		});
-		this.lastKnownModifiedCode = model.getValue();
+		this.appendToModel(model, text);
 		const newLine = model.getLineCount();
 		this.lastKnownModifiedLineCount = newLine;
 		this.eagerlyGrowDiffContainerHeight();
@@ -5283,8 +5319,30 @@ var DiffEditorManager = class DiffEditorManager {
 		});
 		if (model === this.modifiedModel) this.lastKnownModifiedLineCount = model.getLineCount();
 	}
-	appendToModel(model, appendText) {
+	getModelValueLength(model) {
+		const getValueLength = model.getValueLength;
+		if (typeof getValueLength === "function") try {
+			return getValueLength.call(model);
+		} catch {}
+		return model.getValue().length;
+	}
+	mergeKnownAppend(known, appendText, previousLength, model) {
+		if (known == null) return model.getValue();
+		const nextLength = previousLength + appendText.length;
+		if (known.length === previousLength) return known + appendText;
+		if (known.length >= nextLength && known.slice(previousLength, nextLength) === appendText) return known;
+		return model.getValue();
+	}
+	syncKnownCodeAfterAppend(model, appendText, previousLength) {
+		if (model === this.originalModel) {
+			this.lastKnownOriginalCode = this.mergeKnownAppend(this.lastKnownOriginalCode, appendText, previousLength, model);
+			return;
+		}
+		if (model === this.modifiedModel) this.lastKnownModifiedCode = this.mergeKnownAppend(this.lastKnownModifiedCode, appendText, previousLength, model);
+	}
+	appendToModel(model, appendText, knownLength) {
 		if (!appendText) return;
+		const previousLength = knownLength != null ? knownLength : this.getModelValueLength(model);
 		const lastLine = model.getLineCount();
 		const lastColumn = model.getLineMaxColumn(lastLine);
 		const range = new monaco_shim_exports.Range(lastLine, lastColumn, lastLine, lastColumn);
@@ -5296,6 +5354,7 @@ var DiffEditorManager = class DiffEditorManager {
 			}]);
 		});
 		if (model === this.modifiedModel) this.lastKnownModifiedLineCount = model.getLineCount();
+		this.syncKnownCodeAfterAppend(model, appendText, previousLength);
 	}
 	applyModelEdit(model, fn) {
 		if (model === this.modifiedModel) {
@@ -5333,6 +5392,8 @@ var EditorManager = class {
 	minimalEditMaxChangeRatioValue = minimalEditMaxChangeRatio;
 	lastUpdateFlushTime = 0;
 	updateThrottleTimer = null;
+	lastAppendFlushTime = 0;
+	appendFlushThrottleTimer = null;
 	shouldAutoScroll = true;
 	scrollWatcher = null;
 	scrollWatcherSuppressionTimer = null;
@@ -5432,6 +5493,10 @@ var EditorManager = class {
 			clearTimeout(this.updateThrottleTimer);
 			this.updateThrottleTimer = null;
 		}
+		if (this.appendFlushThrottleTimer != null) {
+			clearTimeout(this.appendFlushThrottleTimer);
+			this.appendFlushThrottleTimer = null;
+		}
 	}
 	initDebugFlag() {
 		if (typeof window !== "undefined" && window.__STREAM_MONACO_DEBUG__ !== void 0) {
@@ -5528,6 +5593,14 @@ var EditorManager = class {
 	}
 	maybeScrollToBottom(targetLine) {
 		this.rafScheduler.schedule("maybe-scroll", () => {
+			if (!(this.autoScrollOnUpdate && this.shouldAutoScroll)) {
+				this.dlog("maybeScrollToBottom skipped (auto-scroll disabled)", {
+					autoScrollOnUpdate: this.autoScrollOnUpdate,
+					shouldAutoScroll: this.shouldAutoScroll,
+					targetLine
+				});
+				return;
+			}
 			const hasVS = this.hasVerticalScrollbar();
 			this.dlog("maybeScrollToBottom called", {
 				autoScrollOnUpdate: this.autoScrollOnUpdate,
@@ -5535,8 +5608,8 @@ var EditorManager = class {
 				hasVerticalScrollbar: hasVS,
 				targetLine
 			});
-			if (!(this.autoScrollOnUpdate && this.shouldAutoScroll && this.hasVerticalScrollbar())) {
-				this.dlog("maybeScrollToBottom skipped (auto-scroll conditions not met)");
+			if (!hasVS) {
+				this.dlog("maybeScrollToBottom skipped (no vertical scrollbar)");
 				return;
 			}
 			const model = this.editorView.getModel();
@@ -5796,7 +5869,7 @@ var EditorManager = class {
 				this.lastScrollTop = v;
 			}
 		});
-		this.maybeScrollToBottom();
+		if (this.shouldAutoScroll) this.maybeScrollToBottom();
 		return this.editorView;
 	}
 	syncLastKnownCode() {
@@ -5967,10 +6040,31 @@ var EditorManager = class {
 			this.appendBuffer.push(appendText);
 			if (!this.appendBufferScheduled) {
 				this.appendBufferScheduled = true;
-				this.rafScheduler.schedule("append", () => this.flushAppendBuffer());
+				this.scheduleFlushAppendBuffer();
 			}
 		}
 	}
+	scheduleFlushAppendBuffer() {
+		const schedule = () => {
+			this.rafScheduler.schedule("append", () => this.flushAppendBuffer());
+		};
+		if (!this.updateThrottleMs) {
+			schedule();
+			return;
+		}
+		const now = Date.now();
+		const since = now - this.lastAppendFlushTime;
+		if (since >= this.updateThrottleMs) {
+			schedule();
+			return;
+		}
+		if (this.appendFlushThrottleTimer != null) return;
+		const wait = this.updateThrottleMs - since;
+		this.appendFlushThrottleTimer = setTimeout(() => {
+			this.appendFlushThrottleTimer = null;
+			schedule();
+		}, wait);
+	}
 	applyMinimalEdit(prev, next) {
 		if (!this.editorView) return;
 		const model = this.editorView.getModel();
@@ -6011,6 +6105,7 @@ var EditorManager = class {
 		if (!this.editorView) return;
 		if (this.appendBuffer.length === 0) return;
 		this.appendBufferScheduled = false;
+		this.lastAppendFlushTime = Date.now();
 		const model = this.editorView.getModel();
 		if (!model) {
 			this.appendBuffer.length = 0;
@@ -6065,6 +6160,11 @@ var EditorManager = class {
 			this.updateThrottleTimer = null;
 			this.rafScheduler.schedule("update", () => this.flushPendingUpdate());
 		}
+		if (!this.updateThrottleMs && this.appendFlushThrottleTimer != null) {
+			clearTimeout(this.appendFlushThrottleTimer);
+			this.appendFlushThrottleTimer = null;
+			this.rafScheduler.schedule("append", () => this.flushAppendBuffer());
+		}
 	}
 	getUpdateThrottleMs() {
 		return this.updateThrottleMs;
@@ -6141,6 +6241,8 @@ function arraysEqual(a, b) {
 const LEGACY_ONIG_INIT_KEY = "__streamMonacoLegacyOnigurumaInit__";
 const LEGACY_ENGINE_KEY = "__streamMonacoLegacyShikiEngine__";
 const LEGACY_MONACO_LANGS_INIT_KEY = "__streamMonacoLegacyMonacoLangsInit__";
+const PERF_HOOKS_ENABLED_KEY = "__STREAM_MONACO_ENABLE_INTERNAL_PERF_HOOKS__";
+let instrumentedHighlighterCache = /* @__PURE__ */ new WeakMap();
 async function awaitLegacyOnigurumaInitIfPresent() {
 	try {
 		var _globalThis;
@@ -6191,9 +6293,109 @@ let lastPatchedHighlighter = null;
 let lastPatchedLanguages = /* @__PURE__ */ new Set();
 const monacoThemeByKey = /* @__PURE__ */ new Map();
 const monacoLanguageSet = /* @__PURE__ */ new Set();
+function nowMs() {
+	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function isPerfHooksEnabled() {
+	try {
+		var _globalThis4;
+		return typeof globalThis !== "undefined" && ((_globalThis4 = globalThis) === null || _globalThis4 === void 0 ? void 0 : _globalThis4[PERF_HOOKS_ENABLED_KEY]) === true;
+	} catch {
+		return false;
+	}
+}
+function getPerfHook(name) {
+	if (!isPerfHooksEnabled()) return null;
+	try {
+		var _STREAM_MONACO_PERF__;
+		if (typeof globalThis === "undefined") return null;
+		const hook = (_STREAM_MONACO_PERF__ = globalThis.__STREAM_MONACO_PERF__) === null || _STREAM_MONACO_PERF__ === void 0 ? void 0 : _STREAM_MONACO_PERF__[name];
+		return typeof hook === "function" ? hook : null;
+	} catch {
+		return null;
+	}
+}
+function getTokenizationPerfHook() {
+	return getPerfHook("recordTokenize");
+}
+function getGrammarTokenizationPerfHook() {
+	return getPerfHook("recordGrammarTokenize");
+}
+function getThemeRegistrationPerfHook() {
+	return getPerfHook("recordThemeRegistration");
+}
+function recordTokenize(hook, language, durationMs, line, tokenCount, failed) {
+	if (!hook) return;
+	try {
+		hook({
+			language,
+			durationMs,
+			lineLength: line.length,
+			lineSample: line.slice(0, 120),
+			tokenCount,
+			failed
+		});
+	} catch {}
+}
+function recordGrammarTokenize(language, durationMs, line, stoppedEarly, tokenCount) {
+	const hook = getGrammarTokenizationPerfHook();
+	if (!hook) return;
+	try {
+		hook({
+			language,
+			durationMs,
+			lineLength: line.length,
+			lineSample: line.slice(0, 120),
+			stoppedEarly,
+			tokenCount
+		});
+	} catch {}
+}
+function recordThemeRegistration(event) {
+	const hook = getThemeRegistrationPerfHook();
+	if (!hook) return;
+	try {
+		hook(event);
+	} catch {}
+}
+function getProxyMember(target, prop) {
+	const value = Reflect.get(target, prop, target);
+	return typeof value === "function" ? value.bind(target) : value;
+}
 function themeKey(t) {
 	return typeof t === "string" ? t : t.name ?? JSON.stringify(t);
 }
+function maybeInstrumentHighlighterGrammar(highlighter) {
+	if (!getGrammarTokenizationPerfHook()) return highlighter;
+	if (!highlighter || typeof highlighter !== "object" && typeof highlighter !== "function") return highlighter;
+	const cached = instrumentedHighlighterCache.get(highlighter);
+	if (cached) return cached;
+	const grammarProxyCache = /* @__PURE__ */ new WeakMap();
+	const instrumentedHighlighter = new Proxy(highlighter, { get(target, prop, _receiver) {
+		if (prop !== "getLanguage") return getProxyMember(target, prop);
+		return (language) => {
+			const grammar = target.getLanguage(language);
+			if (!grammar || typeof grammar !== "object" || typeof grammar.tokenizeLine2 !== "function") return grammar;
+			const cachedGrammar = grammarProxyCache.get(grammar);
+			if (cachedGrammar) return cachedGrammar;
+			const instrumentedGrammar = new Proxy(grammar, { get(grammarTarget, grammarProp, _grammarReceiver) {
+				if (grammarProp !== "tokenizeLine2") return getProxyMember(grammarTarget, grammarProp);
+				const originalTokenizeLine2 = grammarTarget.tokenizeLine2.bind(grammarTarget);
+				return (line, ruleStack, timeLimit) => {
+					var _result$tokens;
+					const startedAt = nowMs();
+					const result = originalTokenizeLine2(line, ruleStack, timeLimit);
+					recordGrammarTokenize(language, nowMs() - startedAt, line, !!(result === null || result === void 0 ? void 0 : result.stoppedEarly), typeof (result === null || result === void 0 || (_result$tokens = result.tokens) === null || _result$tokens === void 0 ? void 0 : _result$tokens.length) === "number" ? result.tokens.length / 2 : 0);
+					return result;
+				};
+			} });
+			grammarProxyCache.set(grammar, instrumentedGrammar);
+			return instrumentedGrammar;
+		};
+	} });
+	instrumentedHighlighterCache.set(highlighter, instrumentedHighlighter);
+	return instrumentedHighlighter;
+}
 async function ensureMonacoHighlighter(themes, languages$1) {
 	for (const t of themes) monacoThemeByKey.set(themeKey(t), t);
 	for (const l of languages$1) monacoLanguageSet.add(l);
@@ -6203,7 +6405,11 @@ async function ensureMonacoHighlighter(themes, languages$1) {
 		monacoHighlighterPromise = createHighlighterWithLegacyEngineIfNeeded({
 			themes: initialThemes,
 			langs: initialLangs
-		}).then((h$1) => h$1);
+		}).then((h$1) => {
+			h$1.__streamMonacoLoadedThemes = new Set(initialThemes.map((t) => themeKey(t)));
+			h$1.__streamMonacoLoadedLangs = new Set(initialLangs);
+			return h$1;
+		});
 	}
 	const h = await monacoHighlighterPromise;
 	const wantsThemes = Array.from(monacoThemeByKey.values());
@@ -6231,7 +6437,11 @@ async function ensureMonacoHighlighter(themes, languages$1) {
 	const p = createHighlighterWithLegacyEngineIfNeeded({
 		themes: wantsThemes,
 		langs: wantsLangs
-	}).then((hh) => hh);
+	}).then((hh) => {
+		hh.__streamMonacoLoadedThemes = new Set(wantsThemes.map((t) => themeKey(t)));
+		hh.__streamMonacoLoadedLangs = new Set(wantsLangs);
+		return hh;
+	});
 	monacoHighlighterPromise = p;
 	return p;
 }
@@ -6250,6 +6460,7 @@ function clearHighlighterCache() {
 	monacoThemeByKey.clear();
 	monacoLanguageSet.clear();
 	themeRegisterPromise = null;
+	instrumentedHighlighterCache = /* @__PURE__ */ new WeakMap();
 	languagesRegistered = false;
 	currentLanguages = [];
 }
@@ -6316,9 +6527,15 @@ async function getOrCreateHighlighter(themes, languages$1) {
 */
 async function registerMonacoThemes(themes, languages$1) {
 	return enqueueRegistration(async () => {
+		const registrationStartedAt = nowMs();
+		let ensureHighlighterMs = 0;
+		let patchMonacoMs = 0;
+		let patchedMonaco = false;
 		registerMonacoLanguages(languages$1);
 		const p = (async () => {
+			const ensureHighlighterStartedAt = nowMs();
 			const highlighter = await ensureMonacoHighlighter(themes, languages$1);
+			ensureHighlighterMs = nowMs() - ensureHighlighterStartedAt;
 			const wantsLangs = Array.from(monacoLanguageSet.values());
 			const needsLanguagePatch = lastPatchedHighlighter !== highlighter || wantsLangs.some((l) => !lastPatchedLanguages.has(l));
 			if (needsLanguagePatch) {
@@ -6339,9 +6556,17 @@ async function registerMonacoThemes(themes, languages$1) {
 								provider = {
 									...provider,
 									tokenize(line, state) {
+										const hook = getTokenizationPerfHook();
+										const startedAt = hook ? nowMs() : 0;
+										let tokenCount = 0;
+										let failed = false;
 										try {
-											return originalTokenize(line, state);
+											const result = originalTokenize(line, state);
+											tokenCount = Array.isArray(result === null || result === void 0 ? void 0 : result.tokens) ? result.tokens.length : 0;
+											return result;
 										} catch {
+											failed = true;
+											tokenCount = 1;
 											return {
 												endState: state,
 												tokens: [{
@@ -6349,6 +6574,8 @@ async function registerMonacoThemes(themes, languages$1) {
 													scopes: ""
 												}]
 											};
+										} finally {
+											if (hook) recordTokenize(hook, lang, nowMs() - startedAt, line, tokenCount, failed);
 										}
 									}
 								};
@@ -6357,7 +6584,10 @@ async function registerMonacoThemes(themes, languages$1) {
 						}
 					}
 				};
-				(0, __shikijs_monaco.shikiToMonaco)(highlighter, monacoProxy);
+				const patchMonacoStartedAt = nowMs();
+				(0, __shikijs_monaco.shikiToMonaco)(maybeInstrumentHighlighterGrammar(highlighter), monacoProxy);
+				patchMonacoMs = nowMs() - patchMonacoStartedAt;
+				patchedMonaco = true;
 				lastPatchedHighlighter = highlighter;
 				lastPatchedLanguages = new Set(wantsLangs);
 			}
@@ -6367,6 +6597,14 @@ async function registerMonacoThemes(themes, languages$1) {
 		setThemeRegisterPromise(p);
 		try {
 			const res = await p;
+			recordThemeRegistration({
+				durationMs: nowMs() - registrationStartedAt,
+				ensureHighlighterMs,
+				patchMonacoMs,
+				themes: themes.length,
+				languages: languages$1.length,
+				patchedMonaco
+			});
 			return res;
 		} catch (e) {
 			setThemeRegisterPromise(null);
@@ -6500,7 +6738,8 @@ function useMonaco(monacoOptions = {}) {
 	let modifiedModel = null;
 	const themes = monacoOptions.themes && ((_monacoOptions$themes = monacoOptions.themes) === null || _monacoOptions$themes === void 0 ? void 0 : _monacoOptions$themes.length) ? monacoOptions.themes : defaultThemes;
 	if (!Array.isArray(themes) || themes.length < 2) throw new Error("Monaco themes must be an array with at least two themes: [darkTheme, lightTheme]");
-	const languages$1 = monacoOptions.languages ?? defaultLanguages;
+	const explicitLanguages = monacoOptions.languages;
+	const languages$1 = explicitLanguages ?? defaultLanguages;
 	const MAX_HEIGHT = monacoOptions.MAX_HEIGHT ?? 500;
 	const autoScrollOnUpdate = monacoOptions.autoScrollOnUpdate ?? true;
 	const autoScrollInitial = monacoOptions.autoScrollInitial ?? true;
@@ -6589,10 +6828,27 @@ function useMonaco(monacoOptions = {}) {
 			console.warn("onThemeChange callback threw an error:", err);
 		}
 	}
-	async function ensureThemeRegistered(themeName) {
+	function normalizeLanguage(language) {
+		if (!language) return null;
+		return processedLanguage(language) || language;
+	}
+	function resolveCreateLanguages(primaryLanguage) {
+		const primary = normalizeLanguage(primaryLanguage);
+		if (Array.isArray(explicitLanguages) && explicitLanguages.length) {
+			const set = /* @__PURE__ */ new Set();
+			for (const language of explicitLanguages) {
+				const normalized = normalizeLanguage(language);
+				if (normalized) set.add(normalized);
+			}
+			if (primary) set.add(primary);
+			return Array.from(set);
+		}
+		return primary ? [primary] : ["typescript"];
+	}
+	async function ensureThemeRegistered(themeName, requestedLanguages = languages$1) {
 		const availableNames = themes.map((t) => typeof t === "string" ? t : t.name);
 		const list = availableNames.includes(themeName) ? themes : themes.concat(themeName);
-		await registerMonacoThemes(list, languages$1);
+		await registerMonacoThemes(list, requestedLanguages);
 	}
 	function resolveRequestedThemeName() {
 		return requestedThemeName ?? globalRequestedThemeName ?? monacoOptions.theme ?? currentTheme.value;
@@ -6669,11 +6925,12 @@ function useMonaco(monacoOptions = {}) {
 		queuedEditorUpdateDuringCreate = null;
 		disposeAllPendingCreateDisposables();
 	}
-	async function resolveCreateThemeName(requestId, kind) {
+	async function resolveCreateThemeName(requestId, kind, primaryLanguage) {
 		let themeName = resolveRequestedThemeName();
+		const createLanguages = resolveCreateLanguages(primaryLanguage);
 		while (true) {
 			assertCreateStillActive(requestId, kind);
-			await ensureThemeRegistered(themeName);
+			await ensureThemeRegistered(themeName, createLanguages);
 			assertCreateStillActive(requestId, kind);
 			const latestThemeName = resolveRequestedThemeName();
 			if (latestThemeName === themeName) return themeName;
@@ -6692,7 +6949,7 @@ function useMonaco(monacoOptions = {}) {
 		if (requestDisposables.length) pendingCreateDisposables.set(requestId, requestDisposables);
 		let nextEditorMgr = null;
 		try {
-			const initialThemeName = await resolveCreateThemeName(requestId, "editor");
+			const initialThemeName = await resolveCreateThemeName(requestId, "editor", language);
 			nextEditorMgr = new EditorManager(monacoOptions, maxHeightValue, maxHeightCSS, autoScrollOnUpdate, autoScrollInitial, autoScrollThresholdPx, autoScrollThresholdLines, monacoOptions.revealDebounceMs, monacoOptions.updateThrottleMs);
 			const nextEditorView = await nextEditorMgr.createEditor(container, code, language, initialThemeName);
 			assertCreateStillActive(requestId, "editor");
@@ -6739,7 +6996,7 @@ function useMonaco(monacoOptions = {}) {
 		if (requestDisposables.length) pendingCreateDisposables.set(requestId, requestDisposables);
 		let nextDiffMgr = null;
 		try {
-			const initialThemeName = await resolveCreateThemeName(requestId, "diff");
+			const initialThemeName = await resolveCreateThemeName(requestId, "diff", language);
 			nextDiffMgr = new DiffEditorManager(monacoOptions, maxHeightValue, maxHeightCSS, autoScrollOnUpdate, autoScrollInitial, autoScrollThresholdPx, autoScrollThresholdLines, diffAutoScroll, monacoOptions.revealDebounceMs, monacoOptions.diffUpdateThrottleMs);
 			const nextDiffEditorView = await nextDiffMgr.createDiffEditor(container, originalCode, modifiedCode, language, initialThemeName);
 			assertCreateStillActive(requestId, "diff");