@rejot-dev/thalo-lsp 0.0.0

package/dist/server.bundled.js

@@ -0,0 +1,1764 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DidChangeConfigurationNotification, FileChangeType, ProposedFeatures, createConnection as createConnection$1 } from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { createWorkspace, parseDocument } from "@rejot-dev/thalo/native";
+import { ALL_DIRECTIVES, INSTANCE_DIRECTIVES, PRIMITIVE_TYPES, SCHEMA_BLOCK_HEADERS, SCHEMA_DIRECTIVES, TypeExpr, checkDocument, encodeSemanticTokens, extractSemanticTokens, findDefinition, findEntityDefinition, findEntityReferences, findFieldDefinition, findFieldReferences, findNodeAtPosition, findReferences, findSectionDefinition, findSectionReferences, findTagReferences, getHoverInfo, isInstanceDirective, isSchemaDirective, isSyntaxError, isSynthesisDirective, tokenModifiers, tokenTypes } from "@rejot-dev/thalo";
+
+//#region src/capabilities.ts
+/**
+* File operation filters for thalo and markdown files
+*/
+const thaloFileFilters = [{
+	scheme: "file",
+	pattern: { glob: "**/*.thalo" }
+}, {
+	scheme: "file",
+	pattern: { glob: "**/*.md" }
+}];
+/**
+* Semantic tokens legend for LSP
+* Maps the token types and modifiers from @rejot-dev/thalo
+*/
+const tokenLegend = {
+	tokenTypes: [...tokenTypes],
+	tokenModifiers: [...tokenModifiers]
+};
+/**
+* LSP server capabilities for thalo
+*
+* Defines which LSP features are supported by this server.
+*/
+const serverCapabilities = {
+	textDocumentSync: {
+		openClose: true,
+		change: 2,
+		save: { includeText: true }
+	},
+	definitionProvider: true,
+	referencesProvider: true,
+	hoverProvider: true,
+	completionProvider: {
+		triggerCharacters: ["^", "#"],
+		resolveProvider: true
+	},
+	semanticTokensProvider: {
+		legend: tokenLegend,
+		full: true,
+		range: false
+	},
+	workspace: { fileOperations: {
+		didCreate: { filters: thaloFileFilters },
+		didDelete: { filters: thaloFileFilters },
+		didRename: { filters: thaloFileFilters }
+	} }
+};
+
+//#endregion
+//#region src/handlers/definition.ts
+/**
+* Convert a file path to a URI
+*/
+function pathToUri$1(path$1) {
+	if (!path$1.startsWith("file://")) return `file://${encodeURIComponent(path$1).replace(/%2F/g, "/")}`;
+	return path$1;
+}
+/**
+* Get the file type from a URI
+*/
+function getFileType$4(uri) {
+	if (uri.endsWith(".thalo")) return "thalo";
+	if (uri.endsWith(".md")) return "markdown";
+	return "thalo";
+}
+/**
+* Convert LSP Position to thalo Position (both are 0-based).
+*/
+function lspToThaloPosition$2(pos) {
+	return {
+		line: pos.line,
+		column: pos.character
+	};
+}
+/**
+* Handle textDocument/definition request
+*
+* Finds the definition location for various syntax elements at the given position:
+* - ^link-id → Entry definition
+* - Entity name in instance/alter-entity → define-entity
+* - Metadata key → Field definition in schema
+* - Section header → Section definition in schema
+*
+* Supports both standalone .thalo files and thalo blocks embedded in markdown.
+*
+* @param workspace - The thalo workspace
+* @param document - The text document
+* @param position - The position in the document (line/character)
+* @returns The definition location, or null if not found
+*/
+function handleDefinition(workspace, document, position) {
+	const fileType = getFileType$4(document.uri);
+	try {
+		const context = findNodeAtPosition(parseDocument(document.getText(), {
+			fileType,
+			filename: document.uri
+		}), lspToThaloPosition$2(position));
+		switch (context.kind) {
+			case "link": {
+				const result = findDefinition(workspace, context.linkId);
+				if (result) return {
+					uri: pathToUri$1(result.file),
+					range: {
+						start: {
+							line: result.location.startPosition.row,
+							character: result.location.startPosition.column
+						},
+						end: {
+							line: result.location.endPosition.row,
+							character: result.location.endPosition.column
+						}
+					}
+				};
+				return null;
+			}
+			case "entity":
+			case "schema_entity": {
+				const result = findEntityDefinition(workspace, context.kind === "entity" ? context.entityName : context.entityName);
+				if (result) return {
+					uri: pathToUri$1(result.file),
+					range: {
+						start: {
+							line: result.location.startPosition.row,
+							character: result.location.startPosition.column
+						},
+						end: {
+							line: result.location.endPosition.row,
+							character: result.location.endPosition.column
+						}
+					}
+				};
+				return null;
+			}
+			case "metadata_key": {
+				const result = findFieldDefinition(workspace, context.key, context.entityContext);
+				if (result) return {
+					uri: pathToUri$1(result.file),
+					range: {
+						start: {
+							line: result.location.startPosition.row,
+							character: result.location.startPosition.column
+						},
+						end: {
+							line: result.location.endPosition.row,
+							character: result.location.endPosition.column
+						}
+					}
+				};
+				return null;
+			}
+			case "section_header": {
+				const result = findSectionDefinition(workspace, context.sectionName, context.entityContext);
+				if (result) return {
+					uri: pathToUri$1(result.file),
+					range: {
+						start: {
+							line: result.location.startPosition.row,
+							character: result.location.startPosition.column
+						},
+						end: {
+							line: result.location.endPosition.row,
+							character: result.location.endPosition.column
+						}
+					}
+				};
+				return null;
+			}
+			case "field_name": {
+				const result = findFieldDefinition(workspace, context.fieldName, context.entityContext);
+				if (result) return {
+					uri: pathToUri$1(result.file),
+					range: {
+						start: {
+							line: result.location.startPosition.row,
+							character: result.location.startPosition.column
+						},
+						end: {
+							line: result.location.endPosition.row,
+							character: result.location.endPosition.column
+						}
+					}
+				};
+				return null;
+			}
+			case "section_name": {
+				const result = findSectionDefinition(workspace, context.sectionName, context.entityContext);
+				if (result) return {
+					uri: pathToUri$1(result.file),
+					range: {
+						start: {
+							line: result.location.startPosition.row,
+							character: result.location.startPosition.column
+						},
+						end: {
+							line: result.location.endPosition.row,
+							character: result.location.endPosition.column
+						}
+					}
+				};
+				return null;
+			}
+			default: return null;
+		}
+	} catch (error) {
+		console.error(`[thalo-lsp] Error in definition handler:`, error);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/handlers/references.ts
+/**
+* Convert a file path to a URI
+*/
+function pathToUri(path$1) {
+	if (!path$1.startsWith("file://")) return `file://${encodeURIComponent(path$1).replace(/%2F/g, "/")}`;
+	return path$1;
+}
+/**
+* Get the file type from a URI
+*/
+function getFileType$3(uri) {
+	if (uri.endsWith(".thalo")) return "thalo";
+	if (uri.endsWith(".md")) return "markdown";
+	return "thalo";
+}
+/**
+* Convert LSP Position to thalo Position (both are 0-based).
+*/
+function lspToThaloPosition$1(pos) {
+	return {
+		line: pos.line,
+		column: pos.character
+	};
+}
+/**
+* Handle textDocument/references request
+*
+* Finds all references to various syntax elements at the given position:
+* - ^link-id → All usages of that link
+* - #tag → All entries with that tag
+* - Entity name → All entries using that entity type
+* - Metadata key → All entries using that field
+* - Section header → All entries with that section
+*
+* Supports both standalone .thalo files and thalo blocks embedded in markdown.
+*
+* @param workspace - The thalo workspace
+* @param document - The text document
+* @param position - The position in the document (line/character)
+* @param context - Reference context (includeDeclaration)
+* @returns Array of reference locations, or null if not found
+*/
+function handleReferences(workspace, document, position, context) {
+	const fileType = getFileType$3(document.uri);
+	try {
+		const nodeContext = findNodeAtPosition(parseDocument(document.getText(), {
+			fileType,
+			filename: document.uri
+		}), lspToThaloPosition$1(position));
+		switch (nodeContext.kind) {
+			case "link": {
+				const result = findReferences(workspace, nodeContext.linkId, context.includeDeclaration);
+				if (result) return result.locations.map((loc) => ({
+					uri: pathToUri(loc.file),
+					range: {
+						start: {
+							line: loc.location.startPosition.row,
+							character: loc.location.startPosition.column
+						},
+						end: {
+							line: loc.location.endPosition.row,
+							character: loc.location.endPosition.column
+						}
+					}
+				}));
+				return null;
+			}
+			case "tag": return findTagReferences(workspace, nodeContext.tagName).references.map((ref) => ({
+				uri: pathToUri(ref.file),
+				range: {
+					start: {
+						line: ref.location.startPosition.row,
+						character: ref.location.startPosition.column
+					},
+					end: {
+						line: ref.location.endPosition.row,
+						character: ref.location.endPosition.column
+					}
+				}
+			}));
+			case "entity":
+			case "schema_entity": return findEntityReferences(workspace, nodeContext.kind === "entity" ? nodeContext.entityName : nodeContext.entityName, context.includeDeclaration).locations.map((loc) => ({
+				uri: pathToUri(loc.file),
+				range: {
+					start: {
+						line: loc.location.startPosition.row,
+						character: loc.location.startPosition.column
+					},
+					end: {
+						line: loc.location.endPosition.row,
+						character: loc.location.endPosition.column
+					}
+				}
+			}));
+			case "metadata_key": {
+				const result = findFieldReferences(workspace, nodeContext.key, nodeContext.entityContext);
+				const locations = [];
+				if (context.includeDeclaration && result.definition) locations.push({
+					uri: pathToUri(result.definition.file),
+					range: {
+						start: {
+							line: result.definition.location.startPosition.row,
+							character: result.definition.location.startPosition.column
+						},
+						end: {
+							line: result.definition.location.endPosition.row,
+							character: result.definition.location.endPosition.column
+						}
+					}
+				});
+				for (const ref of result.references) locations.push({
+					uri: pathToUri(ref.file),
+					range: {
+						start: {
+							line: ref.location.startPosition.row,
+							character: ref.location.startPosition.column
+						},
+						end: {
+							line: ref.location.endPosition.row,
+							character: ref.location.endPosition.column
+						}
+					}
+				});
+				return locations;
+			}
+			case "section_header": {
+				const result = findSectionReferences(workspace, nodeContext.sectionName, nodeContext.entityContext);
+				const locations = [];
+				if (context.includeDeclaration && result.definition) locations.push({
+					uri: pathToUri(result.definition.file),
+					range: {
+						start: {
+							line: result.definition.location.startPosition.row,
+							character: result.definition.location.startPosition.column
+						},
+						end: {
+							line: result.definition.location.endPosition.row,
+							character: result.definition.location.endPosition.column
+						}
+					}
+				});
+				for (const ref of result.references) locations.push({
+					uri: pathToUri(ref.file),
+					range: {
+						start: {
+							line: ref.location.startPosition.row,
+							character: ref.location.startPosition.column
+						},
+						end: {
+							line: ref.location.endPosition.row,
+							character: ref.location.endPosition.column
+						}
+					}
+				});
+				return locations;
+			}
+			case "field_name": {
+				const result = findFieldReferences(workspace, nodeContext.fieldName, nodeContext.entityContext);
+				const locations = [];
+				if (context.includeDeclaration && result.definition) locations.push({
+					uri: pathToUri(result.definition.file),
+					range: {
+						start: {
+							line: result.definition.location.startPosition.row,
+							character: result.definition.location.startPosition.column
+						},
+						end: {
+							line: result.definition.location.endPosition.row,
+							character: result.definition.location.endPosition.column
+						}
+					}
+				});
+				for (const ref of result.references) locations.push({
+					uri: pathToUri(ref.file),
+					range: {
+						start: {
+							line: ref.location.startPosition.row,
+							character: ref.location.startPosition.column
+						},
+						end: {
+							line: ref.location.endPosition.row,
+							character: ref.location.endPosition.column
+						}
+					}
+				});
+				return locations;
+			}
+			case "section_name": {
+				const result = findSectionReferences(workspace, nodeContext.sectionName, nodeContext.entityContext);
+				const locations = [];
+				if (context.includeDeclaration && result.definition) locations.push({
+					uri: pathToUri(result.definition.file),
+					range: {
+						start: {
+							line: result.definition.location.startPosition.row,
+							character: result.definition.location.startPosition.column
+						},
+						end: {
+							line: result.definition.location.endPosition.row,
+							character: result.definition.location.endPosition.column
+						}
+					}
+				});
+				for (const ref of result.references) locations.push({
+					uri: pathToUri(ref.file),
+					range: {
+						start: {
+							line: ref.location.startPosition.row,
+							character: ref.location.startPosition.column
+						},
+						end: {
+							line: ref.location.endPosition.row,
+							character: ref.location.endPosition.column
+						}
+					}
+				});
+				return locations;
+			}
+			default: return null;
+		}
+	} catch (error) {
+		console.error(`[thalo-lsp] Error in references handler:`, error);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/handlers/semantic-tokens.ts
+/**
+* Get the file type from a URI
+*/
+function getFileType$2(uri) {
+	if (uri.endsWith(".thalo")) return "thalo";
+	if (uri.endsWith(".md")) return "markdown";
+	return "thalo";
+}
+/**
+* Handle textDocument/semanticTokens/full request
+*
+* Returns semantic tokens for syntax highlighting.
+*
+* @param document - The text document
+* @returns Semantic tokens in LSP format
+*/
+function handleSemanticTokens(document) {
+	const fileType = getFileType$2(document.uri);
+	try {
+		return { data: encodeSemanticTokens(extractSemanticTokens(parseDocument(document.getText(), {
+			fileType,
+			filename: document.uri
+		}))) };
+	} catch (error) {
+		console.error(`[thalo-lsp] Error extracting semantic tokens:`, error);
+		return { data: [] };
+	}
+}
+
+//#endregion
+//#region src/handlers/diagnostics.ts
+/**
+* Map thalo severity to LSP DiagnosticSeverity
+*/
+function mapSeverity(severity) {
+	switch (severity) {
+		case "error": return 1;
+		case "warning": return 2;
+		case "info": return 3;
+		default: return 3;
+	}
+}
+/**
+* Convert a URI to a file path
+*/
+function uriToPath$1(uri) {
+	if (uri.startsWith("file://")) return decodeURIComponent(uri.slice(7));
+	return uri;
+}
+/**
+* Convert a thalo Diagnostic to an LSP Diagnostic
+*/
+function convertDiagnostic(diagnostic) {
+	return {
+		range: {
+			start: {
+				line: diagnostic.location.startPosition.row,
+				character: diagnostic.location.startPosition.column
+			},
+			end: {
+				line: diagnostic.location.endPosition.row,
+				character: diagnostic.location.endPosition.column
+			}
+		},
+		severity: mapSeverity(diagnostic.severity),
+		code: diagnostic.code,
+		source: "thalo",
+		message: diagnostic.message
+	};
+}
+/**
+* Get diagnostics for a document
+*
+* @param workspace - The thalo workspace
+* @param textDocument - The LSP text document
+* @returns Array of LSP diagnostics
+*/
+function getDiagnostics(workspace, textDocument) {
+	const path$1 = uriToPath$1(textDocument.uri);
+	if (!workspace.getModel(path$1)) return [];
+	try {
+		return checkDocument(path$1, workspace).map(convertDiagnostic);
+	} catch (error) {
+		console.error(`[thalo-lsp] Error checking ${path$1}:`, error);
+		return [{
+			range: {
+				start: {
+					line: 0,
+					character: 0
+				},
+				end: {
+					line: 0,
+					character: 0
+				}
+			},
+			severity: 1,
+			source: "thalo",
+			message: `Parse error: ${error instanceof Error ? error.message : String(error)}`
+		}];
+	}
+}
+
+//#endregion
+//#region src/handlers/hover.ts
+/**
+* Get the file type from a URI
+*/
+function getFileType$1(uri) {
+	if (uri.endsWith(".thalo")) return "thalo";
+	if (uri.endsWith(".md")) return "markdown";
+	return "thalo";
+}
+/**
+* Convert LSP Position to thalo Position (both are 0-based).
+*/
+function lspToThaloPosition(pos) {
+	return {
+		line: pos.line,
+		column: pos.character
+	};
+}
+/**
+* Handle textDocument/hover request
+*
+* Provides hover information for various syntax elements:
+* - ^link-id: Shows target entry details
+* - #tag: Shows tag usage statistics
+* - Directives: Shows documentation
+* - Entity names: Shows schema with fields and sections
+* - Metadata keys: Shows field type and description
+* - Type expressions: Shows type documentation
+* - Section headers: Shows section description
+* - Timestamps: Shows entry info or link reference hint
+*
+* Supports both standalone .thalo files and thalo blocks embedded in markdown.
+*
+* @param workspace - The thalo workspace
+* @param document - The text document
+* @param position - The hover position
+* @returns Hover information, or null if nothing to show
+*/
+function handleHover(workspace, document, position) {
+	const fileType = getFileType$1(document.uri);
+	try {
+		const result = getHoverInfo(workspace, findNodeAtPosition(parseDocument(document.getText(), {
+			fileType,
+			filename: document.uri
+		}), lspToThaloPosition(position)));
+		if (!result) return null;
+		const hover = { contents: {
+			kind: "markdown",
+			value: result.content
+		} };
+		if (result.range) hover.range = {
+			start: {
+				line: result.range.startPosition.row,
+				character: result.range.startPosition.column
+			},
+			end: {
+				line: result.range.endPosition.row,
+				character: result.range.endPosition.column
+			}
+		};
+		return hover;
+	} catch (error) {
+		console.error(`[thalo-lsp] Error in hover handler:`, error);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/handlers/completions/context.ts
+/** Timestamp pattern: YYYY-MM-DDTHH:MMZ or YYYY-MM-DDTHH:MM±HH:MM */
+const TIMESTAMP_PREFIX_PATTERN = /^[12]\d{3}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d(Z|[+-][0-2]\d:[0-5]\d)\s+/;
+/**
+* Get the text before the cursor on the current line.
+*/
+function getTextBeforeCursor(document, position) {
+	return document.getText({
+		start: {
+			line: position.line,
+			character: 0
+		},
+		end: position
+	});
+}
+/**
+* Get the full text of a line.
+*/
+function getLineText(document, lineNumber) {
+	if (lineNumber >= document.lineCount) return "";
+	const start = {
+		line: lineNumber,
+		character: 0
+	};
+	const end = {
+		line: lineNumber + 1,
+		character: 0
+	};
+	return document.getText({
+		start,
+		end
+	}).replace(/\r?\n$/, "");
+}
+/**
+* Find the entry header line by scanning backwards from the cursor.
+* Returns the line number and text of the header, or undefined if not found.
+*/
+function findEntryHeader(document, fromLine) {
+	for (let i = fromLine; i >= 0; i--) {
+		const lineText = getLineText(document, i);
+		if (TIMESTAMP_PREFIX_PATTERN.test(lineText)) return {
+			line: i,
+			text: lineText
+		};
+		if (lineText.trim() && !lineText.startsWith(" ") && !lineText.startsWith("	")) break;
+	}
+}
+/**
+* Parse entry info from a header line.
+*/
+function parseEntryInfo(headerText) {
+	const parts = headerText.split(/\s+/);
+	const info = {};
+	if (parts.length >= 2) {
+		const directive = parts[1];
+		info.directive = directive;
+		info.isSchemaEntry = isSchemaDirective(directive);
+		info.isSynthesisEntry = isSynthesisDirective(directive);
+	}
+	if (parts.length >= 3) if (info.isSynthesisEntry) info.entity = "synthesis";
+	else info.entity = parts[2];
+	return info;
+}
+/**
+* Extract existing metadata keys from lines between header and cursor.
+*/
+function extractExistingMetadataKeys(document, headerLine, currentLine) {
+	const keys = [];
+	for (let i = headerLine + 1; i < currentLine; i++) {
+		const match = getLineText(document, i).match(/^[\t ]+([a-z][a-zA-Z0-9\-_]*):/);
+		if (match) keys.push(match[1]);
+	}
+	return keys;
+}
+/**
+* Check if a line is in the content area (after a blank line following metadata).
+*/
+function isInContentArea(document, headerLine, currentLine) {
+	let foundBlankAfterMetadata = false;
+	let foundMetadata = false;
+	for (let i = headerLine + 1; i < currentLine; i++) {
+		const line = getLineText(document, i);
+		if (!line.trim()) {
+			if (foundMetadata) foundBlankAfterMetadata = true;
+			continue;
+		}
+		if (/^[\t ]+[a-z][a-zA-Z0-9\-_]*:/.test(line)) {
+			foundMetadata = true;
+			continue;
+		}
+		if (foundBlankAfterMetadata && /^[\t ]+/.test(line)) return true;
+	}
+	return foundBlankAfterMetadata;
+}
+/**
+* Check if we're inside a schema block definition (after # Metadata, # Sections, etc.)
+*/
+function isInSchemaBlock(document, headerLine, currentLine) {
+	for (let i = currentLine - 1; i > headerLine; i--) {
+		const trimmed = getLineText(document, i).trim();
+		if (trimmed === "# Metadata" || trimmed === "# Sections" || trimmed === "# Remove Metadata" || trimmed === "# Remove Sections") return true;
+	}
+	return false;
+}
+/**
+* Detect the completion context at a given position.
+*/
+function detectContext(document, position) {
+	const textBefore = getTextBeforeCursor(document, position);
+	const ctx = {
+		kind: "unknown",
+		textBefore,
+		lineText: getLineText(document, position.line),
+		lineNumber: position.line,
+		entry: {},
+		partial: ""
+	};
+	if (textBefore.endsWith("^") || /\^[\w\-:]*$/.test(textBefore)) {
+		ctx.kind = "link";
+		const match = textBefore.match(/\^([\w\-:]*)$/);
+		ctx.partial = match ? match[1] : "";
+		const header = findEntryHeader(document, position.line);
+		if (header) ctx.entry = parseEntryInfo(header.text);
+		return ctx;
+	}
+	if (!textBefore.trimStart().startsWith("#") && (textBefore.endsWith("#") || /#[\w\-./]*$/.test(textBefore))) {
+		ctx.kind = "tag";
+		const match = textBefore.match(/#([\w\-./]*)$/);
+		ctx.partial = match ? match[1] : "";
+		const header = findEntryHeader(document, position.line);
+		if (header) ctx.entry = parseEntryInfo(header.text);
+		return ctx;
+	}
+	if (textBefore === "" && position.character === 0) {
+		ctx.kind = "line_start";
+		return ctx;
+	}
+	const timestampMatch = textBefore.match(/^([12]\d{3}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d(Z|[+-][0-2]\d:[0-5]\d))\s*/);
+	if (timestampMatch) {
+		const afterTimestamp = textBefore.slice(timestampMatch[0].length);
+		if (afterTimestamp === "" || afterTimestamp.match(/^\s*$/)) {
+			ctx.kind = "after_timestamp";
+			ctx.partial = afterTimestamp.trim();
+			return ctx;
+		}
+		const parts = afterTimestamp.trim().split(/\s+/);
+		const directive = parts[0];
+		ctx.entry.directive = directive;
+		ctx.entry.isSchemaEntry = isSchemaDirective(directive);
+		ctx.entry.isSynthesisEntry = isSynthesisDirective(directive);
+		if (parts.length === 1 && !afterTimestamp.endsWith(" ")) {
+			ctx.kind = "after_timestamp";
+			ctx.partial = directive;
+			return ctx;
+		}
+		if (parts.length === 1 && afterTimestamp.endsWith(" ")) {
+			ctx.kind = "after_directive";
+			ctx.partial = "";
+			return ctx;
+		}
+		if (parts.length >= 2) ctx.entry.entity = parts[1];
+		if (parts.length === 2 && !afterTimestamp.endsWith(" ") && !afterTimestamp.includes("\"")) {
+			ctx.kind = "after_directive";
+			ctx.partial = parts[1];
+			return ctx;
+		}
+		const titleMatch = afterTimestamp.match(/"[^"]*"/);
+		if (titleMatch) {
+			ctx.kind = "header_suffix";
+			ctx.partial = afterTimestamp.slice(afterTimestamp.indexOf(titleMatch[0]) + titleMatch[0].length).trim();
+			return ctx;
+		}
+		if (parts.length >= 2) {
+			ctx.kind = "after_entity";
+			return ctx;
+		}
+	}
+	const indentMatch = textBefore.match(/^([\t ]+)/);
+	if (indentMatch && indentMatch[1].length >= 2) {
+		const header = findEntryHeader(document, position.line);
+		if (header) {
+			ctx.entry = parseEntryInfo(header.text);
+			ctx.entry.existingMetadataKeys = extractExistingMetadataKeys(document, header.line, position.line);
+		}
+		const afterIndent = textBefore.slice(indentMatch[0].length);
+		if (ctx.entry.isSchemaEntry) {
+			if (afterIndent.startsWith("#") && !afterIndent.includes(":")) {
+				ctx.kind = "schema_block_header";
+				ctx.partial = afterIndent;
+				return ctx;
+			}
+			if (header && isInSchemaBlock(document, header.line, position.line)) {
+				const colonMatch = afterIndent.match(/^[a-z][a-zA-Z0-9\-_]*\??:\s*/);
+				if (colonMatch) {
+					ctx.kind = "field_type";
+					ctx.partial = afterIndent.slice(colonMatch[0].length);
+					return ctx;
+				}
+			}
+		}
+		if (header && isInContentArea(document, header.line, position.line)) {
+			if (afterIndent.startsWith("#") && afterIndent.length <= 2) {
+				ctx.kind = "section_header";
+				ctx.partial = afterIndent.replace(/^#\s*/, "");
+				return ctx;
+			}
+			ctx.kind = "unknown";
+			return ctx;
+		}
+		const colonIndex = afterIndent.indexOf(":");
+		if (colonIndex !== -1) {
+			ctx.kind = "metadata_value";
+			ctx.metadataKey = afterIndent.slice(0, colonIndex).trim();
+			ctx.partial = afterIndent.slice(colonIndex + 1).trim();
+			return ctx;
+		}
+		ctx.kind = "metadata_key";
+		ctx.partial = afterIndent.trim();
+		return ctx;
+	}
+	return ctx;
+}
+
+//#endregion
+//#region src/handlers/completions/providers/timestamp.ts
+/**
+* Format a date as a thalo timestamp (YYYY-MM-DDTHH:MMZ) in UTC.
+*/
+function formatTimestamp$1(date = /* @__PURE__ */ new Date()) {
+	return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}T${String(date.getUTCHours()).padStart(2, "0")}:${String(date.getUTCMinutes()).padStart(2, "0")}Z`;
+}
+/**
+* Provider for timestamp completion at the start of a new entry.
+*/
+const timestampProvider = {
+	name: "timestamp",
+	contextKinds: ["line_start"],
+	getCompletions(_ctx, _workspace) {
+		const timestamp = formatTimestamp$1();
+		return [{
+			label: timestamp,
+			kind: 12,
+			detail: "Current timestamp",
+			documentation: {
+				kind: "markdown",
+				value: "Insert the current timestamp to start a new entry."
+			},
+			insertText: `${timestamp} `,
+			sortText: "0"
+		}];
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/directive.ts
+/**
+* Get description for a directive.
+*/
+function getDirectiveDescription(directive) {
+	switch (directive) {
+		case "create": return "Create a new instance entry (lore, opinion, reference, journal)";
+		case "update": return "Update an existing entry (reference a previous entry with supersedes:)";
+		case "define-entity": return "Define a new entity schema with fields and sections";
+		case "alter-entity": return "Modify an existing entity schema (add/remove fields or sections)";
+		case "define-synthesis": return "Define a synthesis operation that queries entries and generates content via LLM";
+		case "actualize-synthesis": return "Trigger a synthesis to regenerate its output based on current data";
+	}
+}
+/**
+* Get detail text for a directive.
+*/
+function getDirectiveDetail(directive) {
+	if (INSTANCE_DIRECTIVES.includes(directive)) return "Instance directive";
+	if (SCHEMA_DIRECTIVES.includes(directive)) return "Schema directive";
+	return "Synthesis directive";
+}
+/**
+* Provider for directive completion after timestamp.
+*/
+const directiveProvider = {
+	name: "directive",
+	contextKinds: ["after_timestamp"],
+	getCompletions(ctx, _workspace) {
+		const partial = ctx.partial.toLowerCase();
+		return ALL_DIRECTIVES.filter((d) => !partial || d.toLowerCase().startsWith(partial)).map((directive, index) => ({
+			label: directive,
+			kind: 14,
+			detail: getDirectiveDetail(directive),
+			documentation: {
+				kind: "markdown",
+				value: getDirectiveDescription(directive)
+			},
+			insertText: `${directive} `,
+			sortText: String(index),
+			filterText: directive
+		}));
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/entity.ts
+/**
+* Provider for entity type completion after directive.
+*
+* Entity types are defined via `define-entity` and stored in the SchemaRegistry.
+*/
+const entityProvider = {
+	name: "entity",
+	contextKinds: ["after_directive"],
+	getCompletions(ctx, workspace) {
+		const partial = ctx.partial.toLowerCase();
+		const directive = ctx.entry.directive;
+		const items = [];
+		if (directive && isInstanceDirective(directive)) for (const entityName of workspace.schemaRegistry.entityNames()) {
+			if (partial && !entityName.toLowerCase().startsWith(partial)) continue;
+			const schema = workspace.schemaRegistry.get(entityName);
+			items.push({
+				label: entityName,
+				kind: 7,
+				detail: "Entity type",
+				documentation: schema ? {
+					kind: "markdown",
+					value: `**${schema.description}**\n\nDefined at ${schema.definedAt}`
+				} : void 0,
+				insertText: `${entityName} `,
+				filterText: entityName
+			});
+		}
+		if (directive === "alter-entity") for (const entityName of workspace.schemaRegistry.entityNames()) {
+			if (partial && !entityName.toLowerCase().startsWith(partial)) continue;
+			const schema = workspace.schemaRegistry.get(entityName);
+			items.push({
+				label: entityName,
+				kind: 7,
+				detail: "Existing entity",
+				documentation: schema ? {
+					kind: "markdown",
+					value: `**${schema.description}**\n\nDefined at ${schema.definedAt}`
+				} : void 0,
+				insertText: `${entityName} `,
+				filterText: entityName
+			});
+		}
+		return items;
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/metadata-key.ts
+/**
+* Provider for metadata key completion in instance entries.
+*/
+const metadataKeyProvider = {
+	name: "metadata-key",
+	contextKinds: ["metadata_key"],
+	getCompletions(ctx, workspace) {
+		const partial = ctx.partial.toLowerCase();
+		const entity = ctx.entry.entity;
+		const existingKeys = ctx.entry.existingMetadataKeys ?? [];
+		const items = [];
+		if (ctx.entry.isSchemaEntry) return items;
+		if (!entity) return items;
+		const schema = workspace.schemaRegistry.get(entity);
+		if (!schema) return items;
+		for (const [fieldName, field] of schema.fields) {
+			if (existingKeys.includes(fieldName)) continue;
+			if (partial && !fieldName.toLowerCase().startsWith(partial)) continue;
+			const typeStr = TypeExpr.toString(field.type);
+			const optionalSuffix = field.optional ? " (optional)" : " (required)";
+			items.push({
+				label: fieldName,
+				kind: 5,
+				detail: `${typeStr}${optionalSuffix}`,
+				documentation: field.description ? {
+					kind: "markdown",
+					value: field.description
+				} : void 0,
+				insertText: `${fieldName}: `,
+				filterText: fieldName,
+				sortText: field.optional ? `1${fieldName}` : `0${fieldName}`
+			});
+		}
+		return items;
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/metadata-value.ts
+/**
+* Extract literal values from a type expression.
+*/
+function extractLiteralValues(type) {
+	switch (type.kind) {
+		case "literal": return [type.value];
+		case "union": return type.members.flatMap((m) => extractLiteralValues(m));
+		default: return [];
+	}
+}
+/**
+* Check if a type accepts links.
+*/
+function acceptsLinks(type) {
+	switch (type.kind) {
+		case "primitive": return type.name === "link";
+		case "array": return acceptsLinks(type.elementType);
+		case "union": return type.members.some((m) => acceptsLinks(m));
+		default: return false;
+	}
+}
+/**
+* Provider for metadata value completion.
+*/
+const metadataValueProvider = {
+	name: "metadata-value",
+	contextKinds: ["metadata_value"],
+	getCompletions(ctx, workspace) {
+		const partial = ctx.partial.toLowerCase();
+		const entity = ctx.entry.entity;
+		const metadataKey = ctx.metadataKey;
+		const items = [];
+		if (ctx.entry.isSchemaEntry) return items;
+		if (!entity || !metadataKey) return items;
+		const schema = workspace.schemaRegistry.get(entity);
+		if (!schema) return items;
+		const field = schema.fields.get(metadataKey);
+		if (!field) return items;
+		const literals = extractLiteralValues(field.type);
+		for (const value of literals) {
+			if (partial && !value.toLowerCase().startsWith(partial)) continue;
+			items.push({
+				label: value,
+				kind: 12,
+				detail: `Valid value for ${metadataKey}`,
+				insertText: value,
+				filterText: value
+			});
+		}
+		if (metadataKey === "subject" && acceptsLinks(field.type)) {
+			if (!partial || "self".startsWith(partial) || "^self".startsWith(partial)) items.push({
+				label: "^self",
+				kind: 18,
+				detail: "Reference to yourself",
+				documentation: {
+					kind: "markdown",
+					value: "Use `^self` for personal lore entries about yourself."
+				},
+				insertText: "^self",
+				filterText: "self",
+				sortText: "0"
+			});
+		}
+		return items;
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/link.ts
+/**
+* Format a timestamp to string
+*/
+function formatTimestamp(ts) {
+	return `${`${ts.date.year}-${String(ts.date.month).padStart(2, "0")}-${String(ts.date.day).padStart(2, "0")}`}T${`${String(ts.time.hour).padStart(2, "0")}:${String(ts.time.minute).padStart(2, "0")}`}${isSyntaxError(ts.timezone) ? "" : ts.timezone.value}`;
+}
+/**
+* Get sort text for an entry (prefer recent entries).
+*/
+function getSortText(entry) {
+	let ts;
+	switch (entry.type) {
+		case "instance_entry":
+			ts = entry.header.timestamp;
+			break;
+		case "schema_entry":
+			ts = entry.header.timestamp;
+			break;
+		case "synthesis_entry":
+			ts = entry.header.timestamp;
+			break;
+		case "actualize_entry":
+			ts = entry.header.timestamp;
+			break;
+	}
+	return formatTimestamp(ts).split("").map((c) => String.fromCharCode(126 - c.charCodeAt(0))).join("");
+}
+/**
+* Get title from an entry
+*/
+function getEntryTitle(entry) {
+	switch (entry.type) {
+		case "instance_entry": return entry.header.title?.value ?? "(no title)";
+		case "synthesis_entry": return entry.header.title?.value ?? "(no title)";
+		case "actualize_entry": return `actualize-synthesis ^${entry.header.target.id}`;
+		case "schema_entry": return entry.header.title?.value ?? "(no title)";
+	}
+}
+/**
+* Get entity description from an entry
+*/
+function getEntryEntity(entry) {
+	switch (entry.type) {
+		case "instance_entry": return entry.header.entity;
+		case "synthesis_entry": return "synthesis";
+		case "actualize_entry": return "actualize";
+		case "schema_entry": return entry.header.entityName.value;
+	}
+}
+/**
+* Format a link completion item.
+*/
+function formatLinkCompletion(linkId, definition) {
+	const entry = definition.entry;
+	const title = getEntryTitle(entry);
+	const entity = getEntryEntity(entry);
+	let ts;
+	switch (entry.type) {
+		case "instance_entry":
+			ts = entry.header.timestamp;
+			break;
+		case "schema_entry":
+			ts = entry.header.timestamp;
+			break;
+		case "synthesis_entry":
+			ts = entry.header.timestamp;
+			break;
+		case "actualize_entry":
+			ts = entry.header.timestamp;
+			break;
+	}
+	const timestamp = formatTimestamp(ts);
+	return {
+		label: `^${linkId}`,
+		kind: 18,
+		detail: title,
+		documentation: {
+			kind: "markdown",
+			value: `**${title}**\n\n${timestamp} • ${entity}\n\n*${definition.file}*`
+		},
+		insertText: linkId,
+		sortText: getSortText(entry),
+		filterText: linkId
+	};
+}
+/**
+* Provider for link completion (^link-id).
+*/
+const linkProvider = {
+	name: "link",
+	contextKinds: ["link", "header_suffix"],
+	getCompletions(ctx, workspace) {
+		if (ctx.kind === "header_suffix" && !ctx.partial.includes("^")) return [];
+		const partial = ctx.kind === "link" ? ctx.partial.toLowerCase() : ctx.partial.replace(/.*\^/, "").toLowerCase();
+		const items = [];
+		const linkIndex = workspace.linkIndex;
+		for (const [linkId, definition] of linkIndex.definitions) {
+			if (partial && !linkId.toLowerCase().includes(partial)) {
+				const entry = definition.entry;
+				if (!getEntryTitle(entry).toLowerCase().includes(partial)) continue;
+			}
+			items.push(formatLinkCompletion(linkId, definition));
+		}
+		return items;
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/tag.ts
+/**
+* Get tags from an entry
+*/
+function getEntryTags(entry) {
+	switch (entry.type) {
+		case "instance_entry": return entry.header.tags.map((t) => t.name);
+		case "schema_entry": return entry.header.tags.map((t) => t.name);
+		case "synthesis_entry": return entry.header.tags.map((t) => t.name);
+		case "actualize_entry": return [];
+	}
+}
+/**
+* Get all unique tags from the workspace with counts.
+*/
+function getTagsWithCounts(workspace) {
+	const tagCounts = /* @__PURE__ */ new Map();
+	for (const model of workspace.allModels()) for (const entry of model.ast.entries) for (const tag of getEntryTags(entry)) tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+	return tagCounts;
+}
+/**
+* Format a tag completion item.
+*/
+function formatTagCompletion(tag, count) {
+	return {
+		label: `#${tag}`,
+		kind: 20,
+		detail: `${count} ${count === 1 ? "entry" : "entries"}`,
+		insertText: tag,
+		filterText: tag,
+		sortText: String(1e6 - count).padStart(7, "0")
+	};
+}
+/**
+* Provider for tag completion (#tag).
+*/
+const tagProvider = {
+	name: "tag",
+	contextKinds: ["tag", "header_suffix"],
+	getCompletions(ctx, workspace) {
+		if (ctx.kind === "header_suffix" && !ctx.partial.includes("#")) return [];
+		const partial = ctx.kind === "tag" ? ctx.partial.toLowerCase() : ctx.partial.replace(/.*#/, "").toLowerCase();
+		const items = [];
+		const tagCounts = getTagsWithCounts(workspace);
+		for (const [tag, count] of tagCounts) {
+			if (partial && !tag.toLowerCase().includes(partial)) continue;
+			items.push(formatTagCompletion(tag, count));
+		}
+		return items;
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/section.ts
+/**
+* Provider for section header completion in content area (# Section).
+*/
+const sectionProvider = {
+	name: "section",
+	contextKinds: ["section_header"],
+	getCompletions(ctx, workspace) {
+		const partial = ctx.partial.toLowerCase();
+		const entity = ctx.entry.entity;
+		const items = [];
+		if (!entity) return items;
+		const schema = workspace.schemaRegistry.get(entity);
+		if (!schema) return items;
+		for (const [sectionName, section] of schema.sections) {
+			if (partial && !sectionName.toLowerCase().startsWith(partial)) continue;
+			const optionalSuffix = section.optional ? " (optional)" : " (required)";
+			items.push({
+				label: sectionName,
+				kind: 22,
+				detail: `Section${optionalSuffix}`,
+				documentation: section.description ? {
+					kind: "markdown",
+					value: section.description
+				} : void 0,
+				insertText: ` ${sectionName}`,
+				filterText: sectionName,
+				sortText: section.optional ? `1${sectionName}` : `0${sectionName}`
+			});
+		}
+		return items;
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/schema-block.ts
+/**
+* Get description for a schema block header.
+*/
+function getBlockDescription(header) {
+	switch (header) {
+		case "# Metadata": return "Define metadata fields for this entity";
+		case "# Sections": return "Define content sections for this entity";
+		case "# Remove Metadata": return "Remove metadata fields (alter-entity only)";
+		case "# Remove Sections": return "Remove sections (alter-entity only)";
+	}
+}
+/**
+* Provider for schema block header completion (# Metadata, # Sections, etc.)
+*/
+const schemaBlockProvider = {
+	name: "schema-block",
+	contextKinds: ["schema_block_header"],
+	getCompletions(ctx, _workspace) {
+		const partial = ctx.partial.toLowerCase();
+		const directive = ctx.entry.directive;
+		const items = [];
+		for (const header of SCHEMA_BLOCK_HEADERS) {
+			if ((header === "# Remove Metadata" || header === "# Remove Sections") && directive !== "alter-entity") continue;
+			if (partial && !header.toLowerCase().startsWith(partial)) continue;
+			items.push({
+				label: header,
+				kind: 22,
+				detail: "Schema block",
+				documentation: {
+					kind: "markdown",
+					value: getBlockDescription(header)
+				},
+				insertText: header.slice(1),
+				filterText: header
+			});
+		}
+		return items;
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/type-expr.ts
+/**
+* Get description for a primitive type.
+*/
+function getPrimitiveTypeDescription(type) {
+	switch (type) {
+		case "string": return "Any text value";
+		case "datetime": return "Date value (YYYY-MM-DD)";
+		case "daterange": return "Date range (YYYY ~ YYYY, YYYY-MM, YYYY Q1, etc.)";
+		case "link": return "Reference to another entry (^link-id)";
+		case "number": return "Numeric value (integer or float)";
+	}
+}
+/**
+* Provider for type expression completion in schema field definitions.
+*/
+const typeExprProvider = {
+	name: "type-expr",
+	contextKinds: ["field_type"],
+	getCompletions(ctx, _workspace) {
+		const partial = ctx.partial.toLowerCase();
+		const items = [];
+		for (const type of PRIMITIVE_TYPES) {
+			if (partial && !type.toLowerCase().startsWith(partial)) continue;
+			items.push({
+				label: type,
+				kind: 25,
+				detail: "Primitive type",
+				documentation: {
+					kind: "markdown",
+					value: getPrimitiveTypeDescription(type)
+				},
+				insertText: type,
+				filterText: type
+			});
+		}
+		if (!partial || "\"".startsWith(partial)) items.push({
+			label: "\"...\"",
+			kind: 12,
+			detail: "Literal type",
+			documentation: {
+				kind: "markdown",
+				value: "Define a literal value type (e.g., \"article\" | \"video\")"
+			},
+			insertText: "\"",
+			filterText: "\""
+		});
+		return items;
+	}
+};
+
+//#endregion
+//#region src/handlers/completions/providers/providers.ts
+/**
+* All completion providers, in order of priority.
+*/
+const allProviders = [
+	timestampProvider,
+	directiveProvider,
+	entityProvider,
+	metadataKeyProvider,
+	metadataValueProvider,
+	linkProvider,
+	tagProvider,
+	sectionProvider,
+	schemaBlockProvider,
+	typeExprProvider
+];
+
+//#endregion
+//#region src/handlers/completions/completions.ts
+/**
+* Handle textDocument/completion request.
+*
+* @param workspace - The thalo workspace for schema/link lookups
+* @param document - The text document
+* @param params - Completion parameters
+* @returns Array of completion items
+*/
+function handleCompletion(workspace, document, params) {
+	const ctx = detectContext(document, params.position);
+	const items = [];
+	for (const provider of allProviders) if (provider.contextKinds.includes(ctx.kind)) items.push(...provider.getCompletions(ctx, workspace));
+	return items;
+}
+/**
+* Handle completionItem/resolve request.
+*
+* Provides additional details for a completion item.
+*
+* @param item - The completion item to resolve
+* @returns The resolved completion item
+*/
+function handleCompletionResolve(item) {
+	return item;
+}
+
+//#endregion
+//#region src/server.ts
+/**
+* Create the initial server state
+*/
+function createServerState(connection) {
+	return {
+		workspace: createWorkspace(),
+		documents: /* @__PURE__ */ new Map(),
+		connection,
+		workspaceFolders: []
+	};
+}
+/**
+* Get the file type from a URI
+*/
+function getFileType(uri) {
+	if (uri.endsWith(".thalo")) return "thalo";
+	if (uri.endsWith(".md")) return "markdown";
+	return "thalo";
+}
+/**
+* Convert a URI to a file path
+*/
+function uriToPath(uri) {
+	if (uri.startsWith("file://")) return decodeURIComponent(uri.slice(7));
+	return uri;
+}
+/**
+* Collect all .thalo and .md files from a directory recursively
+*/
+function collectThaloFiles(dir) {
+	const files = [];
+	function walk(currentDir) {
+		let entries;
+		try {
+			entries = fs.readdirSync(currentDir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = path.join(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				if (!entry.name.startsWith(".") && entry.name !== "node_modules") walk(fullPath);
+			} else if (entry.isFile()) {
+				if (entry.name.endsWith(".thalo") || entry.name.endsWith(".md")) files.push(fullPath);
+			}
+		}
+	}
+	walk(dir);
+	return files;
+}
+/**
+* Load all thalo files from the workspace folders into the workspace.
+* This ensures cross-file features work correctly even for files not yet opened.
+*/
+function loadWorkspaceFiles(state) {
+	for (const folder of state.workspaceFolders) {
+		const files = collectThaloFiles(folder);
+		for (const file of files) {
+			if (state.workspace.getModel(file)) continue;
+			try {
+				const source = fs.readFileSync(file, "utf-8");
+				const fileType = getFileType(file);
+				state.workspace.addDocument(source, {
+					filename: file,
+					fileType
+				});
+			} catch (err) {
+				console.error(`[thalo-lsp] Error loading ${file}: ${err instanceof Error ? err.message : err}`);
+			}
+		}
+		console.error(`[thalo-lsp] Loaded ${files.length} files from ${folder}`);
+	}
+}
+/**
+* Publish diagnostics for a single document
+*/
+function publishDiagnosticsForDocument(state, doc) {
+	try {
+		const diagnostics = getDiagnostics(state.workspace, doc);
+		state.connection.sendDiagnostics({
+			uri: doc.uri,
+			diagnostics
+		});
+	} catch (error) {
+		const path$1 = uriToPath(doc.uri);
+		console.error(`[thalo-lsp] Error getting diagnostics for ${path$1}:`, error);
+		state.connection.sendDiagnostics({
+			uri: doc.uri,
+			diagnostics: [{
+				range: {
+					start: {
+						line: 0,
+						character: 0
+					},
+					end: {
+						line: 0,
+						character: 0
+					}
+				},
+				severity: 1,
+				source: "thalo",
+				message: `Diagnostic error: ${error instanceof Error ? error.message : String(error)}`
+			}]
+		});
+	}
+}
+/**
+* Refresh diagnostics for specific files based on invalidation result.
+* Only refreshes open documents that are in the affected files list.
+*/
+function refreshDiagnosticsForFiles(state, affectedFiles, changedFile) {
+	const affectedSet = new Set(affectedFiles);
+	for (const doc of state.documents.values()) {
+		const docPath = uriToPath(doc.uri);
+		if (docPath === changedFile || affectedSet.has(docPath)) publishDiagnosticsForDocument(state, doc);
+	}
+}
+/**
+* Update a document in the workspace and publish diagnostics
+*/
+function updateDocument(state, doc) {
+	const filePath = uriToPath(doc.uri);
+	try {
+		const invalidation = state.workspace.updateDocument(filePath, doc.getText());
+		if (invalidation.schemasChanged || invalidation.linksChanged) refreshDiagnosticsForFiles(state, invalidation.affectedFiles, filePath);
+		else publishDiagnosticsForDocument(state, doc);
+	} catch (error) {
+		console.error(`[thalo-lsp] Parse error in ${filePath}:`, error);
+		state.connection.sendDiagnostics({
+			uri: doc.uri,
+			diagnostics: [{
+				range: {
+					start: {
+						line: 0,
+						character: 0
+					},
+					end: {
+						line: 0,
+						character: 0
+					}
+				},
+				severity: 1,
+				source: "thalo",
+				message: `Parse error: ${error instanceof Error ? error.message : String(error)}`
+			}]
+		});
+	}
+}
+/**
+* Create a new LSP connection
+*/
+function createConnection() {
+	return createConnection$1(ProposedFeatures.all);
+}
+/**
+* Start the LSP server
+*
+* @param connection - The LSP connection to use (defaults to stdio)
+*/
+function startServer(connection = createConnection()) {
+	const state = createServerState(connection);
+	connection.onInitialize((params) => {
+		console.error(`[thalo-lsp] Initializing with workspace: ${params.workspaceFolders?.[0]?.uri}`);
+		if (params.workspaceFolders) state.workspaceFolders = params.workspaceFolders.map((folder) => uriToPath(folder.uri));
+		else if (params.rootUri) state.workspaceFolders = [uriToPath(params.rootUri)];
+		return {
+			capabilities: serverCapabilities,
+			serverInfo: {
+				name: "thalo-lsp",
+				version: "0.0.0"
+			}
+		};
+	});
+	connection.onInitialized(() => {
+		console.error("[thalo-lsp] Server initialized");
+		connection.client.register(DidChangeConfigurationNotification.type, void 0);
+		loadWorkspaceFiles(state);
+	});
+	connection.onDidOpenTextDocument((params) => {
+		const doc = TextDocument.create(params.textDocument.uri, params.textDocument.languageId, params.textDocument.version, params.textDocument.text);
+		state.documents.set(params.textDocument.uri, doc);
+		updateDocument(state, doc);
+		console.error(`[thalo-lsp] Opened: ${params.textDocument.uri}`);
+	});
+	connection.onDidChangeTextDocument((params) => {
+		const doc = state.documents.get(params.textDocument.uri);
+		if (doc) {
+			const updated = TextDocument.update(doc, params.contentChanges, params.textDocument.version);
+			state.documents.set(params.textDocument.uri, updated);
+			updateDocument(state, updated);
+		}
+	});
+	connection.onDidCloseTextDocument((params) => {
+		state.documents.delete(params.textDocument.uri);
+		const filePath = uriToPath(params.textDocument.uri);
+		try {
+			if (fs.existsSync(filePath)) {
+				const source = fs.readFileSync(filePath, "utf-8");
+				const fileType = getFileType(params.textDocument.uri);
+				state.workspace.addDocument(source, {
+					filename: filePath,
+					fileType
+				});
+			} else state.workspace.removeDocument(filePath);
+		} catch {
+			state.workspace.removeDocument(filePath);
+		}
+		connection.sendDiagnostics({
+			uri: params.textDocument.uri,
+			diagnostics: []
+		});
+		console.error(`[thalo-lsp] Closed: ${params.textDocument.uri}`);
+	});
+	connection.onDidChangeWatchedFiles((params) => {
+		const allAffectedFiles = [];
+		for (const change of params.changes) {
+			const filePath = uriToPath(change.uri);
+			if (!filePath.endsWith(".thalo") && !filePath.endsWith(".md")) continue;
+			if (change.type === FileChangeType.Deleted) {
+				const affected = state.workspace.getAffectedFiles(filePath);
+				allAffectedFiles.push(...affected);
+				state.workspace.removeDocument(filePath);
+				state.documents.delete(change.uri);
+				connection.sendDiagnostics({
+					uri: change.uri,
+					diagnostics: []
+				});
+				console.error(`[thalo-lsp] Removed deleted file: ${filePath}`);
+				continue;
+			}
+			if (state.documents.has(change.uri)) continue;
+			switch (change.type) {
+				case FileChangeType.Created:
+				case FileChangeType.Changed:
+					try {
+						if (fs.existsSync(filePath)) {
+							const source = fs.readFileSync(filePath, "utf-8");
+							const invalidation = state.workspace.updateDocument(filePath, source);
+							allAffectedFiles.push(...invalidation.affectedFiles);
+							console.error(`[thalo-lsp] Loaded external file: ${filePath}`);
+						}
+					} catch (err) {
+						console.error(`[thalo-lsp] Error loading ${filePath}: ${err instanceof Error ? err.message : err}`);
+					}
+					break;
+			}
+		}
+		if (allAffectedFiles.length > 0) {
+			const affectedSet = new Set(allAffectedFiles);
+			for (const doc of state.documents.values()) if (affectedSet.has(uriToPath(doc.uri))) publishDiagnosticsForDocument(state, doc);
+		}
+	});
+	connection.workspace.onDidCreateFiles((params) => {
+		const allAffectedFiles = [];
+		for (const file of params.files) {
+			const filePath = uriToPath(file.uri);
+			if (!filePath.endsWith(".thalo") && !filePath.endsWith(".md")) continue;
+			try {
+				if (fs.existsSync(filePath)) {
+					const source = fs.readFileSync(filePath, "utf-8");
+					const invalidation = state.workspace.updateDocument(filePath, source);
+					allAffectedFiles.push(...invalidation.affectedFiles);
+					console.error(`[thalo-lsp] Loaded created file: ${filePath}`);
+				}
+			} catch (err) {
+				console.error(`[thalo-lsp] Error loading created file ${filePath}: ${err instanceof Error ? err.message : err}`);
+			}
+		}
+		if (allAffectedFiles.length > 0) {
+			const affectedSet = new Set(allAffectedFiles);
+			for (const doc of state.documents.values()) if (affectedSet.has(uriToPath(doc.uri))) publishDiagnosticsForDocument(state, doc);
+		}
+	});
+	connection.workspace.onDidDeleteFiles((params) => {
+		const allAffectedFiles = [];
+		for (const file of params.files) {
+			const filePath = uriToPath(file.uri);
+			if (!filePath.endsWith(".thalo") && !filePath.endsWith(".md")) continue;
+			const affected = state.workspace.getAffectedFiles(filePath);
+			allAffectedFiles.push(...affected);
+			state.workspace.removeDocument(filePath);
+			console.error(`[thalo-lsp] Removed file: ${filePath}`);
+		}
+		if (allAffectedFiles.length > 0) {
+			const affectedSet = new Set(allAffectedFiles);
+			for (const doc of state.documents.values()) if (affectedSet.has(uriToPath(doc.uri))) publishDiagnosticsForDocument(state, doc);
+		}
+	});
+	connection.workspace.onDidRenameFiles((params) => {
+		const allAffectedFiles = [];
+		for (const file of params.files) {
+			const oldPath = uriToPath(file.oldUri);
+			const newPath = uriToPath(file.newUri);
+			const oldIsThalo = oldPath.endsWith(".thalo") || oldPath.endsWith(".md");
+			const newIsThalo = newPath.endsWith(".thalo") || newPath.endsWith(".md");
+			if (oldIsThalo) {
+				const affected = state.workspace.getAffectedFiles(oldPath);
+				allAffectedFiles.push(...affected);
+				state.workspace.removeDocument(oldPath);
+				console.error(`[thalo-lsp] Removed renamed file: ${oldPath}`);
+			}
+			if (newIsThalo) try {
+				if (fs.existsSync(newPath)) {
+					const source = fs.readFileSync(newPath, "utf-8");
+					const invalidation = state.workspace.updateDocument(newPath, source);
+					allAffectedFiles.push(...invalidation.affectedFiles);
+					console.error(`[thalo-lsp] Loaded renamed file: ${newPath}`);
+				}
+			} catch (err) {
+				console.error(`[thalo-lsp] Error loading renamed file ${newPath}: ${err instanceof Error ? err.message : err}`);
+			}
+		}
+		if (allAffectedFiles.length > 0) {
+			const affectedSet = new Set(allAffectedFiles);
+			for (const doc of state.documents.values()) if (affectedSet.has(uriToPath(doc.uri))) publishDiagnosticsForDocument(state, doc);
+		}
+	});
+	connection.onDefinition((params) => {
+		const doc = state.documents.get(params.textDocument.uri);
+		if (!doc) return null;
+		return handleDefinition(state.workspace, doc, params.position);
+	});
+	connection.onReferences((params) => {
+		const doc = state.documents.get(params.textDocument.uri);
+		if (!doc) return null;
+		return handleReferences(state.workspace, doc, params.position, params.context);
+	});
+	connection.onHover((params) => {
+		const doc = state.documents.get(params.textDocument.uri);
+		if (!doc) return null;
+		return handleHover(state.workspace, doc, params.position);
+	});
+	connection.onCompletion((params) => {
+		const doc = state.documents.get(params.textDocument.uri);
+		if (!doc) return [];
+		return handleCompletion(state.workspace, doc, params);
+	});
+	connection.onCompletionResolve((item) => {
+		return handleCompletionResolve(item);
+	});
+	connection.onRequest("textDocument/semanticTokens/full", (params) => {
+		const doc = state.documents.get(params.textDocument.uri);
+		if (!doc) return { data: [] };
+		return handleSemanticTokens(doc);
+	});
+	connection.listen();
+	console.error("[thalo-lsp] Server started");
+}
+if (import.meta.url === `file://${process.argv[1]}`) startServer();
+
+//#endregion
+export { createConnection, startServer, tokenLegend };