diff --git a/src/vs/workbench/test/browser/componentFixtures/fixtureResourceLoader.ts b/src/vs/workbench/test/browser/componentFixtures/fixtureResourceLoader.ts
new file mode 100644
index 00000000000000..bf7e7e947d5114
--- /dev/null
+++ b/src/vs/workbench/test/browser/componentFixtures/fixtureResourceLoader.ts
@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { mainWindow } from '../../../../base/browser/window.js';
+import { FileAccess } from '../../../../base/common/network.js';
+import { isNative } from '../../../../base/common/platform.js';
+import { URI } from '../../../../base/common/uri.js';
+
+export function fixtureResourceUri(path: string): URI {
+	return isNative
+		? URI.joinPath(FileAccess.asFileUri(''), '..', path)
+		: URI.parse(new URL(`/${path}`, mainWindow.document.baseURI).href);
+}
+
+export function readFixtureTextResource(resource: URI): Promise<string> {
+	return requestFixtureResource(resource, 'text').then(request => request.responseText);
+}
+
+export function readFixtureBinaryResource(resource: URI): Promise<ArrayBuffer> {
+	return requestFixtureResource(resource, 'arraybuffer').then(request => request.response);
+}
+
+function requestFixtureResource(resource: URI, responseType: XMLHttpRequestResponseType): Promise<XMLHttpRequest> {
+	return new Promise((resolve, reject) => {
+		const request = new mainWindow.XMLHttpRequest();
+		request.open('GET', resource.toString(true), true);
+		request.responseType = responseType;
+		request.onload = () => {
+			if (request.status === 0 || (request.status >= 200 && request.status < 300)) {
+				resolve(request);
+			} else {
+				reject(new Error(`Failed to load fixture resource ${resource.toString()}: ${request.status} ${request.statusText}`));
+			}
+		};
+		request.onerror = () => reject(new Error(`Failed to load fixture resource ${resource.toString()}: ${request.statusText}`));
+		request.send();
+	});
+}
diff --git a/src/vs/workbench/test/browser/componentFixtures/fixtureSyntaxHighlighting.test.ts b/src/vs/workbench/test/browser/componentFixtures/fixtureSyntaxHighlighting.test.ts
new file mode 100644
index 00000000000000..85346eb57c7625
--- /dev/null
+++ b/src/vs/workbench/test/browser/componentFixtures/fixtureSyntaxHighlighting.test.ts
@@ -0,0 +1,234 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import assert from 'assert';
+import { $ } from '../../../../base/browser/dom.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { Color } from '../../../../base/common/color.js';
+import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
+import { TokenMetadata } from '../../../../editor/common/encodedTokenAttributes.js';
+import { TokenizationRegistry } from '../../../../editor/common/languages.js';
+import { LanguageService } from '../../../../editor/common/services/languageService.js';
+import { IExtensionResourceLoaderService } from '../../../../platform/extensionResourceLoader/common/extensionResourceLoader.js';
+import { ThemeTypeSelector } from '../../../../platform/theme/common/theme.js';
+import { IColorTheme } from '../../../../platform/theme/common/themeService.js';
+import { editorForeground } from '../../../../platform/theme/common/colors/editorColors.js';
+import { ColorThemeData } from '../../../services/themes/common/colorThemeData.js';
+import { ExtensionData } from '../../../services/themes/common/workbenchThemeService.js';
+import { fixtureResourceUri, readFixtureTextResource } from './fixtureResourceLoader.js';
+import { registerFixtureLanguages, registerFixtureSyntaxHighlighting } from './fixtureSyntaxHighlighting.js';
+
+suite('Component fixture TextMate syntax highlighting', () => {
+	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
+	const darkTheme = ColorThemeData.fromExtensionTheme(
+		{ id: '2026-dark', path: '2026-dark.json', uiTheme: ThemeTypeSelector.VS_DARK, _watch: false },
+		fixtureResourceUri('extensions/theme-defaults/themes/2026-dark.json'),
+		ExtensionData.fromName('vscode', 'theme-defaults', true),
+	);
+	const themeLoader = new class implements IExtensionResourceLoaderService {
+		declare readonly _serviceBrand: undefined;
+		readExtensionResource(uri: URI): Promise<string> { return readFixtureTextResource(uri); }
+		supportsExtensionGalleryResources(): Promise<boolean> { return Promise.resolve(false); }
+		isExtensionGalleryResource(): Promise<boolean> { return Promise.resolve(false); }
+		getExtensionGalleryResourceURL(): Promise<undefined> { return Promise.resolve(undefined); }
+	}();
+	let themeLoaded: Promise<void> | undefined;
+
+	async function createTokenizers(theme: IColorTheme = darkTheme): Promise<{ store: DisposableStore; languageService: LanguageService; host: HTMLElement }> {
+		const store = disposables.add(new DisposableStore());
+		const languageService = store.add(new LanguageService());
+		registerFixtureLanguages(store, languageService);
+		const host = mainWindow.document.body.appendChild($('div'));
+		store.add(toDisposable(() => host.remove()));
+		await (themeLoaded ??= darkTheme.ensureLoaded(themeLoader));
+		await registerFixtureSyntaxHighlighting(store, host, darkTheme, theme);
+		return { store, languageService, host };
+	}
+
+	test('registers actual TextMate tokenizers for every fixture language', async () => {
+		const { languageService } = await createTokenizers();
+		const samples = new Map([
+			['typescript', 'const value: number = 1;'],
+			['typescriptreact', 'const view = <div>{value}</div>;'],
+			['javascript', 'const value = /actual+/gi;'],
+			['javascriptreact', 'const view = <div>{value}</div>;'],
+			['json', '{ "enabled": true }'],
+			['css', '.fixture { color: #ff7b72; }'],
+			['html', '<main class="fixture">text</main>'],
+		]);
+
+		const actual = [...samples].map(([languageId, line]) => {
+			const support = TokenizationRegistry.get(languageId);
+			assert.ok(support);
+			const result = support.tokenizeEncoded(line, true, support.getInitialState());
+			return {
+				languageId,
+				registered: languageService.isRegisteredLanguageId(languageId),
+				tokenCount: result.tokens.length / 2,
+				encodedLanguageIds: distinctLanguageIds(result.tokens).map(id => languageService.languageIdCodec.decodeLanguageId(id)),
+			};
+		});
+
+		assert.deepStrictEqual(actual, [
+			{ languageId: 'typescript', registered: true, tokenCount: 11, encodedLanguageIds: ['typescript'] },
+			{ languageId: 'typescriptreact', registered: true, tokenCount: 16, encodedLanguageIds: ['typescriptreact', 'jsx-tags'] },
+			{ languageId: 'javascript', registered: true, tokenCount: 10, encodedLanguageIds: ['javascript'] },
+			{ languageId: 'javascriptreact', registered: true, tokenCount: 16, encodedLanguageIds: ['javascriptreact', 'jsx-tags'] },
+			{ languageId: 'json', registered: true, tokenCount: 5, encodedLanguageIds: ['json'] },
+			{ languageId: 'css', registered: true, tokenCount: 6, encodedLanguageIds: ['css'] },
+			{ languageId: 'html', registered: true, tokenCount: 11, encodedLanguageIds: ['html'] },
+		]);
+	});
+
+	test('uses Dark 2026 TextMate scope distinctions and generated token CSS', async () => {
+		const { host } = await createTokenizers();
+		const support = TokenizationRegistry.get('typescript')!;
+		const line = 'import value from "./value"; class Example { private readonly field = 1; } const result = value;';
+		const result = support.tokenizeEncoded(line, true, support.getInitialState());
+
+		assert.deepStrictEqual({
+			import: colorAt(result.tokens, line.indexOf('import')),
+			private: colorAt(result.tokens, line.indexOf('private')),
+			readonly: colorAt(result.tokens, line.indexOf('readonly')),
+			const: colorAt(result.tokens, line.indexOf('const')),
+			hasPurpleRule: host.querySelector('style')?.textContent?.includes('#c586c0'),
+			hasBlueRule: host.querySelector('style')?.textContent?.includes('#569cd6'),
+			hasCoralRule: host.querySelector('style')?.textContent?.includes('#ff7b72'),
+		}, {
+			import: '#c586c0',
+			private: '#569cd6',
+			readonly: '#569cd6',
+			const: '#ff7b72',
+			hasPurpleRule: true,
+			hasBlueRule: true,
+			hasCoralRule: true,
+		});
+	});
+
+	test('preserves multiline TextMate state and embedded language IDs', async () => {
+		const { languageService } = await createTokenizers();
+		const typescript = TokenizationRegistry.get('typescript')!;
+		const initialState = typescript.getInitialState();
+		const commentStart = typescript.tokenizeEncoded('/* first line', true, initialState);
+		const commentEndLine = 'continued */ const value = 1;';
+		const commentEnd = typescript.tokenizeEncoded(commentEndLine, true, commentStart.endState);
+
+		const html = TokenizationRegistry.get('html')!;
+		const scriptStart = html.tokenizeEncoded('<script>', true, html.getInitialState());
+		const embeddedScript = html.tokenizeEncoded('const value = 1;', true, scriptStart.endState);
+
+		assert.deepStrictEqual({
+			stateChanged: !commentStart.endState.equals(initialState),
+			continuedComment: colorAt(commentEnd.tokens, 0),
+			constAfterComment: colorAt(commentEnd.tokens, commentEndLine.indexOf('const')),
+			embeddedLanguages: distinctLanguageIds(embeddedScript.tokens).map(id => languageService.languageIdCodec.decodeLanguageId(id)),
+		}, {
+			stateChanged: true,
+			continuedComment: '#8b949e',
+			constAfterComment: '#ff7b72',
+			embeddedLanguages: ['javascript'],
+		});
+	});
+
+	test('uses monochrome token styles in non-Dark fixtures without affecting Dark', async () => {
+		const variants = [
+			{ name: 'Light', path: 'light_modern.json', uiTheme: ThemeTypeSelector.VS },
+			{ name: 'DarkHighContrast', path: 'hc_black.json', uiTheme: ThemeTypeSelector.HC_BLACK },
+			{ name: 'LightHighContrast', path: 'hc_light.json', uiTheme: ThemeTypeSelector.HC_LIGHT },
+			{ name: 'Dark', path: '2026-dark.json', uiTheme: ThemeTypeSelector.VS_DARK },
+		];
+		const rendered = [];
+		for (const variant of variants) {
+			const theme = ColorThemeData.fromExtensionTheme(
+				{ id: variant.name, path: variant.path, uiTheme: variant.uiTheme, _watch: false },
+				fixtureResourceUri(`extensions/theme-defaults/themes/${variant.path}`),
+				ExtensionData.fromName('vscode', 'theme-defaults', true),
+			);
+			await theme.ensureLoaded(themeLoader);
+			const { host } = await createTokenizers(theme);
+			const foreground = theme.getColor(editorForeground)!;
+			host.style.setProperty('--vscode-editor-foreground', foreground.toString());
+			host.style.font = '14px monospace';
+
+			const support = TokenizationRegistry.get('typescript')!;
+			const result = support.tokenizeEncoded('import value from "./value";', true, support.getInitialState());
+			const token = host.appendChild($(`span.mtk${TokenMetadata.getForeground(result.tokens[1])}.mtki.mtkb.mtku.mtks`));
+			token.textContent = 'import';
+			rendered.push({ name: variant.name, token, foreground });
+		}
+
+		assert.deepStrictEqual(rendered.map(({ name, token }) => {
+			const style = mainWindow.getComputedStyle(token);
+			return {
+				name,
+				color: style.color,
+				fontStyle: style.fontStyle,
+				fontWeight: style.fontWeight,
+				textDecoration: style.textDecorationLine,
+			};
+		}), rendered.map(({ name, foreground }) => ({
+			name,
+			color: name === 'Dark' ? 'rgb(197, 134, 192)' : Color.Format.CSS.formatRGB(foreground),
+			fontStyle: name === 'Dark' ? 'italic' : 'normal',
+			fontWeight: name === 'Dark' ? '700' : '400',
+			textDecoration: name === 'Dark' ? 'underline line-through' : 'none',
+		})));
+	});
+
+	test('retains shared tokenizers until the final fixture is disposed', async () => {
+		const previousColorMap = TokenizationRegistry.getColorMap();
+		const first = await createTokenizers();
+		const second = await createTokenizers();
+		const support = TokenizationRegistry.get('typescript');
+		first.store.dispose();
+
+		assert.deepStrictEqual({
+			retainedAfterFirstDispose: TokenizationRegistry.get('typescript') === support,
+			secondUsesCanonicalDarkCSS: second.host.querySelector('style')?.textContent?.includes('#ff7b72'),
+		}, {
+			retainedAfterFirstDispose: true,
+			secondUsesCanonicalDarkCSS: true,
+		});
+
+		second.store.dispose();
+		const finalColorMap = TokenizationRegistry.getColorMap();
+		const defaultBackground = TokenizationRegistry.getDefaultBackground();
+		assert.deepStrictEqual({
+			tokenizerRemoved: TokenizationRegistry.get('typescript') === null,
+			previousColorMapRestored: previousColorMap === null || (
+				finalColorMap?.length === previousColorMap.length
+				&& previousColorMap.every((color, index) => finalColorMap[index] === color)
+			),
+			defaultBackgroundLuminance: typeof defaultBackground?.getRelativeLuminance() === 'number',
+		}, {
+			tokenizerRemoved: true,
+			previousColorMapRestored: true,
+			defaultBackgroundLuminance: true,
+		});
+	});
+});
+
+function distinctLanguageIds(tokens: Uint32Array): number[] {
+	const result: number[] = [];
+	for (let index = 1; index < tokens.length; index += 2) {
+		const languageId = TokenMetadata.getLanguageId(tokens[index]);
+		if (!result.includes(languageId)) {
+			result.push(languageId);
+		}
+	}
+	return result;
+}
+
+function colorAt(tokens: Uint32Array, offset: number): string {
+	let metadata = tokens[1];
+	for (let index = 2; index < tokens.length && tokens[index] <= offset; index += 2) {
+		metadata = tokens[index + 1];
+	}
+	const color = TokenizationRegistry.getColorMap()?.[TokenMetadata.getForeground(metadata)];
+	assert.ok(color);
+	return color.toString();
+}
diff --git a/src/vs/workbench/test/browser/componentFixtures/fixtureSyntaxHighlighting.ts b/src/vs/workbench/test/browser/componentFixtures/fixtureSyntaxHighlighting.ts
new file mode 100644
index 00000000000000..8d9c2102f29504
--- /dev/null
+++ b/src/vs/workbench/test/browser/componentFixtures/fixtureSyntaxHighlighting.ts
@@ -0,0 +1,239 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createStyleSheet } from '../../../../base/browser/domStylesheets.js';
+import { Color } from '../../../../base/common/color.js';
+import { DisposableStore, IDisposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { ColorId, StandardTokenType } from '../../../../editor/common/encodedTokenAttributes.js';
+import { TokenizationRegistry } from '../../../../editor/common/languages.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { generateTokensCSSForColorMap, generateTokensCSSForFontMap } from '../../../../editor/common/languages/supports/tokenization.js';
+import { LanguageService } from '../../../../editor/common/services/languageService.js';
+import { ColorScheme } from '../../../../platform/theme/common/theme.js';
+import { IColorTheme } from '../../../../platform/theme/common/themeService.js';
+import { TMGrammarFactory } from '../../../services/textMate/common/TMGrammarFactory.js';
+import { IValidEmbeddedLanguagesMap, IValidGrammarDefinition, IValidTokenTypeMap } from '../../../services/textMate/common/TMScopeRegistry.js';
+import { TextMateTokenizationSupport } from '../../../services/textMate/browser/tokenizationSupport/textMateTokenizationSupport.js';
+import { ITextMateThemingRule } from '../../../services/themes/common/workbenchThemeService.js';
+// eslint-disable-next-line local/code-import-patterns, local/code-amd-node-module
+import * as vscodeOniguruma from 'vscode-oniguruma';
+// eslint-disable-next-line local/code-import-patterns, local/code-amd-node-module
+import * as vscodeTextmate from 'vscode-textmate';
+// eslint-disable-next-line local/code-import-patterns
+import type { IOnigLib, IRawTheme } from 'vscode-textmate';
+import { fixtureResourceUri, readFixtureBinaryResource, readFixtureTextResource } from './fixtureResourceLoader.js';
+
+const fixtureLanguageIds = [
+	'typescript',
+	'typescriptreact',
+	'javascript',
+	'javascriptreact',
+	'json',
+	'css',
+	'html',
+	'jsx-tags',
+] as const;
+
+const commonScriptTokenTypes: IValidTokenTypeMap = {
+	'punctuation.definition.template-expression': StandardTokenType.Other,
+	'entity.name.type.instance.jsdoc': StandardTokenType.Other,
+	'entity.name.function.tagged-template': StandardTokenType.Other,
+	'meta.import string.quoted': StandardTokenType.Other,
+	'variable.other.jsdoc': StandardTokenType.Other,
+};
+
+const grammarDescriptors: readonly FixtureGrammarDescriptor[] = [
+	{ language: 'typescript', scopeName: 'source.ts', path: 'extensions/typescript-basics/syntaxes/TypeScript.tmLanguage.json', tokenTypes: commonScriptTokenTypes, unbalancedBracketScopes: ['keyword.operator.relational', 'storage.type.function.arrow', 'keyword.operator.bitwise.shift', 'meta.brace.angle', 'punctuation.definition.tag', 'keyword.operator.assignment.compound.bitwise.ts'] },
+	{ language: 'typescriptreact', scopeName: 'source.tsx', path: 'extensions/typescript-basics/syntaxes/TypeScriptReact.tmLanguage.json', embeddedLanguages: { 'meta.tag.tsx': 'jsx-tags', 'meta.tag.without-attributes.tsx': 'jsx-tags', 'meta.tag.attributes.tsx': 'typescriptreact', 'meta.embedded.expression.tsx': 'typescriptreact' }, tokenTypes: commonScriptTokenTypes, unbalancedBracketScopes: ['keyword.operator.relational', 'storage.type.function.arrow', 'keyword.operator.bitwise.shift', 'punctuation.definition.tag', 'keyword.operator.assignment.compound.bitwise.ts'] },
+	{ scopeName: 'documentation.injection.ts', path: 'extensions/typescript-basics/syntaxes/jsdoc.ts.injection.tmLanguage.json', injectTo: ['source.ts', 'source.tsx'] },
+	{ scopeName: 'documentation.injection.js.jsx', path: 'extensions/typescript-basics/syntaxes/jsdoc.js.injection.tmLanguage.json', injectTo: ['source.js', 'source.js.jsx'] },
+	{ language: 'javascript', scopeName: 'source.js', path: 'extensions/javascript/syntaxes/JavaScript.tmLanguage.json', embeddedLanguages: { 'meta.tag.js': 'jsx-tags', 'meta.tag.without-attributes.js': 'jsx-tags', 'meta.tag.attributes.js': 'javascript', 'meta.embedded.expression.js': 'javascript' }, tokenTypes: commonScriptTokenTypes },
+	{ language: 'javascriptreact', scopeName: 'source.js.jsx', path: 'extensions/javascript/syntaxes/JavaScriptReact.tmLanguage.json', embeddedLanguages: { 'meta.tag.js': 'jsx-tags', 'meta.tag.without-attributes.js': 'jsx-tags', 'meta.tag.attributes.js.jsx': 'javascriptreact', 'meta.embedded.expression.js': 'javascriptreact' }, tokenTypes: commonScriptTokenTypes },
+	{ scopeName: 'source.js.regexp', path: 'extensions/javascript/syntaxes/Regular Expressions (JavaScript).tmLanguage' },
+	{ language: 'json', scopeName: 'source.json', path: 'extensions/json/syntaxes/JSON.tmLanguage.json' },
+	{ language: 'css', scopeName: 'source.css', path: 'extensions/css/syntaxes/css.tmLanguage.json', tokenTypes: { 'meta.function.url string.quoted': StandardTokenType.Other } },
+	{ scopeName: 'text.html.basic', path: 'extensions/html/syntaxes/html.tmLanguage.json', embeddedLanguages: { 'text.html': 'html', 'source.css': 'css', 'source.js': 'javascript' }, tokenTypes: { 'meta.tag string.quoted': StandardTokenType.Other } },
+	{ language: 'html', scopeName: 'text.html.derivative', path: 'extensions/html/syntaxes/html-derivative.tmLanguage.json', embeddedLanguages: { 'text.html': 'html', 'source.css': 'css', 'source.js': 'javascript' }, tokenTypes: { 'meta.tag string.quoted': StandardTokenType.Other } },
+];
+
+export interface FixtureSyntaxHighlightingTheme extends IColorTheme {
+	readonly tokenColors: ITextMateThemingRule[];
+}
+
+interface FixtureGrammarDescriptor {
+	readonly language?: string;
+	readonly scopeName: string;
+	readonly path: string;
+	readonly embeddedLanguages?: Readonly<Record<string, string>>;
+	readonly tokenTypes?: IValidTokenTypeMap;
+	readonly injectTo?: string[];
+	readonly unbalancedBracketScopes?: string[];
+}
+
+export function registerFixtureLanguages(disposables: DisposableStore, languageService: ILanguageService): void {
+	for (const languageId of fixtureLanguageIds) {
+		disposables.add(languageService.registerLanguage({ id: languageId }));
+	}
+}
+
+export async function registerFixtureSyntaxHighlighting(
+	disposables: DisposableStore,
+	fixtureHost: HTMLElement,
+	darkTheme: FixtureSyntaxHighlightingTheme,
+	theme: IColorTheme,
+): Promise<void> {
+	disposables.add(await fixtureTextMateTokenizers.acquire(darkTheme));
+	const colorMap = toColorMap(darkTheme.tokenColorMap);
+	const styleElement = createStyleSheet(fixtureHost, undefined, disposables);
+	const styles = theme.type === ColorScheme.DARK
+		? `${generateTokensCSSForColorMap(colorMap)}\n${generateTokensCSSForFontMap(darkTheme.tokenFontMap)}`
+		: `${colorMap.slice(1).map((_, index) => `.mtk${index + 1}`).join(', ')} { color: var(--vscode-editor-foreground); font: inherit; text-decoration: none; }`;
+	styleElement.textContent = `@scope {\n${styles}\n}`;
+}
+
+class FixtureTextMateTokenizers {
+	private _references = 0;
+	private _instancePromise: Promise<FixtureTextMateTokenizerInstance> | undefined;
+	private _instance: FixtureTextMateTokenizerInstance | undefined;
+
+	async acquire(darkTheme: FixtureSyntaxHighlightingTheme): Promise<IDisposable> {
+		this._references++;
+		try {
+			const instance = await (this._instancePromise ??= FixtureTextMateTokenizerInstance.create(darkTheme));
+			this._instance = instance;
+		} catch (error) {
+			this._references--;
+			this._instancePromise = undefined;
+			throw error;
+		}
+
+		let disposed = false;
+		return toDisposable(() => {
+			if (disposed) {
+				return;
+			}
+			disposed = true;
+			if (--this._references === 0) {
+				this._instance?.dispose();
+				this._instance = undefined;
+				this._instancePromise = undefined;
+			}
+		});
+	}
+}
+
+const fixtureTextMateTokenizers = new FixtureTextMateTokenizers();
+
+class FixtureTextMateTokenizerInstance implements IDisposable {
+	private constructor(
+		private readonly _store: DisposableStore,
+		private readonly _installedColorMap: readonly Color[],
+		private readonly _previousColorMap: readonly Color[] | null,
+	) { }
+
+	static async create(darkTheme: FixtureSyntaxHighlightingTheme): Promise<FixtureTextMateTokenizerInstance> {
+		const store = new DisposableStore();
+		try {
+			const languageService = store.add(new LanguageService());
+			registerFixtureLanguages(store, languageService);
+			const grammarDefinitions = createGrammarDefinitions(languageService);
+			const onigLib = await createOnigLib();
+			const grammarFactory = store.add(new TMGrammarFactory({
+				logTrace: () => { },
+				logError: (message, error) => console.error(message, error),
+				readFile: readFixtureTextResource,
+			}, grammarDefinitions, vscodeTextmate, Promise.resolve(onigLib)));
+			const rawTheme: IRawTheme = { name: darkTheme.label, settings: darkTheme.tokenColors };
+			grammarFactory.setTheme(rawTheme, darkTheme.tokenColorMap);
+
+			await Promise.all(fixtureLanguageIds.filter(languageId => grammarFactory.has(languageId)).map(async languageId => {
+				if (TokenizationRegistry.get(languageId)) {
+					return;
+				}
+				const encodedLanguageId = languageService.languageIdCodec.encodeLanguageId(languageId);
+				const result = await grammarFactory.createGrammar(languageId, encodedLanguageId);
+				if (!result.grammar) {
+					return;
+				}
+				const support = store.add(new TextMateTokenizationSupport(
+					result.grammar,
+					result.initialState,
+					result.containsEmbeddedLanguages,
+					undefined,
+					() => false,
+					() => { },
+					false,
+				));
+				store.add(TokenizationRegistry.register(languageId, support));
+			}));
+
+			const installedColorMap = toColorMap(grammarFactory.getColorMap());
+			const currentColorMap = TokenizationRegistry.getColorMap();
+			const previousColorMap = isValidColorMap(currentColorMap) ? currentColorMap : null;
+			TokenizationRegistry.setColorMap(installedColorMap);
+			return new FixtureTextMateTokenizerInstance(store, installedColorMap, previousColorMap);
+		} catch (error) {
+			store.dispose();
+			throw error;
+		}
+	}
+
+	dispose(): void {
+		if (this._previousColorMap && TokenizationRegistry.getColorMap() === this._installedColorMap) {
+			TokenizationRegistry.setColorMap([...this._previousColorMap]);
+		}
+		this._store.dispose();
+	}
+}
+
+function createGrammarDefinitions(languageService: ILanguageService): IValidGrammarDefinition[] {
+	return grammarDescriptors.map(descriptor => {
+		const embeddedLanguages: IValidEmbeddedLanguagesMap = {};
+		for (const [scope, languageId] of Object.entries(descriptor.embeddedLanguages ?? {})) {
+			embeddedLanguages[scope] = languageService.languageIdCodec.encodeLanguageId(languageId);
+		}
+		return {
+			location: fixtureResourceUri(descriptor.path),
+			language: descriptor.language,
+			scopeName: descriptor.scopeName,
+			embeddedLanguages,
+			tokenTypes: descriptor.tokenTypes ?? {},
+			injectTo: descriptor.injectTo,
+			balancedBracketSelectors: ['*'],
+			unbalancedBracketSelectors: descriptor.unbalancedBracketScopes ?? [],
+			sourceExtensionId: `vscode.${descriptor.path.split('/')[1]}`,
+		};
+	});
+}
+
+let onigLibPromise: Promise<IOnigLib> | undefined;
+
+function createOnigLib(): Promise<IOnigLib> {
+	return onigLibPromise ??= (async () => {
+		const wasm = await readFixtureBinaryResource(fixtureResourceUri('node_modules/vscode-oniguruma/release/onig.wasm'));
+		await vscodeOniguruma.loadWASM(wasm);
+		return {
+			createOnigScanner: (sources: string[]) => vscodeOniguruma.createOnigScanner(sources),
+			createOnigString: (value: string) => vscodeOniguruma.createOnigString(value),
+		};
+	})().catch(error => {
+		onigLibPromise = undefined;
+		throw error;
+	});
+}
+
+function toColorMap(colorMap: readonly string[]): Color[] {
+	const result: Color[] = [null!];
+	for (let index = 1; index < colorMap.length; index++) {
+		result[index] = Color.fromHex(colorMap[index]);
+	}
+	return result;
+}
+
+function isValidColorMap(colorMap: readonly Color[] | null): colorMap is readonly Color[] {
+	return !!colorMap
+		&& colorMap.length > ColorId.DefaultBackground
+		&& colorMap.slice(1).every(color => !!color);
+}
diff --git a/src/vs/workbench/test/browser/componentFixtures/fixtureUtils.ts b/src/vs/workbench/test/browser/componentFixtures/fixtureUtils.ts
index 5080a90a36d299..592e5a3510ca95 100644
--- a/src/vs/workbench/test/browser/componentFixtures/fixtureUtils.ts
+++ b/src/vs/workbench/test/browser/componentFixtures/fixtureUtils.ts
@@ -117,6 +117,7 @@ import { IPreferencesService } from '../../../services/preferences/common/prefer
 // Editor
 import { ITextModel } from '../../../../editor/common/model.js';
 import { applyFixtureFocus, createFixtureUserInteractionService } from './fixtureFocus.js';
+import { registerFixtureLanguages, registerFixtureSyntaxHighlighting } from './fixtureSyntaxHighlighting.js';
 
 export { applyFixtureFocus, createFixtureUserInteractionService };
 
@@ -645,7 +646,9 @@ export function createEditorServices(disposables: DisposableStore, options?: Cre
 	define(INotificationService, TestNotificationService);
 	define(IDialogService, TestDialogService);
 	define(IUndoRedoService, UndoRedoService);
-	define(ILanguageService, LanguageService);
+	const languageService = disposables.add(new LanguageService());
+	registerFixtureLanguages(disposables, languageService);
+	defineInstance(ILanguageService, languageService);
 	define(ILanguageConfigurationService, TestLanguageConfigurationService);
 	define(IConfigurationService, TestConfigurationService);
 	define(ITextResourcePropertiesService, TestTextResourcePropertiesService);
@@ -935,7 +938,9 @@ export function createTextModel(
 	const modelService = instantiationService.get(IModelService);
 	const languageService = instantiationService.get(ILanguageService);
 	const languageSelection = languageId ? languageService.createById(languageId) : null;
-	return modelService.createModel(text, languageSelection, uri);
+	const model = modelService.createModel(text, languageSelection, uri);
+	model.tokenization.forceTokenization(model.getLineCount());
+	return model;
 }
 
 
@@ -1133,7 +1138,6 @@ export function defineComponentFixture(options: ComponentFixtureOptions): Themed
 							await p.run({
 								until: untilTime(clock.now + teardownDrainMs),
 								maxEvents: 1000,
-								maxTraceDepth: 5,
 							});
 						} catch (e) {
 							console.error(`[ComponentFixture] error draining virtual time during teardown: ${e instanceof Error ? e.stack : e}`);
@@ -1154,7 +1158,11 @@ export function defineComponentFixture(options: ComponentFixtureOptions): Themed
 			});
 
 			async function actualRender() {
-				const fileIconTheme = await setupTheme(container, theme, options.fileIconTheme, fixtureHost);
+				const [fileIconTheme] = await Promise.all([
+					setupTheme(container, theme, options.fileIconTheme, fixtureHost),
+					ensureThemeLoaded(darkTheme),
+				]);
+				await registerFixtureSyntaxHighlighting(disposableStore, fixtureHost, darkTheme, theme);
 
 				const stylesheetOrderOverride = disposableStore.add(new MutableDisposable<IDisposable>());
 				const updateStylesheetOrder = (input: unknown) => {
@@ -1212,7 +1220,6 @@ export function defineComponentFixture(options: ComponentFixtureOptions): Themed
 						? p.run({
 							until: untilTime(clock.now + (options.virtualTime?.durationMs ?? 1000)),
 							maxEvents: 200,
-							maxTraceDepth: 5,
 						})
 						: Promise.resolve();
 
diff --git a/test/componentFixtures/blocks-ci-screenshots.md b/test/componentFixtures/blocks-ci-screenshots.md
index a9c5556299711a..cbe4a5c8e56d16 100644
--- a/test/componentFixtures/blocks-ci-screenshots.md
+++ b/test/componentFixtures/blocks-ci-screenshots.md
@@ -199,10 +199,10 @@
 ![screenshot](https://hediet-screenshots.azurewebsites.net/images/b4e697f87416c5f384d7dd0338fcf76ca128bf695efa96ed885abc124a8736e1)
 
 #### editor/codeEditor/CodeEditor/Dark
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/1221f368f7cbba0ca39ae6916383223b9b7a546da2dba40c22a157d25e0f0b44)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/b4617f74b50a09295a5151a0d53481c37a53839f94f23f6e7d0a5a6159a7a231)
 
 #### editor/codeEditor/CodeEditor/Light
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/89b2d50f5bd33feaa20b3c8f83f3d83548fda48b6f85cd7d784460aafaeeb596)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/10e1881a8125f12fa8a45164f5bda6b55319bd0dad93e465246b407bed6bc3e1)
 
 #### editor/fullwidthCharacterWidth/FullwidthCharacterWidthClassification/Dark
 ![screenshot](https://hediet-screenshots.azurewebsites.net/images/92340a8ea9c540e02cfb4de7dbf8614464773a7c0995820650a4f8d2f9a815ba)
@@ -241,40 +241,40 @@
 ![screenshot](https://hediet-screenshots.azurewebsites.net/images/07cc96d028f69fd9609b88fa23b1c087cde223393dd0fd9ad6341e480068db95)
 
 #### editor/injectedTextDecorations/ColorDecorators/Dark
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/14128ed8c48767f7d1da7686d6323c673585559e828c261de1976e752dfc4e0d)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/15bccf97b15ae64f26121c0893b889a7ab19cc834bdbe771d0527f0a997c49b8)
 
 #### editor/injectedTextDecorations/ColorDecorators/Light
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/96c71d6072b20e0b9a75089789af194cd503fce1585d013491a57613ede6c96d)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/ca4563d37cccd40a5f49e1d6075dde7bbf085b718ca52a3e22d91e5d951242d2)
 
 #### editor/injectedTextDecorations/InlayHints/Dark
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/2afcdca90960661c8a322d51d240483a85ea996ca0cf47fcd4188fcbb3338bd0)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/c857a196daad3ec04aea7f7f1cf292321735549a2ad42a9b7fdb83a6f1c2a860)
 
 #### editor/injectedTextDecorations/InlayHints/Light
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/8a9cc16b16476f8fad3c5e5a0fef7f5467624610b44b3929b30759f4ae90f536)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/76ab9ccd41b2b1a400c2feece58e56e8f49cad84023ed07708305e2ed75db8f5)
 
 #### editor/injectedTextDecorations/InlineProgress/Dark
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/ea996024c68f38992a0c698f35b94b469d537e502503979ae2e3d067c1d3ce5e)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/53099b4cbb5111c9cc1060cb560ce717d687cc73ccfc2522571a9ecd43dbf6d7)
 
 #### editor/injectedTextDecorations/InlineProgress/Light
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/4810c9ab74a193cc722de9f7d3fe7c3bffbf878d65da6c1b6e11cf4fb626ce1e)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/4aaae3363f8f4637ecde8de278eefc8a04f04a70f0ba6567309d9e8c76e8a260)
 
 #### editor/injectedTextDecorations/SelectedColorDecorator/Dark
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/64b74a3c76c0c01740cc8c06a561150e634436fd619eaeaae05e954cb85202d2)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/87594d2357221a163289df3c4d826ddff7e92112cf259d78b21d8788c0d93710)
 
 #### editor/injectedTextDecorations/SelectedColorDecorator/Light
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/7f70224f7733a2461eba63fa98234aab38b8804a73460deffa11f49cd6f7172c)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/dbcdd1e5ca6920f0f0b5fd6a97126465912cfa12d26007b125e831636f3c11c8)
 
 #### editor/inlineChatZoneWidget/InlineChatZoneWidget/Dark
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/e8dcc0cf3606a864d5ef57bafefe983086de45f43e63b786a6f11bed12c04e94)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/935fccd2015c4b87e42ed8deca53143eca7f90e29908e87ad5efbed27e3cb6ce)
 
 #### editor/inlineChatZoneWidget/InlineChatZoneWidget/Light
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/a6412a92ec5265fe65d714be9a9af4e0feb95fed7378ca1477629fb2391485a0)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/149a3762c5eef80f2a1c74385c9d45871821de012a9cc36ecaa8d22858ac1ad2)
 
 #### editor/inlineChatZoneWidget/InlineChatZoneWidgetTerminated/Dark
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/862d9082aa65eddbe31a5c9ce87841df1f3fc29389c2f1ec1282b1fe08902eda)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/cc1638d294072922eb21dd4f90435744db32b35e7bbdcc2f5cbcbbaf07ee1e36)
 
 #### editor/inlineChatZoneWidget/InlineChatZoneWidgetTerminated/Light
-![screenshot](https://hediet-screenshots.azurewebsites.net/images/a29cfc0bf4510b57c82d9eae0d974babe7035042456326be861308cae609a1b5)
+![screenshot](https://hediet-screenshots.azurewebsites.net/images/8d8b39f9a3dd85453ad1594df888c7ac1908d5c7ed80a5b15238d818a89aeb1b)
 
 #### sessions/accountMenu/petAchievementBadges/chatPetAchievementBadges/AllBadges/Dark
 ![screenshot](https://hediet-screenshots.azurewebsites.net/images/1e3ddc3ee992c5ce9561c6b3a473ec3036675a5582c8a6ddb931da6095cb5d37)