@master/css-mcp 2.0.0-rc.88 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Master CSS MCP Server
 
-Model Context Protocol server for Master CSS tooling. It lets AI clients inspect a Master CSS workspace, audit setup, read the active project manifest, inspect CSS-first directives, trace classes through extraction and generated CSS, render or compare CSS output, run lint diagnostics, request syntax suggestions, apply reviewed fix previews, and route Master CSS repository contributor work through deterministic context tools.
+Model Context Protocol server for Master CSS tooling. It lets AI clients inspect a Master CSS workspace, audit setup, read the active project manifest, inspect CSS-first directives, trace classes through extraction and generated CSS, render or compare CSS output, run lint diagnostics, request syntax suggestions, and apply reviewed fix previews.
 
 ## Installation
 
@@ -11,7 +11,7 @@ npm install -D @master/css-mcp
 You can also run it directly:
 
 ```bash
-npx -y @master/css-mcp@rc --root /absolute/path/to/project
+npx -y @master/css-mcp@latest --root /absolute/path/to/project
 ```
 
 ## MCP client config
@@ -23,7 +23,7 @@ Most MCP clients accept a command and arguments for stdio servers:
   "mcpServers": {
     "master-css": {
       "command": "npx",
-      "args": ["-y", "@master/css-mcp@rc", "--root", "/absolute/path/to/project"]
+      "args": ["-y", "@master/css-mcp@latest", "--root", "/absolute/path/to/project"]
     }
   }
 }
@@ -35,6 +35,7 @@ Use an absolute `--root` path so the server resolves the intended workspace.
 
 | Tool | Use |
 | --- | --- |
+| `mastercss_suggest_classes` | Suggest project-aware classes for an isolated CSS declaration block without writing files. Preserves the block when conversion needs review; checks declaration output, not surrounding cascade or browser rendering. |
 | `mastercss_workspace_info` | Report workspace roots, resolved packages, and manifest status. |
 | `mastercss_setup_audit` | Audit package, entry stylesheet, manifest, integration, and package-resolution setup. |
 | `mastercss_inspect_class` | Inspect one class and return generated rules and CSS text. |
@@ -42,9 +43,9 @@ Use an absolute `--root` path so the server resolves the intended workspace.
 | `mastercss_extract_classes` | Extract class positions and validation summaries from files or an in-memory source buffer. |
 | `mastercss_inspect_directives` | Inspect CSS-first directives and report manifest, dependency, warning, and CSS effects. |
 | `mastercss_render_css` | Generate CSS from HTML or a class list. |
-| `mastercss_scan_project` | Scan sources, check optional classes, and report scanner state, stylesheet entries, generated CSS metadata, and missing CSS diagnostics. |
-| `mastercss_manifest_query` | Query active manifest tokens, utilities, variants, modes, conditions, and aliases. |
-| `mastercss_css_compare` | Compare generated CSS for before/after class lists, HTML fragments, or source buffers. |
+| `mastercss_scan_project` | Scan sources, check optional classes, and report scanner state, stylesheet entries, generated CSS metadata, and missing CSS diagnostics. Optionally inspect stylesheet token references and design policies. |
+| `mastercss_manifest_query` | Query active manifest tokens, utilities, mixins, custom media, and token families. |
+| `mastercss_css_compare` | Compare class/content output under one manifest, or two resolved project snapshots including definition changes and known consumers. |
 | `mastercss_lint_project` | Run class-list diagnostics for workspace files without writing files. |
 | `mastercss_lint_content` | Run class-list diagnostics on an in-memory source buffer without writing files. |
 | `mastercss_suggest_syntax` | Return language-service completions and hover context. |
@@ -52,16 +53,33 @@ Use an absolute `--root` path so the server resolves the intended workspace.
 | `mastercss_preview_directive_format` | Preview Master CSS directive formatting for files, or format in-memory content without writing. |
 | `mastercss_apply_preview` | Apply a preview after token, hash, and workspace checks. |
 
-## Contributor tools
+`@theme` defines utility tokens with direct custom-property declarations and optional `static` / `inline` modifiers. Native CSS controls scoped overrides and does not add utility candidates. Directive inspection and manifest queries report the same Rust-backed contract as the compiler and language service.
 
-These read-only tools are for Master CSS repository contributors, AI coding agents, review bots, and CI support. They expose repository-specific routing as low-token JSON instead of asking an agent to repeatedly infer package ownership, risk, and validation from raw files. In non-Master CSS workspaces they return limited package data instead of guessing.
+## Inspect token use in stylesheets
 
-| Tool | Use |
-| --- | --- |
-| `mastercss_repo_context` | Route changed paths or a diff to affected packages, required context files, risks, and validation commands. |
-| `mastercss_change_impact` | Summarize contributor change risk for CSS output, runtime, extraction, language tooling, ESLint, docs, and package boundaries. |
-| `mastercss_test_router` | Return focused validation commands for contributor changes. |
-| `mastercss_package_graph` | Report workspace package ownership, scripts, exports, workspace dependencies, and dependents. |
+Pass `designSystem` to `mastercss_scan_project` with the default project context to include a version 1 report in `result.data.designSystem`. This option cannot be combined with `context: "preset"`:
+
+```json
+{
+  "designSystem": {
+    "version": 1,
+    "metadata": {
+      "--color-brand-old": {
+        "description": "Previous brand color",
+        "deprecated": true,
+        "replacement": "--color-brand"
+      }
+    },
+    "rawValuePolicy": {
+      "requireProperties": ["color", "background-color"]
+    }
+  }
+}
+```
+
+The report covers project-owned CSS reached from the project's Master CSS entries, plus any `routeStylesheets` globs for stylesheets imported from JavaScript. It includes authored `var()` reference ranges in UTF-16 offsets, selector and at-rule ancestry, source importers, token-family collisions, each component class's attribute vocabulary (`components`), and diagnostics for the supplied metadata and raw-value policy. Ordinary native CSS can reference the same `@theme` tokens as Master CSS classes. Unregistered custom properties may come from native CSS or inheritance and are not automatically missing-token errors.
+
+Metadata and policies are analysis inputs: they do not change generated CSS, manifests, or runtime programs. Unrecognized option fields are rejected. Omit `rawValuePolicy` to skip native declaration raw-value checks. Read `project.excluded` and `coverage`: package sources and files outside the project root are excluded, importer links include reference-only context, and the report does not establish DOM usage, cascade winners, computed styles, or browser behavior. `includeSnapshot` remains available in the same call.
 
 ## Prompt templates
 
@@ -69,21 +87,28 @@ These read-only tools are for Master CSS repository contributors, AI coding agen
 | --- | --- |
 | `debug-missing-css` | Debug scanner coverage, manifest loading, invalid syntax, native CSS pruning, and stylesheet entry configuration. |
 | `review-mastercss-classes` | Review class lists and propose only safe, scoped write previews. |
-| `migrate-to-mastercss` | Audit an existing styling system and produce an incremental migration plan before editing. |
-
-Use `migrate-to-mastercss` when an MCP-capable AI client is helping migrate CSS, CSS Modules, Sass, Tailwind CSS, CSS-in-JS, component-library styling, or Master CSS v1. The prompt asks the agent to inspect the workspace first, identify stylesheet entries and source extraction coverage, recommend a rendering mode, choose the first reviewable migration batch, and list validation commands and visual review risks.
-
-The migration prompt is a planning workflow, not a one-shot converter. Keep the previous styling system in place until each migrated slice builds, runs, and visually matches the old UI.
+| `migrate-to-mastercss` | Plan a conversion from CSS, CSS Modules, Sass, Tailwind CSS, CSS-in-JS or component-library styling to current Master CSS. |
 
 ## Machine-readable results
 
-Project scan, lint, setup audit, directive inspection, class extraction, class tracing, CSS comparison, manifest query, and contributor routing reports use `version: 1`. Tooling can rely on stable top-level fields such as `version`, `root`, `manifest`, `inputs`, `files`, `diagnostics`, `risks`, `validation`, and `summary` when present. Nested diagnostic `data` objects may gain additional fields over time.
+Every tool returns a `version: 3` envelope with `metadata`, `diagnostics` and `result`. Success data lives in `result.data`; failures have `result.status: "error"` and an error code and message, and set MCP `isError`. JSON text matches `structuredContent`. Metadata identifies the actual context, manifest and package contracts; read the tool’s published output schema for its payload.
 
 ## Safety
 
 Read-only tools do not write files. File writes use a two-step preview/apply flow, validate workspace containment, and verify original file hashes before writing. Lint fixes, generated CSS output writes, and directive formatting for files all use preview tokens before `mastercss_apply_preview` can write anything.
 
+Concurrent applies coordinate across MCP processes for the same OS user through a local lock directory under `~/.cache/mastercss`. Hash validation and writes run one apply at a time across all workspace roots. A waiting apply times out after 30 seconds without taking over a live writer; its token can be retried until it expires. External editors do not participate in this lock, so edits made after hash validation can still race with apply. Multi-file writes are sequential and do not provide rollback or crash atomicity.
+
 ## Related docs
 
-- [MCP Server guide](https://rc.css.master.co/guide/mcp-server)
-- [AI Coding guide](https://rc.css.master.co/guide/ai-coding)
+- [MCP Server guide](https://css.master.co/guide/ai-coding#connect-the-mcp-server)
+- [AI Coding guide](https://css.master.co/guide/ai-coding)
+
+
+## Compare a project before and after editing
+
+Call `mastercss_scan_project` with `includeSnapshot: true` before editing and save `result.data.snapshot`. Repeat after editing, then pass the two objects to `mastercss_css_compare` as `beforeSnapshot` and `afterSnapshot`. Both are required; snapshot inputs cannot be mixed with class/content, `filePath` or `context` inputs.
+
+The project result is `{ version: 3, mode: 'project', comparison }` inside the usual version 3 envelope. `comparison.version` is 1. It reports changed definitions, known class consumers and files, before/after generated rules, native references, output assets and delivery order. Read `coverage` even when there are no differences: dynamic sources, remote content, binary assets and final browser behavior are not exhaustively checked. Native consumers are conservative at stylesheet granularity.
+
+These tools use the installed compiler. Check workspace package versions, language/binding versions and manifest metadata before using documentation or examples; use the project-local, lockfile-pinned MCP package for reproducible sessions.

package/dist/bin/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { startStdioServer } from "../server.js";
+import { startMasterCSSMCPStdioServer } from "../server.js";
+import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { readFileSync } from "node:fs";
-//#region src/bin/index.ts
+// src/bin/index.ts
 function readPackageVersion() {
 	const directory = dirname(fileURLToPath(import.meta.url));
 	try {
@@ -51,10 +51,9 @@ function parseArgs(argv) {
 	return options;
 }
 try {
-	await startStdioServer(parseArgs(process.argv.slice(2)));
+	await startMasterCSSMCPStdioServer(parseArgs(process.argv.slice(2)));
 } catch (error) {
 	console.error(error instanceof Error ? error.message : String(error));
 	process.exit(1);
 }
-//#endregion
 export {};

package/dist/classes.js

@@ -1,52 +1,17 @@
-import { createMCPTextDocument, getLanguageId } from "./document.js";
-import { loadWorkspaceManifest } from "./project.js";
+import { loadWorkspaceManifest, manifestMetadata, requireWorkspaceManifest } from "./project.js";
+import { compactClassInspection, createMCPToolingSession } from "./tooling-session.js";
 import { resolveSourceFiles, scanProject } from "./scan.js";
-import { createRequire } from "node:module";
+import { createMCPTextDocument, getLanguageId } from "./document.js";
 import { readFile } from "node:fs/promises";
-import CSSLanguageService from "@master/css-language-service";
-import { inspectMasterCSSClass } from "@master/css-engine/inspect";
-import { createCSSWithNativeDeclarations } from "@master/css-validator/native-declaration";
-//#region src/classes.ts
+// src/classes.ts
 const CLASS_EXTRACTION_VERSION = 1;
 const CLASS_TRACE_VERSION = 1;
-const defaultManifest = createRequire(import.meta.url)("@master/css-preset/default-manifest.json");
-async function createCSS(context) {
-	const manifest = await loadWorkspaceManifest(context);
+async function createClassInspectionState(context, options = {}) {
+	const manifest = await loadWorkspaceManifest(context, options.context);
+	const activeManifest = requireWorkspaceManifest(manifest);
 	return {
 		manifest,
-		css: createCSSWithNativeDeclarations(manifest.status === "loaded" ? manifest.manifest : defaultManifest)
-	};
-}
-function createLanguageService(manifest) {
-	return new CSSLanguageService(manifest.status === "loaded" ? { manifest: manifest.manifest } : void 0);
-}
-function compactInspection(css, className, mode, includeRules = false) {
-	const inspection = inspectMasterCSSClass(css, className, mode);
-	return {
-		valid: inspection.rules.length > 0,
-		base: inspection.base,
-		suffix: inspection.suffix,
-		key: inspection.key,
-		value: inspection.value,
-		keyToken: inspection.keyToken,
-		valueToken: inspection.valueToken,
-		stateToken: inspection.stateToken,
-		important: inspection.important,
-		matcherTypes: inspection.matcherTypes,
-		variables: inspection.variableEntries.map(({ key, variable }) => ({
-			key,
-			variable
-		})),
-		rules: includeRules ? inspection.rules.map((rule) => ({
-			className: rule.name,
-			layer: rule.layerName,
-			type: rule.type,
-			text: rule.text
-		})) : inspection.rules.map((rule) => ({
-			className: rule.name,
-			layer: rule.layerName,
-			type: rule.type
-		}))
+		session: await createMCPToolingSession(activeManifest, manifest.nativeClassNames)
 	};
 }
 function classifyExtractedClass(token, inspection, discovered) {
@@ -54,100 +19,118 @@ function classifyExtractedClass(token, inspection, discovered) {
 	if (discovered?.usedNative.includes(token)) return "native-css";
 	if (discovered?.invalid.includes(token)) return "invalid";
 	if (discovered?.latent.includes(token)) return "latent";
-	return inspection.valid ? "generated" : "unknown";
+	return inspection.matchStatus === "matched" ? "generated" : "unknown";
 }
-function extractFromContent(service, css, filePath, content, includeRules, discovered) {
+function extractFromContent(session, filePath, content, includeRules, discovered) {
 	const document = createMCPTextDocument(filePath, content);
-	return service.getClassPositions(document).map((position) => {
-		const inspection = compactInspection(css, position.token, void 0, includeRules);
-		return {
-			raw: position.raw,
-			token: position.token,
-			range: position.range,
-			loc: {
-				start: document.positionAt(position.range.start),
-				end: document.positionAt(position.range.end)
-			},
-			contextRange: position.contextRange,
-			sourceKind: "class-position",
-			status: classifyExtractedClass(position.token, inspection, discovered),
-			valid: inspection.valid,
-			inspection
-		};
+	const extracted = session.extractSource({ files: [{
+		source: filePath,
+		content
+	}] }).files[0];
+	if (extracted.diagnostics.length) throw Object.assign(new Error(extracted.diagnostics[0].message), {
+		code: "SOURCE_PARSE_ERROR",
+		diagnostics: extracted.diagnostics
 	});
+	return {
+		classes: extracted.occurrences.filter((occurrence) => occurrence.included).map((occurrence) => {
+			const position = {
+				token: occurrence.candidate,
+				range: occurrence.range,
+				raw: content.slice(occurrence.range.start, occurrence.range.end),
+				contextRange: occurrence.contextRange
+			};
+			const inspection = compactClassInspection(session, position.token, includeRules);
+			return {
+				raw: position.raw,
+				token: position.token,
+				range: position.range,
+				loc: {
+					start: document.positionAt(position.range.start),
+					end: document.positionAt(position.range.end)
+				},
+				contextRange: position.contextRange,
+				sourceKind: occurrence.contentKind,
+				provenance: occurrence,
+				status: classifyExtractedClass(position.token, inspection, discovered),
+				matchStatus: inspection.matchStatus,
+				cssSyntaxStatus: inspection.cssSyntaxStatus,
+				cssValueStatus: inspection.cssValueStatus,
+				browserSupport: inspection.browserSupport,
+				inspection
+			};
+		}),
+		occurrences: extracted.occurrences
+	};
 }
 async function extractClasses(context, options = {}) {
-	const { manifest, css } = await createCSS(context);
-	const service = createLanguageService(manifest);
+	const { manifest, session } = await createClassInspectionState(context, options);
 	const includeRules = Boolean(options.includeRules);
-	if (options.content !== void 0) {
-		const filePath = context.resolveVirtualPath(options.filePath || "index.html");
-		const classes = extractFromContent(service, css, filePath, options.content, includeRules);
+	try {
+		if (options.content !== void 0) {
+			const filePath = context.resolveVirtualPath(options.filePath || "index.html");
+			const extracted = extractFromContent(session, filePath, options.content, includeRules);
+			const { classes } = extracted;
+			return {
+				version: CLASS_EXTRACTION_VERSION,
+				root: context.root,
+				manifest: manifestMetadata(manifest),
+				inputs: {
+					mode: "content",
+					filePath
+				},
+				files: [{
+					filePath,
+					languageId: getLanguageId(filePath),
+					...extracted
+				}],
+				summary: {
+					files: 1,
+					classes: classes.length,
+					matched: classes.filter((className) => className.matchStatus === "matched").length,
+					unmatched: classes.filter((className) => className.matchStatus !== "matched").length
+				}
+			};
+		}
+		const filePaths = await resolveSourceFiles(context, options.patterns);
+		const scan = await scanProject(context, {
+			context: options.context,
+			patterns: options.patterns,
+			includeCss: false
+		});
+		const scanFileByPath = new Map(scan.files.map((file) => [file.filePath, file]));
+		const files = await Promise.all(filePaths.map(async (filePath) => {
+			const content = await readFile(filePath, "utf8");
+			const discovered = scanFileByPath.get(filePath)?.discovered;
+			return {
+				filePath,
+				languageId: getLanguageId(filePath),
+				...extractFromContent(session, filePath, content, includeRules, discovered)
+			};
+		}));
+		const classes = files.flatMap((file) => file.classes);
 		return {
 			version: CLASS_EXTRACTION_VERSION,
 			root: context.root,
-			manifest: {
-				status: manifest.status,
-				entries: manifest.entries,
-				...manifest.status === "error" ? { error: manifest.error } : {}
-			},
+			manifest: manifestMetadata(manifest),
 			inputs: {
-				mode: "content",
-				filePath
+				mode: "project",
+				patterns: options.patterns ?? scan.inputs.patterns,
+				files: filePaths
 			},
-			files: [{
-				filePath,
-				languageId: getLanguageId(filePath),
-				classes
-			}],
+			files,
+			scanner: { counts: scan.scanner.counts },
+			diagnostics: scan.diagnostics,
 			summary: {
-				files: 1,
+				files: files.length,
 				classes: classes.length,
-				valid: classes.filter((className) => className.valid).length,
-				invalid: classes.filter((className) => !className.valid).length
+				matched: classes.filter((className) => className.matchStatus === "matched").length,
+				unmatched: classes.filter((className) => className.matchStatus !== "matched").length,
+				diagnostics: scan.summary.diagnostics
 			}
 		};
+	} finally {
+		session.dispose?.();
 	}
-	const filePaths = await resolveSourceFiles(context, options.patterns);
-	const scan = await scanProject(context, {
-		patterns: options.patterns,
-		includeCss: false
-	});
-	const scanFileByPath = new Map(scan.files.map((file) => [file.filePath, file]));
-	const files = await Promise.all(filePaths.map(async (filePath) => {
-		const content = await readFile(filePath, "utf8");
-		const discovered = scanFileByPath.get(filePath)?.discovered;
-		return {
-			filePath,
-			languageId: getLanguageId(filePath),
-			classes: extractFromContent(service, css, filePath, content, includeRules, discovered)
-		};
-	}));
-	const classes = files.flatMap((file) => file.classes);
-	return {
-		version: CLASS_EXTRACTION_VERSION,
-		root: context.root,
-		manifest: {
-			status: manifest.status,
-			entries: manifest.entries,
-			...manifest.status === "error" ? { error: manifest.error } : {}
-		},
-		inputs: {
-			mode: "project",
-			patterns: options.patterns ?? scan.inputs.patterns,
-			files: filePaths
-		},
-		files,
-		scanner: { counts: scan.scanner.counts },
-		diagnostics: scan.diagnostics,
-		summary: {
-			files: files.length,
-			classes: classes.length,
-			valid: classes.filter((className) => className.valid).length,
-			invalid: classes.filter((className) => !className.valid).length,
-			diagnostics: scan.summary.diagnostics
-		}
-	};
 }
 function findClassOccurrences(report, className) {
 	return report.files.flatMap((file) => {
@@ -169,56 +152,58 @@ async function traceClass(context, options) {
 	const [scan, state] = await Promise.all([scanProject(context, {
 		patterns: options.patterns,
 		classes: [options.className],
-		includeCss: options.includeCss
-	}), createCSS(context)]);
-	const inspection = compactInspection(state.css, options.className, options.mode, true);
-	const missingResult = [...scan.missingCSS.present, ...scan.missingCSS.missing].find((result) => result.className === options.className);
-	const occurrences = findClassOccurrences(scan, options.className);
-	const status = missingResult?.status ?? (inspection.valid ? "present" : "missing");
-	const reason = missingResult?.reason ?? (inspection.valid ? "generated" : "not-detected");
-	return {
-		version: CLASS_TRACE_VERSION,
-		root: context.root,
-		manifest: {
-			status: state.manifest.status,
-			entries: state.manifest.entries,
-			...state.manifest.status === "error" ? { error: state.manifest.error } : {}
-		},
-		inputs: {
+		includeCss: options.includeCss,
+		context: options.context
+	}), createClassInspectionState(context, options)]);
+	try {
+		const inspection = compactClassInspection(state.session, options.className, true);
+		const missingResult = [...scan.missingCSS.present, ...scan.missingCSS.missing].find((result) => result.className === options.className);
+		const occurrences = findClassOccurrences(scan, options.className);
+		const status = missingResult?.status ?? (inspection.matchStatus === "matched" ? "present" : "missing");
+		const reason = missingResult?.reason ?? (inspection.matchStatus === "matched" ? "generated" : "not-detected");
+		return {
+			version: CLASS_TRACE_VERSION,
+			root: context.root,
+			manifest: manifestMetadata(state.manifest),
+			inputs: {
+				className: options.className,
+				patterns: options.patterns ?? scan.inputs.patterns
+			},
 			className: options.className,
-			patterns: options.patterns ?? scan.inputs.patterns,
-			mode: options.mode
-		},
-		className: options.className,
-		status,
-		reason,
-		detected: occurrences.length > 0,
-		occurrences,
-		inspection,
-		scanner: {
-			counts: scan.scanner.counts,
-			safelist: scan.scanner.classes.safelist.includes(options.className),
-			blocklist: scan.scanner.classes.blocklist.includes(options.className)
-		},
-		css: {
-			included: scan.css.included,
-			bytes: scan.css.bytes,
-			emittedGlobals: scan.css.emittedGlobals,
-			...scan.css.text !== void 0 ? { text: scan.css.text } : {}
-		},
-		diagnostics: scan.diagnostics.filter((diagnostic) => {
-			if (diagnostic.sourceKind === "missing-css") return diagnostic.data?.className === options.className;
-			return diagnostic.message.includes(options.className);
-		}),
-		summary: {
 			status,
 			reason,
 			detected: occurrences.length > 0,
-			valid: inspection.valid,
-			rules: inspection.rules.length,
-			diagnostics: scan.diagnostics.length
-		}
-	};
+			occurrences,
+			inspection,
+			scanner: {
+				counts: scan.scanner.counts,
+				safelist: scan.scanner.classes.safelist.includes(options.className),
+				blocklist: scan.scanner.classes.blocklist.includes(options.className)
+			},
+			css: {
+				included: scan.css.included,
+				bytes: scan.css.bytes,
+				emittedGlobals: scan.css.emittedGlobals,
+				...scan.css.text !== void 0 ? { text: scan.css.text } : {}
+			},
+			diagnostics: scan.diagnostics.filter((diagnostic) => {
+				if (diagnostic.sourceKind === "missing-css") return diagnostic.data?.className === options.className;
+				return diagnostic.message.includes(options.className);
+			}),
+			summary: {
+				status,
+				reason,
+				detected: occurrences.length > 0,
+				matchStatus: inspection.matchStatus,
+				cssSyntaxStatus: inspection.cssSyntaxStatus,
+				cssValueStatus: inspection.cssValueStatus,
+				browserSupport: inspection.browserSupport,
+				rules: inspection.rules.length,
+				diagnostics: scan.diagnostics.length
+			}
+		};
+	} finally {
+		state.session.dispose?.();
+	}
 }
-//#endregion
 export { extractClasses, traceClass };