@prisma-next/language-server 0.14.0-dev.21 → 0.14.0-dev.23

package/README.md

@@ -1,45 +1,48 @@
 # @prisma-next/language-server
 
-> **Internal package.** This package is an implementation detail of [`prisma-next`](https://www.npmjs.com/package/prisma-next)
-> and is published only to support its runtime. Its API is unstable and may change
-> without notice. Do not depend on this package directly; install `prisma-next` instead.
+> **Internal package.** This package is an implementation detail of [`prisma-next`](https://www.npmjs.com/package/prisma-next) and is published only to support its runtime. Its API is unstable and may change without notice. Do not depend on this package directly; install `prisma-next` instead.
 
-The Prisma Next language server. It speaks the Language Server Protocol over stdio and supports PSL parse diagnostics plus whole-document PSL formatting for the schema inputs declared in a project's `prisma-next.config.ts`. It is launched by the `prisma-next lsp` subcommand, so the editor features come from the project's own `@prisma-next` version (version-matched by construction).
+The Prisma Next language server speaks the Language Server Protocol over stdio for PSL schema inputs declared in a project's `prisma-next.config.ts`. It is launched by the `prisma-next lsp` subcommand, so editor features come from the project's own `@prisma-next` version and stay version-matched by construction.
 
 ## Scope
 
-Supported capabilities are intentionally narrow: parse diagnostics and whole-document formatting for configured PSL inputs. Formatting is only available for documents listed in `contract.source.inputs`, uses `@prisma-next/psl-parser/format`, and applies formatter options from the project's Prisma config `formatter` block. Hover, completion, navigation, range formatting, on-type formatting, and editor-extension work are out of scope. A server process can manage multiple projects under the workspace root, keyed by the config file each open document belongs to.
+Supported capabilities are intentionally narrow: parse diagnostics, whole-document formatting, folding ranges, and full/range semantic tokens for configured PSL inputs. Formatting is only available for documents listed in `contract.source.inputs`, uses `@prisma-next/psl-parser/format`, and applies formatter options from the project's Prisma config `formatter` block. Semantic tokens use the standard LSP token taxonomy advertised by the server; they do not introduce Prisma-specific token names or a second parser. Hover, completion, navigation, range formatting, on-type formatting, semantic-token delta requests, and editor-extension work are out of scope. A server process can manage multiple projects under the workspace root, keyed by the config file each open document belongs to.
+
+## Responsibilities
+
+- Resolve workspace/project configuration for open PSL documents and keep managed projects aligned with config-file changes.
+- Publish parse diagnostics and serve whole-document formatting, folding ranges, and full/range semantic tokens for configured PSL inputs.
+- Preserve parser artifacts per project so editor features share the same AST, source-file, and symbol-table lifecycle instead of reparsing through feature-specific paths.
+- Fail safely for unsupported documents, missing or closed buffers, config-load failures, malformed inputs, and oversized semantic-token requests.
+
+## Dependencies
+
+- `@prisma-next/config-loader` — discovers nearest config files and loads project configuration.
+- `@prisma-next/psl-parser` — parses PSL, builds symbol tables, exposes syntax artifacts, and formats PSL text.
+- `@prisma-next/framework-components` — supplies control-stack input types used when resolving project configuration.
+- `@prisma-next/errors` and `@prisma-next/utils` — shared framework utilities used by parsing/config plumbing.
+- `vscode-languageserver` and `vscode-languageserver-textdocument` — LSP connection, request/notification types, semantic-token/folding/formatting types, and incremental document management.
 
 ## How it works
 
-1. **`initialize`** — resolves the workspace root from the client's `rootUri` and registers config-file watching when the client supports it. Configs are loaded when matching documents open or when watched config files change. If a config cannot be loaded, the server does not manage that project.
-2. **Document sync** — text-document sync is **incremental**
-   (`TextDocumentSyncKind.Incremental`); the `TextDocuments` manager applies
-   incremental edits, and the server re-parses the full current buffer on each
-   change.
+1. **`initialize`** — resolves the workspace root from the client's `rootUri` and registers config-file watching when the client supports it. The server advertises incremental text sync, whole-document formatting, folding ranges, and `semanticTokensProvider` with a stable standard-only legend, `full: true`, and `range: true`. Configs are loaded when matching documents open or when watched config files change. If a config cannot be loaded, the server does not manage that project.
+2. **Document sync** — text-document sync is **incremental** (`TextDocumentSyncKind.Incremental`); the `TextDocuments` manager applies incremental edits, and the server re-parses the full current buffer on each change.
 3. **Diagnostics** — on `didOpen` / `didChange` of a document whose URI is a configured PSL input, the server runs `@prisma-next/psl-parser`'s `parse()` (the CST path) and `buildSymbolTable()`, then publishes the merged, mapped diagnostics via `textDocument/publishDiagnostics`. A clean document publishes an empty array (clearing markers). Documents that are not configured inputs publish nothing.
 4. **Formatting** — on `textDocument/formatting`, the server formats the current in-memory document text with `@prisma-next/psl-parser/format` when the document is a configured PSL input. It returns one whole-document edit when the formatted text differs, and returns no edits for missing or closed documents, unconfigured documents, already canonical text, malformed PSL, or invalid formatter options.
-5. **Preserved artifacts** — each project keeps the parse artifacts it produces:
-   the AST per open document (keyed by URI) and one symbol table per project,
-   rebuilt from the open configured input on each edit and dropped when the
-   document closes. They are exposed through `getDocumentAst` /
-   `getProjectSymbolTable` so future features (completion, semantic tokens) read
-   real stages instead of re-parsing. Filling the project table from several
-   inputs — and reading unopened inputs from disk — is deferred cross-file work.
+5. **Folding ranges** — on `textDocument/foldingRange`, the server reads the preserved document AST for the configured input and returns foldable declaration/block ranges. Missing, unconfigured, or not-yet-parsed documents return an empty result.
+6. **Semantic tokens** — on `textDocument/semanticTokens/full` and `textDocument/semanticTokens/range`, the server reads the current preserved `DocumentAst`, `SourceFile`, project `SymbolTable`, and control-stack scalar types from the same `ProjectArtifacts` lifecycle used by diagnostics. It classifies PSL keywords, declaration names, field/property names, type references, attributes, strings, numbers, booleans, and comments into standard token types/modifiers, then encodes them as LSP five-integer relative semantic-token data. The range request filters to intersecting tokens before encoding. Unconfigured, missing, closed, config-resolution-failed, oversized, or stale documents return `{ data: [] }` instead of throwing or reparsing through a semantic-token-specific path. Malformed PSL returns best-effort tokens from parser recovery when artifacts are available.
+7. **Preserved artifacts** — each project keeps the parse artifacts it produces: the AST per open document (keyed by URI) and one symbol table per project, rebuilt from the open configured input on each edit and dropped when the document closes. Diagnostics populate these artifacts, and folding/semantic-token handlers read them instead of constructing independent parse/token caches. They are exposed through `getDocumentAst` / `getProjectSymbolTable` for future features. Filling the project table from several inputs — and reading unopened inputs from disk — is deferred cross-file work.
 
 ## Module layout
 
-- `diagnostic-mapping.ts` — pure `ParseDiagnostic[] → LspDiagnostic[]` mapping.
-  Free of any `vscode-languageserver` import; it returns plain shape objects
-  (ranges pass through unchanged) so it stays reusable. The connection layer
-  adapts the numeric severity to the LSP enum.
-- `schema-inputs.ts` — resolves the schema-input set (`SchemaInputSet`) from a
-  config and answers URI membership.
+- `diagnostic-mapping.ts` — pure `ParseDiagnostic[] → LspDiagnostic[]` mapping. Free of any `vscode-languageserver` import; it returns plain shape objects (ranges pass through unchanged) so it stays reusable. The connection layer adapts the numeric severity to the LSP enum.
+- `schema-inputs.ts` — resolves the schema-input set (`SchemaInputSet`) from a config and answers URI membership.
 - `config-resolution.ts` — wraps `loadConfig` and resolves schema inputs, formatter options, and control-stack inputs for a config. A standalone async function so it can be re-run on a config change without rewiring the server.
 - `document-diagnostics.ts` — `computeDocumentDiagnostics(uri, text, inputs, controlStack)`, the pure seam that parses, builds the symbol table, and returns the diagnostics plus the parse artifacts.
-- `project-artifacts.ts` — `createProjectArtifacts()`, the per-project store that
-  preserves the per-URI ASTs and the single project symbol table across edits.
-- `server.ts` — `createServer(connection)` wires diagnostics and whole-document formatting handlers onto an injected connection.
+- `project-artifacts.ts` — `createProjectArtifacts()`, the per-project store that preserves the per-URI ASTs and the single project symbol table across edits.
+- `folding-ranges.ts` — pure AST-to-LSP folding-range computation for declaration/block bodies.
+- `semantic-tokens.ts` — pure PSL semantic-token collection, range filtering, multiline normalization, duplicate resolution, modifier bitset encoding, and LSP semantic-token data encoding.
+- `server.ts` — `createServer(connection)` wires diagnostics, whole-document formatting, folding ranges, semantic-token handlers, config watching, and project-artifact access onto an injected connection.
 - `start-server.ts` — `startServer()` creates a stdio connection and starts the server. This is what the CLI delegates to.
 
 ## Package Location

package/dist/exports/index.d.mts

@@ -20,6 +20,7 @@ declare function mapParseDiagnostics(diagnostics: readonly ParseDiagnostic[]): r
 interface CachedDocument {
   readonly document: DocumentAst;
   readonly sourceFile: SourceFile;
+  readonly text: string;
 }
 //#endregion
 //#region src/server.d.ts

package/dist/exports/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/diagnostic-mapping.ts","../../src/project-artifacts.ts","../../src/server.ts","../../src/start-server.ts"],"mappings":";;;;cAEa,uBAAA;EAAA;;;;;UAOI,aAAA;EAAA,SACN,KAAA,EAAO,KAAK;EAAA,SACZ,OAAA;EAAA,SACA,IAAA;EAAA,SACA,QAAA;AAAA;AAAA,iBAGK,mBAAA,CACd,WAAA,WAAsB,eAAA,cACZ,aAAa;;;UCXR,cAAA;EAAA,SACN,QAAA,EAAU,WAAA;EAAA,SACV,UAAA,EAAY,UAAU;AAAA;;;UCqBhB,cAAA;EACf,OAAA;;AF7BF;;;EEkCE,cAAA,CAAe,GAAA,WAAc,cAAA;EAC7B,qBAAA,CAAsB,GAAA,WAAc,WAAW;AAAA;AAAA,iBAejC,YAAA,CAAa,UAAA,EAAY,UAAA,GAAa,cAAc;;;iBCjDpD,WAAA,IAAe,cAAc"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/diagnostic-mapping.ts","../../src/project-artifacts.ts","../../src/server.ts","../../src/start-server.ts"],"mappings":";;;;cAEa,uBAAA;EAAA;;;;;UAOI,aAAA;EAAA,SACN,KAAA,EAAO,KAAK;EAAA,SACZ,OAAA;EAAA,SACA,IAAA;EAAA,SACA,QAAA;AAAA;AAAA,iBAGK,mBAAA,CACd,WAAA,WAAsB,eAAA,cACZ,aAAa;;;UCXR,cAAA;EAAA,SACN,QAAA,EAAU,WAAA;EAAA,SACV,UAAA,EAAY,UAAU;EAAA,SACtB,IAAA;AAAA;;;UCuBM,cAAA;EACf,OAAA;;AFhCF;;;EEqCE,cAAA,CAAe,GAAA,WAAc,cAAA;EAC7B,qBAAA,CAAsB,GAAA,WAAc,WAAW;AAAA;AAAA,iBAiBjC,YAAA,CAAa,UAAA,EAAY,UAAA,GAAa,cAAc;;;iBCtDpD,WAAA,IAAe,cAAc"}

package/dist/exports/index.mjs

@@ -2,10 +2,10 @@ import { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { findNearestConfigPathForFile, loadConfig } from "@prisma-next/config-loader";
 import { format } from "@prisma-next/psl-parser/format";
-import { DiagnosticSeverity, DidChangeWatchedFilesNotification, FoldingRangeKind, RegistrationRequest, TextDocumentSyncKind, TextDocuments } from "vscode-languageserver";
+import { DiagnosticSeverity, DidChangeWatchedFilesNotification, FoldingRangeKind, RegistrationRequest, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { createControlStack } from "@prisma-next/framework-components/control";
-import { NamespaceDeclarationAst, parse } from "@prisma-next/psl-parser/syntax";
+import { ArrayLiteralAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, FieldDeclarationAst, FunctionCallAst, IdentifierAst, ModelDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectLiteralExprAst, StringLiteralExprAst, TypesBlockAst, filterChildren, parse } from "@prisma-next/psl-parser/syntax";
 import { buildSymbolTable } from "@prisma-next/psl-parser";
 import { ProposedFeatures, createConnection } from "vscode-languageserver/node";
 //#region src/diagnostic-mapping.ts
@@ -157,7 +157,8 @@ function createProjectArtifacts() {
 			}
 			documents.set(uri, {
 				document: computed.document,
-				sourceFile: computed.sourceFile
+				sourceFile: computed.sourceFile,
+				text
 			});
 			symbolTable = computed.symbolTable;
 			return computed.diagnostics;
@@ -168,7 +169,344 @@ function createProjectArtifacts() {
 	};
 }
 //#endregion
+//#region src/semantic-tokens.ts
+const semanticTokenTypes = [
+	SemanticTokenTypes.keyword,
+	SemanticTokenTypes.namespace,
+	SemanticTokenTypes.class,
+	SemanticTokenTypes.struct,
+	SemanticTokenTypes.type,
+	SemanticTokenTypes.property,
+	SemanticTokenTypes.decorator,
+	SemanticTokenTypes.string,
+	SemanticTokenTypes.number,
+	SemanticTokenTypes.comment
+];
+const semanticTokenModifiers = [SemanticTokenModifiers.declaration, SemanticTokenModifiers.defaultLibrary];
+const semanticTokenModifierIndexes = {
+	declaration: 0,
+	defaultLibrary: 1
+};
+const semanticTokenModifierBits = {
+	declaration: 1 << semanticTokenModifierIndexes.declaration,
+	defaultLibrary: 1 << semanticTokenModifierIndexes.defaultLibrary
+};
+const semanticTokensLegend = {
+	tokenTypes: [...semanticTokenTypes],
+	tokenModifiers: [...semanticTokenModifiers]
+};
+function buildSemanticTokens(source, range) {
+	const builder = new SemanticTokensBuilder(source.sourceFile, range);
+	for (const token of collectSemanticTokenEvents(source)) builder.add(token);
+	return builder.build();
+}
+function collectSemanticTokenEvents(source) {
+	const comments = collectCommentTokens(source.document);
+	const tokens = [];
+	collectDeclarations(source, tokens);
+	return mergeSourceOrderedTokens(comments, tokens);
+}
+var SemanticTokensBuilder = class {
+	#data = [];
+	#sourceFile;
+	#rangeOffsets;
+	#previousLine = 0;
+	#previousCharacter = 0;
+	#first = true;
+	constructor(sourceFile, range) {
+		this.#sourceFile = sourceFile;
+		if (range !== void 0) {
+			const startOffset = sourceFile.offsetAt(range.start);
+			const endOffset = sourceFile.offsetAt(range.end);
+			this.#rangeOffsets = {
+				lower: Math.min(startOffset, endOffset),
+				upper: Math.max(startOffset, endOffset)
+			};
+		}
+	}
+	add(token) {
+		if (!this.#intersectsRange(token.startOffset, token.endOffset)) return;
+		if (token.splitMultiline) {
+			this.#addMultilineSplitToken(token);
+			return;
+		}
+		this.#encode(token.startOffset, token.endOffset, token.tokenTypeIndex, token.modifierBitset);
+	}
+	build() {
+		return { data: this.#data };
+	}
+	#intersectsRange(startOffset, endOffset) {
+		const rangeOffsets = this.#rangeOffsets;
+		return rangeOffsets === void 0 || startOffset < rangeOffsets.upper && endOffset > rangeOffsets.lower;
+	}
+	#addMultilineSplitToken(token) {
+		const start = this.#sourceFile.positionAt(token.startOffset);
+		const end = this.#sourceFile.positionAt(token.endOffset);
+		if (start.line === end.line) {
+			this.#encode(token.startOffset, token.endOffset, token.tokenTypeIndex, token.modifierBitset);
+			return;
+		}
+		for (let line = start.line; line <= end.line; line++) {
+			const startOffset = line === start.line ? token.startOffset : this.#sourceFile.lineStartOffset(line);
+			const endOffset = line === end.line ? token.endOffset : this.#sourceFile.lineEndOffset(line);
+			if (endOffset > startOffset && this.#intersectsRange(startOffset, endOffset)) this.#encode(startOffset, endOffset, token.tokenTypeIndex, token.modifierBitset);
+		}
+	}
+	#encode(startOffset, endOffset, tokenTypeIndex, modifierBitset) {
+		const start = this.#sourceFile.positionAt(startOffset);
+		const deltaLine = this.#first ? start.line : start.line - this.#previousLine;
+		const deltaStart = this.#first || deltaLine !== 0 ? start.character : start.character - this.#previousCharacter;
+		this.#data.push(deltaLine, deltaStart, endOffset - startOffset, tokenTypeIndex, modifierBitset);
+		this.#previousLine = start.line;
+		this.#previousCharacter = start.character;
+		this.#first = false;
+	}
+};
+function collectCommentTokens(document) {
+	const tokens = [];
+	for (const token of document.syntax.tokens()) if (token.kind === "Comment") tokens.push(pendingTokenForToken(token, "comment"));
+	return tokens;
+}
+function collectDeclarations(source, tokens) {
+	for (const declaration of source.document.declarations()) collectDeclaration(declaration, source, tokens, void 0);
+}
+function collectDeclaration(declaration, source, tokens, namespace) {
+	if (declaration instanceof ModelDeclarationAst) {
+		addToken(declaration.keyword(), "keyword", tokens);
+		addIdentifier(declaration.name(), "class", tokens, semanticTokenModifierBits.declaration);
+		collectBlockMembers(declaration.members(), source, tokens, namespace);
+		return;
+	}
+	if (declaration instanceof CompositeTypeDeclarationAst) {
+		addToken(declaration.keyword(), "keyword", tokens);
+		addIdentifier(declaration.name(), "struct", tokens, semanticTokenModifierBits.declaration);
+		collectBlockMembers(declaration.members(), source, tokens, namespace);
+		return;
+	}
+	if (declaration instanceof NamespaceDeclarationAst) {
+		addToken(declaration.keyword(), "keyword", tokens);
+		addIdentifier(declaration.name(), "namespace", tokens, semanticTokenModifierBits.declaration);
+		const nestedNamespace = declaration.name()?.name();
+		for (const nested of declaration.declarations()) collectDeclaration(nested, source, tokens, nestedNamespace);
+		return;
+	}
+	if (declaration instanceof TypesBlockAst) {
+		addToken(declaration.keyword(), "keyword", tokens);
+		for (const namedType of declaration.declarations()) collectNamedTypeDeclaration(namedType, source, tokens, namespace);
+		return;
+	}
+	addToken(declaration.keyword(), "keyword", tokens);
+	addIdentifier(declaration.name(), "type", tokens, semanticTokenModifierBits.declaration);
+	collectGenericBlockMembers(declaration.members(), source, tokens, namespace);
+}
+function collectNamedTypeDeclaration(declaration, source, tokens, namespace) {
+	addIdentifier(declaration.name(), "type", tokens, semanticTokenModifierBits.declaration);
+	collectTypeAnnotation(declaration.typeAnnotation(), source, tokens, namespace);
+	collectAttributes(declaration.attributes(), source, tokens, namespace);
+}
+function collectGenericBlockMembers(members, source, tokens, namespace) {
+	for (const member of members) {
+		if ("key" in member) {
+			addIdentifier(member.key(), "property", tokens);
+			collectExpression(member.value(), source, tokens, namespace);
+			continue;
+		}
+		collectAttribute(member, source, tokens, namespace);
+	}
+}
+function collectBlockMembers(members, source, tokens, namespace) {
+	for (const member of members) {
+		if (member instanceof FieldDeclarationAst) {
+			collectField(member, source, tokens, namespace);
+			continue;
+		}
+		collectAttribute(member, source, tokens, namespace);
+	}
+}
+function collectField(field, source, tokens, namespace) {
+	addIdentifier(field.name(), "property", tokens, semanticTokenModifierBits.declaration);
+	collectTypeAnnotation(field.typeAnnotation(), source, tokens, namespace);
+	collectAttributes(field.attributes(), source, tokens, namespace);
+}
+function collectTypeAnnotation(annotation, source, tokens, namespace) {
+	if (annotation === void 0) return;
+	collectTypeReference(annotation.name(), source, tokens, namespace);
+	collectAttributeArgList(annotation.argList(), source, tokens, namespace);
+}
+function collectAttributes(attributes, source, tokens, namespace) {
+	for (const attribute of attributes) collectAttribute(attribute, source, tokens, namespace);
+}
+function collectAttribute(attribute, source, tokens, namespace) {
+	collectDecoratorName(attribute.name(), source.sourceFile.text, tokens);
+	collectAttributeArgList(attribute.argList(), source, tokens, namespace);
+}
+function collectDecoratorName(name, sourceText, tokens) {
+	if (name === void 0) return;
+	const segments = identifierSegments(name);
+	for (const [index, segment] of segments.entries()) tokens.push(rangeForDecoratorIdentifier(segment.identifier, sourceText, index === 0));
+}
+function collectAttributeArgList(argList, source, tokens, namespace) {
+	if (argList === void 0) return;
+	for (const arg of argList.args()) collectAttributeArg(arg, source, tokens, namespace);
+}
+function collectAttributeArg(arg, source, tokens, namespace) {
+	const name = arg.name();
+	addIdentifier(name, "property", tokens);
+	collectExpression(arg.value(), source, tokens, namespace, expressionContextForAttributeArg(name));
+}
+function collectExpression(expression, source, tokens, namespace, context = {}) {
+	if (expression === void 0) return;
+	if (expression instanceof StringLiteralExprAst) {
+		addToken(expression.token(), "string", tokens);
+		return;
+	}
+	if (expression instanceof NumberLiteralExprAst) {
+		addToken(expression.token(), "number", tokens);
+		return;
+	}
+	if (expression instanceof BooleanLiteralExprAst) {
+		addToken(expression.token(), "keyword", tokens);
+		return;
+	}
+	if (expression instanceof FunctionCallAst) {
+		collectTypeReference(expression.name(), source, tokens, namespace);
+		for (const arg of expression.args()) collectAttributeArg(arg, source, tokens, namespace);
+		return;
+	}
+	if (expression instanceof ArrayLiteralAst) {
+		for (const element of expression.elements()) collectExpression(element, source, tokens, namespace, context);
+		return;
+	}
+	if (expression instanceof ObjectLiteralExprAst) {
+		for (const field of expression.fields()) {
+			addIdentifier(field.key(), "property", tokens);
+			collectExpression(field.value(), source, tokens, namespace);
+		}
+		return;
+	}
+	collectIdentifierExpression(expression, source, tokens, namespace, context);
+}
+function collectIdentifierExpression(identifier, source, tokens, namespace, context) {
+	const text = identifier.name();
+	if (text === void 0) return;
+	const bareIdentifierTokenType = context.bareIdentifierTokenType;
+	if (bareIdentifierTokenType !== void 0) {
+		tokens.push(rangeForIdentifier(identifier, bareIdentifierTokenType));
+		return;
+	}
+	const classification = classifyTypeReference([text], source, namespace);
+	tokens.push(rangeForIdentifier(identifier, classification.tokenType, classification.modifierBitset));
+}
+function expressionContextForAttributeArg(name) {
+	const argName = name?.name();
+	return argName === "fields" || argName === "references" ? { bareIdentifierTokenType: "property" } : {};
+}
+function collectTypeReference(name, source, tokens, namespace) {
+	if (name === void 0) return;
+	const segments = identifierSegments(name);
+	if (segments.length === 0) return;
+	const path = segments.map((segment) => segment.text);
+	for (const segment of segments.slice(0, -1)) if (isKnownNamespace(segment.text, source.symbolTable)) tokens.push(rangeForIdentifier(segment.identifier, "namespace"));
+	const finalSegment = segments[segments.length - 1];
+	if (finalSegment === void 0) return;
+	const classification = classifyTypeReference(path, source, namespace);
+	tokens.push(rangeForIdentifier(finalSegment.identifier, classification.tokenType, classification.modifierBitset));
+}
+function classifyTypeReference(path, source, namespace) {
+	const name = path[path.length - 1];
+	if (name === void 0) return { tokenType: "type" };
+	const table = source.symbolTable;
+	const namespaceName = path.length > 1 ? path[path.length - 2] : namespace;
+	const namespaceScope = namespaceName !== void 0 ? table?.topLevel.namespaces[namespaceName] : void 0;
+	if (namespaceScope !== void 0) {
+		if (Object.hasOwn(namespaceScope.models, name)) return { tokenType: "class" };
+		if (Object.hasOwn(namespaceScope.compositeTypes, name)) return { tokenType: "struct" };
+		if (Object.hasOwn(namespaceScope.blocks, name)) return { tokenType: "type" };
+	}
+	if (table !== void 0) {
+		if (Object.hasOwn(table.topLevel.models, name)) return { tokenType: "class" };
+		if (Object.hasOwn(table.topLevel.compositeTypes, name)) return { tokenType: "struct" };
+		if (Object.hasOwn(table.topLevel.scalars, name)) return {
+			tokenType: "type",
+			modifierBitset: semanticTokenModifierBits.defaultLibrary
+		};
+		if (Object.hasOwn(table.topLevel.typeAliases, name) || Object.hasOwn(table.topLevel.blocks, name)) return { tokenType: "type" };
+	}
+	if (source.scalarTypes.includes(name)) return {
+		tokenType: "type",
+		modifierBitset: semanticTokenModifierBits.defaultLibrary
+	};
+	return { tokenType: "type" };
+}
+function isKnownNamespace(name, table) {
+	return table !== void 0 && Object.hasOwn(table.topLevel.namespaces, name);
+}
+function identifierSegments(name) {
+	const segments = [];
+	for (const identifier of filterChildren(name.syntax, IdentifierAst.cast)) {
+		const text = identifier.name();
+		if (text !== void 0) segments.push({
+			identifier,
+			text
+		});
+	}
+	return segments;
+}
+function addIdentifier(identifier, tokenType, tokens, modifierBitset = 0) {
+	if (identifier === void 0) return;
+	tokens.push(rangeForIdentifier(identifier, tokenType, modifierBitset));
+}
+function addToken(token, tokenType, tokens, modifierBitset = 0) {
+	if (token === void 0) return;
+	tokens.push(pendingTokenForToken(token, tokenType, modifierBitset));
+}
+function rangeForIdentifier(identifier, tokenType, modifierBitset = 0) {
+	const token = identifier.token();
+	if (token === void 0) return createPendingSemanticToken(identifier.syntax.offset, identifier.syntax.offset, tokenType, modifierBitset);
+	return pendingTokenForToken(token, tokenType, modifierBitset);
+}
+function rangeForDecoratorIdentifier(identifier, sourceText, includePrefix) {
+	const range = rangeForIdentifier(identifier, "decorator");
+	if (!includePrefix) return range;
+	let startOffset = range.startOffset;
+	while (startOffset > 0 && sourceText.charAt(startOffset - 1) === "@") startOffset--;
+	return createPendingSemanticToken(startOffset, range.endOffset, "decorator", range.modifierBitset);
+}
+function pendingTokenForToken(token, tokenType, modifierBitset = 0) {
+	return createPendingSemanticToken(token.offset, token.offset + token.text.length, tokenType, modifierBitset);
+}
+function mergeSourceOrderedTokens(left, right) {
+	const result = [];
+	let leftIndex = 0;
+	let rightIndex = 0;
+	while (leftIndex < left.length || rightIndex < right.length) {
+		const leftToken = left[leftIndex];
+		const rightToken = right[rightIndex];
+		if (leftToken !== void 0 && (rightToken === void 0 || leftToken.startOffset <= rightToken.startOffset)) {
+			result.push(leftToken);
+			leftIndex++;
+		} else if (rightToken !== void 0) {
+			result.push(rightToken);
+			rightIndex++;
+		}
+	}
+	return result;
+}
+function createPendingSemanticToken(startOffset, endOffset, tokenType, modifierBitset = 0) {
+	return {
+		startOffset,
+		endOffset,
+		tokenTypeIndex: tokenTypeIndex(tokenType),
+		modifierBitset,
+		splitMultiline: tokenType === "string" || tokenType === "comment"
+	};
+}
+function tokenTypeIndex(tokenType) {
+	return semanticTokenTypes.indexOf(tokenType);
+}
+//#endregion
 //#region src/server.ts
+const semanticTokenSourceLimit = 1e5;
 function createServer(connection) {
 	const documents = new TextDocuments(TextDocument);
 	const projects = /* @__PURE__ */ new Map();
@@ -177,16 +515,15 @@ function createServer(connection) {
 	let rootPath = process.cwd();
 	let watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
 	let supportsWatchedFilesRegistration = false;
-	async function publish(uri, text) {
+	async function publish(uri) {
 		const project = await resolveProjectForDocument(uri);
 		if (project === void 0) return;
-		const currentDocument = documents.get(uri);
-		if (currentDocument === void 0) {
+		const document = documents.get(uri);
+		if (document === void 0) {
 			documentConfigPaths.delete(uri);
 			return;
 		}
-		if (currentDocument.getText() !== text) return;
-		const computed = project.artifacts.update(uri, text, project.inputs, project.controlStack);
+		const computed = project.artifacts.update(uri, document.getText(), project.inputs, project.controlStack);
 		if (computed === null) {
 			connection.sendDiagnostics({
 				uri,
@@ -208,7 +545,11 @@ function createServer(connection) {
 	}
 	async function resolveProjectForDocument(uri) {
 		const knownConfigPath = documentConfigPaths.get(uri);
-		if (knownConfigPath !== void 0) return resolveProject(knownConfigPath);
+		if (knownConfigPath !== void 0) {
+			const project = await resolveProjectIfLoadable(knownConfigPath);
+			if (project === void 0) documentConfigPaths.delete(uri);
+			return project;
+		}
 		const filePath = filePathFromUri(uri);
 		if (filePath === void 0) return;
 		const configPath = await findNearestConfigPathForFile(filePath);
@@ -274,19 +615,19 @@ function createServer(connection) {
 	async function republishOpenDocumentsForConfig(configPath) {
 		for (const document of documents.all()) {
 			if (documentConfigPaths.get(document.uri) === configPath) {
-				await publish(document.uri, document.getText());
+				await publish(document.uri);
 				continue;
 			}
 			const filePath = filePathFromUri(document.uri);
 			if (filePath === void 0) continue;
 			if (await findNearestConfigPathForFile(filePath) === configPath) {
 				documentConfigPaths.set(document.uri, configPath);
-				await publish(document.uri, document.getText());
+				await publish(document.uri);
 			}
 		}
 	}
-	function publishSafely(uri, text) {
-		publish(uri, text).catch((error) => {
+	function publishSafely(uri) {
+		publish(uri).catch((error) => {
 			connection.console.error(error instanceof Error ? error.message : String(error));
 		});
 	}
@@ -319,6 +660,22 @@ function createServer(connection) {
 			newText: formatted
 		}];
 	}
+	async function semanticTokensForDocument(uri, range) {
+		const document = documents.get(uri);
+		if (document === void 0) return emptySemanticTokens();
+		const text = document.getText();
+		if (text.length > semanticTokenSourceLimit) return emptySemanticTokens();
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) return emptySemanticTokens();
+		const cached = project.artifacts.getDocument(uri);
+		if (cached === void 0 || cached.text !== text) return emptySemanticTokens();
+		return buildSemanticTokens({
+			document: cached.document,
+			sourceFile: cached.sourceFile,
+			symbolTable: project.artifacts.getSymbolTable(),
+			scalarTypes: project.controlStack.scalarTypes
+		}, range);
+	}
 	connection.onInitialize(async (params) => {
 		rootPath = resolveRootPath(params.rootUri, params.rootPath);
 		watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
@@ -326,7 +683,12 @@ function createServer(connection) {
 		return { capabilities: {
 			textDocumentSync: TextDocumentSyncKind.Incremental,
 			documentFormattingProvider: true,
-			foldingRangeProvider: true
+			foldingRangeProvider: true,
+			semanticTokensProvider: {
+				legend: semanticTokensLegend,
+				full: true,
+				range: true
+			}
 		} };
 	});
 	connection.onInitialized(() => {
@@ -350,6 +712,8 @@ function createServer(connection) {
 		}
 	});
 	connection.onDocumentFormatting((params) => formatDocument(params.textDocument.uri));
+	connection.languages.semanticTokens.on((params) => semanticTokensForDocument(params.textDocument.uri));
+	connection.languages.semanticTokens.onRange((params) => semanticTokensForDocument(params.textDocument.uri, params.range));
 	connection.onFoldingRanges(async (params) => {
 		let project;
 		try {
@@ -363,10 +727,10 @@ function createServer(connection) {
 		return computeFoldingRanges(cached.document, cached.sourceFile);
 	});
 	documents.onDidOpen((event) => {
-		publishSafely(event.document.uri, event.document.getText());
+		publishSafely(event.document.uri);
 	});
 	documents.onDidChangeContent((event) => {
-		publishSafely(event.document.uri, event.document.getText());
+		publishSafely(event.document.uri);
 	});
 	documents.onDidClose((event) => {
 		const uri = event.document.uri;
@@ -392,6 +756,9 @@ function createServer(connection) {
 		getProjectSymbolTable: (uri) => artifactsForDocument(uri)?.getSymbolTable()
 	};
 }
+function emptySemanticTokens() {
+	return { data: [] };
+}
 function toLspSeverity(severity) {
 	switch (severity) {
 		case ParseDiagnosticSeverity.Warning: return DiagnosticSeverity.Warning;