treelsp 0.0.1

package/dist/runtime-CnCx2QS4.js

@@ -0,0 +1,1914 @@
+import Parser from "web-tree-sitter";
+
+//#region src/runtime/parser/node.ts
+/**
+* AST node wrapper providing a friendly API over Tree-sitter's SyntaxNode
+*
+* This class matches the usage patterns from DESIGN.md:
+* - node.field('name') - access named fields
+* - node.fields('params') - access repeated fields
+* - node.field('type')?.text - optional chaining
+* - node.hasChild('export') - check field existence
+*/
+var ASTNode = class ASTNode {
+	/**
+	* Wrapped Tree-sitter SyntaxNode
+	* Kept private to force API usage
+	*/
+	syntaxNode;
+	/**
+	* Source text provider (optional - for efficient text access)
+	* If not provided, uses syntaxNode.text which is slower
+	*/
+	sourceProvider;
+	constructor(syntaxNode, sourceProvider) {
+		this.syntaxNode = syntaxNode;
+		this.sourceProvider = sourceProvider;
+	}
+	/**
+	* Internal accessor for other runtime modules
+	* Not part of the public API — prefixed with underscore
+	* @internal
+	*/
+	get _syntaxNode() {
+		return this.syntaxNode;
+	}
+	/**
+	* Get single child by field name
+	* Returns null if field doesn't exist or has no value
+	*
+	* @example
+	* ```typescript
+	* const name = node.field('name');
+	* if (name) {
+	*   console.log(name.text);
+	* }
+	* ```
+	*/
+	field(name) {
+		const child = this.syntaxNode.childForFieldName(name);
+		if (!child) return null;
+		return new ASTNode(child, this.sourceProvider);
+	}
+	/**
+	* Get all children for a field (handles repeated fields)
+	* Returns empty array if field doesn't exist
+	*
+	* @example
+	* ```typescript
+	* const params = node.fields('params');
+	* for (const param of params) {
+	*   console.log(param.field('name')?.text);
+	* }
+	* ```
+	*/
+	fields(name) {
+		const children = this.syntaxNode.childrenForFieldName(name);
+		return children.map((child) => new ASTNode(child, this.sourceProvider));
+	}
+	/**
+	* Alias for field() - matches Tree-sitter API
+	* Provided for users familiar with Tree-sitter
+	*/
+	childForFieldName(name) {
+		return this.field(name);
+	}
+	/**
+	* Check if node has a child with given field name
+	*
+	* @example
+	* ```typescript
+	* const visibility = node.hasChild('export') ? 'public' : 'private';
+	* ```
+	*/
+	hasChild(name) {
+		return this.syntaxNode.childForFieldName(name) !== null;
+	}
+	/**
+	* Stable node identity (from Tree-sitter SyntaxNode.id)
+	* Safe to use as Map key — same tree node always returns same id
+	*/
+	get id() {
+		return this.syntaxNode.id;
+	}
+	/**
+	* Node type from grammar (e.g., 'variable_decl', 'identifier')
+	*/
+	get type() {
+		return this.syntaxNode.type;
+	}
+	/**
+	* Source text for this node
+	* Uses sourceProvider if available for better performance
+	*/
+	get text() {
+		if (this.sourceProvider) {
+			const source = this.sourceProvider();
+			return source.slice(this.syntaxNode.startIndex, this.syntaxNode.endIndex);
+		}
+		return this.syntaxNode.text;
+	}
+	/**
+	* Is this an error node? (parsing failed)
+	*/
+	get isError() {
+		return this.syntaxNode.isError || this.syntaxNode.hasError;
+	}
+	/**
+	* Is this a missing node? (expected but not found)
+	*/
+	get isMissing() {
+		return this.syntaxNode.isMissing;
+	}
+	/**
+	* Is this a named node? (appears in the grammar)
+	*/
+	get isNamed() {
+		return this.syntaxNode.isNamed;
+	}
+	/**
+	* Parent node (null for root)
+	*/
+	get parent() {
+		const parentNode = this.syntaxNode.parent;
+		if (!parentNode) return null;
+		return new ASTNode(parentNode, this.sourceProvider);
+	}
+	/**
+	* All children (including unnamed nodes like punctuation)
+	*/
+	get children() {
+		return this.syntaxNode.children.map((child) => new ASTNode(child, this.sourceProvider));
+	}
+	/**
+	* Named children only (grammar rules, not literals)
+	*/
+	get namedChildren() {
+		return this.syntaxNode.namedChildren.map((child) => new ASTNode(child, this.sourceProvider));
+	}
+	/**
+	* Get child by index
+	*/
+	child(index) {
+		const child = this.syntaxNode.child(index);
+		if (!child) return null;
+		return new ASTNode(child, this.sourceProvider);
+	}
+	/**
+	* Get named child by index
+	*/
+	namedChild(index) {
+		const child = this.syntaxNode.namedChild(index);
+		if (!child) return null;
+		return new ASTNode(child, this.sourceProvider);
+	}
+	/**
+	* Number of children
+	*/
+	get childCount() {
+		return this.syntaxNode.childCount;
+	}
+	/**
+	* Number of named children
+	*/
+	get namedChildCount() {
+		return this.syntaxNode.namedChildCount;
+	}
+	/**
+	* Convert Tree-sitter Point to LSP Position
+	*/
+	toPosition(point) {
+		return {
+			line: point.row,
+			character: point.column
+		};
+	}
+	/**
+	* Start position (LSP format: 0-based line and character)
+	*/
+	get startPosition() {
+		return this.toPosition(this.syntaxNode.startPosition);
+	}
+	/**
+	* End position (LSP format: 0-based line and character)
+	*/
+	get endPosition() {
+		return this.toPosition(this.syntaxNode.endPosition);
+	}
+	/**
+	* Start byte offset in source
+	*/
+	get startIndex() {
+		return this.syntaxNode.startIndex;
+	}
+	/**
+	* End byte offset in source
+	*/
+	get endIndex() {
+		return this.syntaxNode.endIndex;
+	}
+	/**
+	* Find smallest descendant at byte offset
+	*/
+	descendantForIndex(startIndex, endIndex) {
+		const node = endIndex !== void 0 ? this.syntaxNode.descendantForIndex(startIndex, endIndex) : this.syntaxNode.descendantForIndex(startIndex);
+		return new ASTNode(node, this.sourceProvider);
+	}
+	/**
+	* Find smallest descendant at position
+	*/
+	descendantForPosition(startPosition, endPosition) {
+		const start = {
+			row: startPosition.line,
+			column: startPosition.character
+		};
+		const node = endPosition ? this.syntaxNode.descendantForPosition(start, {
+			row: endPosition.line,
+			column: endPosition.character
+		}) : this.syntaxNode.descendantForPosition(start);
+		return new ASTNode(node, this.sourceProvider);
+	}
+	/**
+	* Get all descendants of specific type(s)
+	*
+	* @example
+	* ```typescript
+	* const vars = root.descendantsOfType('variable_decl');
+	* const allRefs = root.descendantsOfType(['identifier', 'name_ref']);
+	* ```
+	*/
+	descendantsOfType(types, startPosition, endPosition) {
+		const start = startPosition ? {
+			row: startPosition.line,
+			column: startPosition.character
+		} : void 0;
+		const end = endPosition ? {
+			row: endPosition.line,
+			column: endPosition.character
+		} : void 0;
+		const nodes = this.syntaxNode.descendantsOfType(types, start, end);
+		return nodes.map((node) => new ASTNode(node, this.sourceProvider));
+	}
+	/**
+	* String representation (for debugging)
+	*/
+	toString() {
+		return this.syntaxNode.toString();
+	}
+	/**
+	* Get S-expression representation of the syntax tree
+	*/
+	toSExpression() {
+		return this.syntaxNode.toString();
+	}
+};
+
+//#endregion
+//#region src/runtime/parser/wasm.ts
+/**
+* Global state - Parser.init() must be called exactly once
+*/
+const state = {
+	initialized: false,
+	initPromise: null
+};
+/**
+* Language cache - reuse loaded languages
+*/
+const languageCache = {};
+/**
+* Detect runtime platform
+*/
+function detectPlatform() {
+	const global = globalThis;
+	if (typeof global.window !== "undefined" && typeof global.document !== "undefined") return "browser";
+	if (typeof process !== "undefined" && process.versions?.node) return "node";
+	return "node";
+}
+/**
+* Ensure Parser is initialized
+* Safe to call multiple times - initialization happens only once
+*/
+async function ensureInitialized() {
+	if (state.initialized) return;
+	if (state.initPromise) {
+		await state.initPromise;
+		return;
+	}
+	state.initPromise = (async () => {
+		const platform = detectPlatform();
+		if (platform === "browser") await Parser.init();
+		else await Parser.init();
+		state.initialized = true;
+	})();
+	await state.initPromise;
+}
+/**
+* Load a Tree-sitter language from WASM file
+* Languages are cached to avoid redundant loading
+*
+* @param wasmPath Path to grammar.wasm file
+* @returns Tree-sitter Language instance
+*/
+async function loadLanguage(wasmPath) {
+	await ensureInitialized();
+	const cached = languageCache[wasmPath];
+	if (cached) return cached;
+	try {
+		const language = await Parser.Language.load(wasmPath);
+		languageCache[wasmPath] = language;
+		return language;
+	} catch (error) {
+		throw new Error(`Failed to load Tree-sitter grammar from ${wasmPath}. Ensure the WASM file exists and is accessible. Run 'treelsp build' to generate the grammar. Original error: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* Create a new Tree-sitter parser with the specified language
+* This is the main entry point for creating parsers
+*
+* @param wasmPath Path to grammar.wasm file
+* @returns Configured Parser instance ready to use
+*
+* @example
+* ```typescript
+* const parser = await createParser('./generated/grammar.wasm');
+* const tree = parser.parse('let x = 42;');
+* ```
+*/
+async function createParser(wasmPath) {
+	const language = await loadLanguage(wasmPath);
+	const parser = new Parser();
+	parser.setLanguage(language);
+	return parser;
+}
+/**
+* Preload Parser initialization (optional)
+* Useful for reducing latency of the first parse
+*/
+async function preloadParser() {
+	await ensureInitialized();
+}
+
+//#endregion
+//#region src/runtime/parser/tree.ts
+/**
+* Document state with incremental parsing
+*
+* V1 strategy (DESIGN.md lines 16-24):
+* - Keystroke → Tree-sitter incremental CST reparse → full AST rebuild → full scope rebuild
+* - Tree-sitter's CST reparse is incremental automatically (via oldTree)
+* - AST and scope are full recompute (simple and correct)
+* - DocumentState.update() owns the boundary, designed for v2 incremental upgrade
+*
+* Memory management:
+* - Tree-sitter uses WASM memory that must be explicitly freed
+* - Call dispose() when done with the document
+*/
+var DocumentState = class {
+	/**
+	* Document metadata
+	*/
+	metadata;
+	/**
+	* Current source text
+	*/
+	sourceText;
+	/**
+	* Tree-sitter parser (owns the Language)
+	*/
+	parser;
+	/**
+	* Current parse tree (kept for incremental parsing)
+	* Must be deleted when replaced to free WASM memory
+	*/
+	tree = null;
+	/**
+	* Root AST node (cached after parse)
+	*/
+	rootNode = null;
+	constructor(parser, metadata, initialText) {
+		this.parser = parser;
+		this.metadata = metadata;
+		this.sourceText = initialText;
+		this.reparse();
+	}
+	/**
+	* Parse or reparse the document
+	*
+	* V1 strategy: Always parse from scratch (no incremental CST reuse).
+	* Tree-sitter's incremental parsing requires calling tree.edit() with
+	* precise byte-offset edit info before passing the old tree. Without it,
+	* tree-sitter reuses old nodes at wrong positions, producing garbled ASTs.
+	* V2 will add proper edit tracking to enable incremental parsing.
+	*/
+	reparse() {
+		const newTree = this.parser.parse(this.sourceText);
+		if (this.tree) this.tree.delete();
+		this.tree = newTree;
+		this.rootNode = new ASTNode(newTree.rootNode, () => this.sourceText);
+	}
+	/**
+	* Get root AST node
+	*/
+	get root() {
+		if (!this.rootNode) throw new Error("Document has not been parsed");
+		return this.rootNode;
+	}
+	/**
+	* Update document with new text (full replacement)
+	*
+	* V1 API: Simple full text replacement
+	* Tree-sitter does incremental CST reparse automatically via oldTree
+	* We rebuild the full AST wrapper (simple and correct for v1)
+	*
+	* @param newText New source text
+	* @param newVersion Document version after update (optional, will auto-increment)
+	*/
+	update(newText, newVersion) {
+		this.sourceText = newText;
+		if (newVersion !== void 0) this.metadata.version = newVersion;
+		else this.metadata.version++;
+		this.reparse();
+	}
+	/**
+	* Get current source text
+	*/
+	get text() {
+		return this.sourceText;
+	}
+	/**
+	* Get document URI
+	*/
+	get uri() {
+		return this.metadata.uri;
+	}
+	/**
+	* Get document version
+	*/
+	get version() {
+		return this.metadata.version;
+	}
+	/**
+	* Get language ID
+	*/
+	get languageId() {
+		return this.metadata.languageId;
+	}
+	/**
+	* Check if document has parse errors
+	* Tree-sitter is error-tolerant - always returns a tree
+	* Check this to detect ERROR nodes
+	*/
+	get hasErrors() {
+		return this.root.isError;
+	}
+	/**
+	* Dispose resources (free WASM memory)
+	* Call this when done with the document
+	*
+	* @example
+	* ```typescript
+	* const doc = await createDocumentState(...);
+	* try {
+	*   // Use document
+	* } finally {
+	*   doc.dispose();
+	* }
+	* ```
+	*/
+	dispose() {
+		if (this.tree) {
+			this.tree.delete();
+			this.tree = null;
+		}
+		this.rootNode = null;
+	}
+};
+/**
+* Create a new document state
+*
+* @param wasmPath Path to grammar WASM file (e.g., './generated/grammar.wasm')
+* @param metadata Document metadata
+* @param initialText Initial document text
+* @returns Promise<DocumentState>
+*
+* @example
+* ```typescript
+* const doc = await createDocumentState(
+*   './generated/grammar.wasm',
+*   { uri: 'file:///test.mylang', version: 1, languageId: 'mylang' },
+*   'let x = 42;'
+* );
+*
+* const root = doc.root;
+* console.log(root.type); // 'program'
+*
+* doc.update('let y = 99;');
+* console.log(doc.version); // 2
+*
+* doc.dispose(); // Free WASM memory
+* ```
+*/
+async function createDocumentState(wasmPath, metadata, initialText) {
+	const parser = await createParser(wasmPath);
+	return new DocumentState(parser, metadata, initialText);
+}
+
+//#endregion
+//#region src/runtime/scope/scope.ts
+/**
+* Scope - manages declarations and name resolution
+*
+* Supports three scope kinds:
+* - 'global': Root scope, one per document
+* - 'lexical': Standard block scope, inherits from parent
+* - 'isolated': No access to parent scope (module boundaries)
+*
+* Visibility:
+* - 'public': Visible to parent and cross-file
+* - 'private': Visible only within this scope
+*/
+var Scope = class {
+	/**
+	* Scope kind
+	*/
+	kind;
+	/**
+	* AST node that owns this scope (null for global scope)
+	*/
+	node;
+	/**
+	* Parent scope (null for global scope)
+	*/
+	parent;
+	/**
+	* Declarations in this scope
+	* Maps name → array of declarations (for declaration merging in v2)
+	*/
+	declarations = /* @__PURE__ */ new Map();
+	/**
+	* Child scopes
+	*/
+	children = [];
+	constructor(kind, node, parent) {
+		this.kind = kind;
+		this.node = node;
+		this.parent = parent;
+		if (parent) parent.children.push(this);
+	}
+	/**
+	* Add a declaration to this scope
+	*
+	* V1: Single declarations per name (declaration merging in v2)
+	* If name already exists, adds to array (for future merging support)
+	*/
+	declare(name, node, declaredBy, visibility) {
+		const decl = {
+			node,
+			name,
+			visibility,
+			declaredBy
+		};
+		const existing = this.declarations.get(name);
+		if (existing) existing.push(decl);
+		else this.declarations.set(name, [decl]);
+		return decl;
+	}
+	/**
+	* Look up a name in this scope only (does not search parent)
+	*
+	* @param name Name to look up
+	* @param declaredBy Optional filter by declaration type(s)
+	* @param visibility Optional filter by visibility
+	* @returns First matching declaration or null
+	*/
+	lookupLocal(name, declaredBy, visibility) {
+		const declarations = this.declarations.get(name);
+		if (!declarations) return null;
+		let filtered = declarations;
+		if (declaredBy) {
+			const types = Array.isArray(declaredBy) ? declaredBy : [declaredBy];
+			filtered = declarations.filter((d) => types.includes(d.declaredBy));
+		}
+		if (visibility) filtered = filtered.filter((d) => d.visibility === visibility);
+		return filtered[0] ?? null;
+	}
+	/**
+	* Look up a name in this scope and parent scopes
+	*
+	* Respects scope kinds:
+	* - 'global': No parent to search
+	* - 'lexical': Searches parent recursively
+	* - 'isolated': Does not search parent
+	*
+	* @param name Name to look up
+	* @param declaredBy Optional filter by declaration type(s)
+	* @returns First matching declaration or null
+	*/
+	lookup(name, declaredBy) {
+		const local = this.lookupLocal(name, declaredBy);
+		if (local) return local;
+		if (this.kind === "isolated") return null;
+		if (this.parent) return this.parent.lookup(name, declaredBy);
+		return null;
+	}
+	/**
+	* Get all declarations in this scope
+	*
+	* @param options Filtering options
+	* @returns Array of declarations
+	*/
+	allDeclarations(options) {
+		const all = [];
+		for (const declarations of this.declarations.values()) all.push(...declarations);
+		let filtered = all;
+		if (options?.visibility) filtered = filtered.filter((d) => d.visibility === options.visibility);
+		if (options?.declaredBy) {
+			const types = Array.isArray(options.declaredBy) ? options.declaredBy : [options.declaredBy];
+			filtered = filtered.filter((d) => types.includes(d.declaredBy));
+		}
+		return filtered;
+	}
+	/**
+	* Check if a name is declared in this scope (local only)
+	*/
+	isDeclared(name, declaredBy) {
+		return this.lookupLocal(name, declaredBy) !== null;
+	}
+	/**
+	* Get the global scope (root of scope tree)
+	*/
+	global() {
+		let scope = this;
+		while (scope.parent) scope = scope.parent;
+		return scope;
+	}
+	/**
+	* Get all child scopes
+	*/
+	getChildren() {
+		return [...this.children];
+	}
+	/**
+	* Get all descendant scopes (recursive)
+	*/
+	descendants() {
+		const result = [];
+		for (const child of this.children) {
+			result.push(child);
+			result.push(...child.descendants());
+		}
+		return result;
+	}
+	/**
+	* Debug string representation
+	*/
+	toString() {
+		const nodeType = this.node?.type ?? "document";
+		const declCount = Array.from(this.declarations.values()).flat().length;
+		return `Scope(${this.kind}, ${nodeType}, ${declCount} decls)`;
+	}
+};
+
+//#endregion
+//#region src/runtime/scope/resolver.ts
+/**
+* Build scope tree for a document
+*
+* V1 strategy: Full rebuild on every document change
+* - Walk AST to create scope tree
+* - Register all declarations
+* - Register all references
+* - Resolve references to declarations
+*
+* @param document The document to analyze
+* @param semantic Semantic definition from defineLanguage()
+* @returns DocumentScope with scope tree and resolution data
+*/
+function buildScopes(document, semantic) {
+	const root = document.root;
+	const nodeScopes = /* @__PURE__ */ new Map();
+	const references = [];
+	const declaredNodeIds = /* @__PURE__ */ new Set();
+	const context = {
+		scopeOf: (node) => {
+			let current = node;
+			while (current) {
+				const scope = nodeScopes.get(current.id);
+				if (scope) return scope;
+				current = current.parent;
+			}
+			return null;
+		},
+		resolveModule: () => null,
+		getReferences: () => references,
+		getDeclarations: () => {
+			const all = [];
+			for (const scope of nodeScopes.values()) all.push(...scope.allDeclarations());
+			return all;
+		}
+	};
+	const globalScope = new Scope("global", root, null);
+	nodeScopes.set(root.id, globalScope);
+	walkTree(root, globalScope, semantic, nodeScopes, references, context, declaredNodeIds);
+	for (const ref of references) ref.resolved = resolveReference(ref, context);
+	const declarations = context.getDeclarations();
+	return {
+		root: globalScope,
+		nodeScopes,
+		references,
+		declarations
+	};
+}
+/**
+* Walk AST tree to build scopes and register declarations/references
+*/
+function walkTree(node, currentScope, semantic, nodeScopes, references, context, declaredNodeIds) {
+	const rule = semantic[node.type];
+	let nodeScope = currentScope;
+	if (rule?.scope) {
+		nodeScope = new Scope(rule.scope, node, currentScope);
+		nodeScopes.set(node.id, nodeScope);
+	}
+	if (rule) {
+		processDeclarations(node, rule, nodeScope, semantic, nodeScopes, context, declaredNodeIds);
+		processReferences(node, rule, nodeScope, references, context, declaredNodeIds);
+	}
+	for (const child of node.namedChildren) walkTree(child, nodeScope, semantic, nodeScopes, references, context, declaredNodeIds);
+}
+/**
+* Process declarations for a node
+*/
+function processDeclarations(node, rule, _scope, _semantic, nodeScopes, context, declaredNodeIds) {
+	if (!rule.declares) return;
+	const descriptor = rule.declares;
+	const nameNode = node.field(descriptor.field);
+	if (!nameNode) return;
+	declaredNodeIds.add(nameNode.id);
+	const name = nameNode.text;
+	const visibility = getVisibility(node, descriptor);
+	const targetScope = getTargetScope(node, descriptor.scope, nodeScopes);
+	if (!targetScope) return;
+	const strategy = descriptor.strategy ?? "if-not-declared";
+	if (strategy === "if-not-declared") {
+		if (targetScope.isDeclared(name)) return;
+	}
+	if (descriptor.resolve) {
+		const resolved = descriptor.resolve({
+			node,
+			name,
+			text: name
+		}, context);
+		if (!resolved) return;
+	}
+	targetScope.declare(name, nameNode, node.type, visibility);
+}
+/**
+* Process references for a node
+*/
+function processReferences(node, rule, _scope, references, context, declaredNodeIds) {
+	if (!rule.references) return;
+	const descriptor = rule.references;
+	const nameNode = node.field(descriptor.field) ?? node;
+	if (declaredNodeIds.has(nameNode.id)) return;
+	const name = nameNode.text;
+	const to = Array.isArray(descriptor.to) ? descriptor.to : [descriptor.to];
+	const ref = {
+		node: nameNode,
+		name,
+		to,
+		resolved: null
+	};
+	if (descriptor.resolve) {
+		const resolved = descriptor.resolve({
+			node: nameNode,
+			name,
+			text: name
+		}, context);
+		if (resolved) ref.resolved = resolved;
+	}
+	references.push(ref);
+}
+/**
+* Resolve a reference to its declaration
+*/
+function resolveReference(ref, context) {
+	if (ref.resolved) return ref.resolved;
+	const scope = context.scopeOf(ref.node);
+	if (!scope) return null;
+	const decl = scope.lookup(ref.name, ref.to);
+	return decl;
+}
+/**
+* Get visibility for a declaration
+*/
+function getVisibility(node, descriptor) {
+	if (!descriptor.visibility) return "private";
+	if (typeof descriptor.visibility === "function") return descriptor.visibility(node);
+	return descriptor.visibility;
+}
+/**
+* Get target scope for a declaration
+*/
+function getTargetScope(node, target, nodeScopes) {
+	if (target === "global") {
+		let current = node;
+		while (current) {
+			const scope = nodeScopes.get(current.id);
+			if (scope?.kind === "global") return scope;
+			current = current.parent;
+		}
+		return null;
+	}
+	if (target === "enclosing") {
+		let current = node.parent;
+		while (current) {
+			const scope = nodeScopes.get(current.id);
+			if (scope) return scope;
+			current = current.parent;
+		}
+		return null;
+	}
+	if (target === "local") {
+		let current = node.parent;
+		while (current) {
+			const scope = nodeScopes.get(current.id);
+			if (scope) return scope;
+			current = current.parent;
+		}
+		return null;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/runtime/scope/workspace.ts
+/**
+* Workspace - manages multiple documents and cross-file resolution
+*
+* V1: Basic cross-file index for public declarations
+* - Stores DocumentScope for each file
+* - Provides lookup by URI
+* - Exports public declarations for cross-file resolution
+*
+* V2: Will add module resolution, import tracking, circular dependency detection
+*/
+var Workspace = class {
+	/**
+	* Semantic definition (shared across all documents)
+	*/
+	semantic;
+	/**
+	* Documents indexed by URI
+	*/
+	documents = /* @__PURE__ */ new Map();
+	/**
+	* Index of public declarations by name (for cross-file lookup)
+	* Maps name → array of declarations from all files
+	*/
+	publicDeclarations = /* @__PURE__ */ new Map();
+	constructor(semantic) {
+		this.semantic = semantic;
+	}
+	/**
+	* Add or update a document in the workspace
+	*
+	* @param document The document to add/update
+	* @returns The DocumentScope for this document
+	*/
+	addDocument(document) {
+		const scope = buildScopes(document, this.semantic);
+		this.documents.set(document.uri, {
+			document,
+			scope
+		});
+		this.rebuildPublicIndex();
+		return scope;
+	}
+	/**
+	* Remove a document from the workspace
+	*/
+	removeDocument(uri) {
+		this.documents.delete(uri);
+		this.rebuildPublicIndex();
+	}
+	/**
+	* Get a document by URI
+	*/
+	getDocument(uri) {
+		return this.documents.get(uri) ?? null;
+	}
+	/**
+	* Get all documents in the workspace
+	*/
+	getAllDocuments() {
+		return Array.from(this.documents.values());
+	}
+	/**
+	* Look up a public declaration by name across all files
+	*
+	* @param name The name to look up
+	* @param declaredBy Optional filter by declaration type(s)
+	* @returns Array of matching declarations from all files
+	*/
+	lookupPublic(name, declaredBy) {
+		const declarations = this.publicDeclarations.get(name);
+		if (!declarations) return [];
+		if (declaredBy) {
+			const types = Array.isArray(declaredBy) ? declaredBy : [declaredBy];
+			return declarations.filter((d) => types.includes(d.declaredBy));
+		}
+		return declarations;
+	}
+	/**
+	* Get all public declarations in the workspace
+	*/
+	getAllPublicDeclarations() {
+		const all = [];
+		for (const declarations of this.publicDeclarations.values()) all.push(...declarations);
+		return all;
+	}
+	/**
+	* Rebuild the public declarations index
+	* Called after any document is added/removed/updated
+	*/
+	rebuildPublicIndex() {
+		this.publicDeclarations.clear();
+		for (const { scope } of this.documents.values()) {
+			const publicDecls = scope.root.allDeclarations({ visibility: "public" });
+			for (const decl of publicDecls) {
+				const existing = this.publicDeclarations.get(decl.name);
+				if (existing) existing.push(decl);
+				else this.publicDeclarations.set(decl.name, [decl]);
+			}
+		}
+	}
+	/**
+	* Find circular imports (placeholder for v2)
+	*
+	* V1: Not implemented
+	* V2: Will track import graph and detect cycles
+	*
+	* @returns Array of circular import chains
+	*/
+	findCircularImports() {
+		return [];
+	}
+	/**
+	* Get workspace statistics (for debugging)
+	*/
+	getStats() {
+		let totalDecls = 0;
+		let totalRefs = 0;
+		for (const { scope } of this.documents.values()) {
+			totalDecls += scope.declarations.length;
+			totalRefs += scope.references.length;
+		}
+		return {
+			documentCount: this.documents.size,
+			publicDeclarationCount: this.getAllPublicDeclarations().length,
+			totalDeclarationCount: totalDecls,
+			totalReferenceCount: totalRefs
+		};
+	}
+	/**
+	* Clear all documents from the workspace
+	*/
+	clear() {
+		this.documents.clear();
+		this.publicDeclarations.clear();
+	}
+};
+
+//#endregion
+//#region src/runtime/lsp/documents.ts
+/**
+* Document manager for LSP
+*
+* Manages the lifecycle of open documents:
+* - Tracks open/change/close events
+* - Rebuilds scopes on document changes
+* - Maintains workspace index
+*/
+var DocumentManager = class {
+	workspace;
+	constructor(semantic) {
+		this.workspace = new Workspace(semantic);
+	}
+	/**
+	* Open or update a document
+	*
+	* @param document The document state (already parsed)
+	* @returns The computed scope for this document
+	*/
+	open(document) {
+		return this.workspace.addDocument(document);
+	}
+	/**
+	* Handle a document change
+	* The caller should have already called document.update() with new text
+	*
+	* @param document The updated document state
+	* @returns The recomputed scope
+	*/
+	change(document) {
+		return this.workspace.addDocument(document);
+	}
+	/**
+	* Close a document
+	*/
+	close(uri) {
+		this.workspace.removeDocument(uri);
+	}
+	/**
+	* Get document by URI
+	*/
+	get(uri) {
+		return this.workspace.getDocument(uri);
+	}
+	/**
+	* Get the workspace instance
+	*/
+	getWorkspace() {
+		return this.workspace;
+	}
+	/**
+	* Get all open documents
+	*/
+	getAllDocuments() {
+		return this.workspace.getAllDocuments();
+	}
+	/**
+	* Clear all documents
+	*/
+	clear() {
+		this.workspace.clear();
+	}
+};
+
+//#endregion
+//#region src/runtime/lsp/context.ts
+/**
+* Create LspContext for handler use
+*/
+function createLspContext(docScope, workspace, document, _semantic) {
+	return {
+		resolve(node) {
+			const ref = findReferenceForNode(node, docScope);
+			return ref?.resolved?.node ?? null;
+		},
+		typeOf(_node) {
+			return null;
+		},
+		scopeOf(node) {
+			return findScopeForNode(node, docScope);
+		},
+		document,
+		workspace
+	};
+}
+/**
+* Find the smallest named node at a position
+*
+* When the cursor is at the exclusive end of a token (e.g., right edge of an
+* identifier), tree-sitter returns the parent node because that position falls
+* in whitespace. In that case, look one character back to find the token the
+* user likely intended.
+*
+* Similarly, when the cursor lands on an anonymous node (punctuation like ";",
+* "+", "="), look one character back to find the named token the user likely
+* intended. This handles the common case of clicking at the boundary between
+* an identifier and adjacent punctuation.
+*/
+function findNodeAtPosition(root, position) {
+	const node = root.descendantForPosition(position);
+	if (position.character > 0 && (node.namedChildCount > 0 || !node.isNamed)) {
+		const prev = root.descendantForPosition({
+			line: position.line,
+			character: position.character - 1
+		});
+		if (prev.namedChildCount === 0 && prev.isNamed) return prev;
+	}
+	return node;
+}
+/**
+* Find the reference entry for a node (by position match)
+*/
+function findReferenceForNode(node, docScope) {
+	const startLine = node.startPosition.line;
+	const startChar = node.startPosition.character;
+	const endLine = node.endPosition.line;
+	const endChar = node.endPosition.character;
+	for (const ref of docScope.references) {
+		const refStart = ref.node.startPosition;
+		const refEnd = ref.node.endPosition;
+		if (refStart.line === startLine && refStart.character === startChar && refEnd.line === endLine && refEnd.character === endChar) return ref;
+	}
+	return null;
+}
+/**
+* Find the declaration entry for a node (by position match)
+*/
+function findDeclarationForNode(node, docScope) {
+	const startLine = node.startPosition.line;
+	const startChar = node.startPosition.character;
+	for (const decl of docScope.declarations) {
+		const declStart = decl.node.startPosition;
+		if (declStart.line === startLine && declStart.character === startChar) return decl;
+	}
+	return null;
+}
+/**
+* Find the scope that contains a node
+* Walks up the parent chain checking nodeScopes map
+*/
+function findScopeForNode(node, docScope) {
+	let current = node;
+	while (current) {
+		const scope = docScope.nodeScopes.get(current.id);
+		if (scope) return scope;
+		current = current.parent;
+	}
+	return docScope.root;
+}
+/**
+* Convert an ASTNode to an LSP-style range
+*/
+function nodeToRange(node) {
+	return {
+		start: node.startPosition,
+		end: node.endPosition
+	};
+}
+
+//#endregion
+//#region src/runtime/lsp/diagnostics.ts
+/**
+* Compute all diagnostics for a document
+*/
+function computeDiagnostics(document, docScope, semantic, lsp, validation, workspace) {
+	const diagnostics = [];
+	collectParseErrors(document.root, diagnostics);
+	collectUnresolvedReferences(docScope, semantic, lsp, diagnostics);
+	if (validation) collectValidationDiagnostics(document, docScope, semantic, validation, workspace, diagnostics);
+	return diagnostics;
+}
+/**
+* Walk AST to find ERROR and MISSING nodes
+*/
+function collectParseErrors(node, diagnostics) {
+	if (node.isMissing) {
+		diagnostics.push({
+			range: {
+				start: node.startPosition,
+				end: node.endPosition
+			},
+			severity: "error",
+			message: `Missing ${node.type}`,
+			code: "missing-node",
+			source: "treelsp"
+		});
+		return;
+	}
+	if (node.isError) {
+		const hasErrorChild = node.children.some((c) => c.isError || c.isMissing);
+		if (!hasErrorChild) diagnostics.push({
+			range: {
+				start: node.startPosition,
+				end: node.endPosition
+			},
+			severity: "error",
+			message: "Syntax error",
+			code: "syntax-error",
+			source: "treelsp"
+		});
+	}
+	for (const child of node.children) collectParseErrors(child, diagnostics);
+}
+/**
+* Report unresolved references based on semantic onUnresolved policy
+*/
+function collectUnresolvedReferences(docScope, semantic, lsp, diagnostics) {
+	for (const ref of docScope.references) {
+		if (ref.resolved) continue;
+		const refNode = ref.node;
+		let parentNode = refNode.parent;
+		let policy = "error";
+		let optional = false;
+		while (parentNode) {
+			const rule = semantic[parentNode.type];
+			if (rule?.references) {
+				policy = rule.references.onUnresolved ?? "error";
+				optional = rule.references.optional ?? false;
+				break;
+			}
+			parentNode = parentNode.parent;
+		}
+		if (optional || policy === "ignore") continue;
+		const severity = policy === "warning" ? "warning" : "error";
+		let message = `Cannot find name '${ref.name}'`;
+		if (lsp?.$unresolved) {
+			const ctx = {
+				resolve: () => null,
+				typeOf: () => null,
+				scopeOf: () => docScope.root,
+				document: null,
+				workspace: null
+			};
+			const custom = lsp.$unresolved(refNode, ctx);
+			if (custom) message = custom;
+		}
+		diagnostics.push({
+			range: {
+				start: refNode.startPosition,
+				end: refNode.endPosition
+			},
+			severity,
+			message,
+			code: "unresolved-reference",
+			source: "treelsp"
+		});
+	}
+}
+/**
+* Run custom validators and collect their diagnostics
+*/
+function collectValidationDiagnostics(document, docScope, semantic, validation, workspace, diagnostics) {
+	const lspContext = createLspContext(docScope, workspace ?? {}, document, semantic);
+	function createValidationContext(node) {
+		return {
+			error(target, message, options) {
+				addValidationDiagnostic("error", target, message, options, diagnostics);
+			},
+			warning(target, message, options) {
+				addValidationDiagnostic("warning", target, message, options, diagnostics);
+			},
+			info(target, message, options) {
+				addValidationDiagnostic("info", target, message, options, diagnostics);
+			},
+			hint(target, message, options) {
+				addValidationDiagnostic("hint", target, message, options, diagnostics);
+			},
+			resolve: (n) => lspContext.resolve(n),
+			scopeOf: (n) => lspContext.scopeOf(n),
+			declarationsOf(_target) {
+				const scope = lspContext.scopeOf(node);
+				return scope.allDeclarations();
+			},
+			referencesTo(_target) {
+				return docScope.references.filter((r) => r.resolved?.node === _target);
+			},
+			document,
+			workspace: workspace ?? null
+		};
+	}
+	walkForValidation(document.root, validation, createValidationContext);
+}
+/**
+* Walk AST and run matching validators
+*/
+function walkForValidation(node, validation, createCtx) {
+	const validators = validation[node.type];
+	if (validators) {
+		const ctx = createCtx(node);
+		const fns = Array.isArray(validators) ? validators : [validators];
+		for (const fn of fns) fn(node, ctx);
+	}
+	for (const child of node.namedChildren) walkForValidation(child, validation, createCtx);
+}
+/**
+* Add a validation diagnostic to the collection
+*/
+function addValidationDiagnostic(severity, node, message, options, diagnostics) {
+	const target = options?.at ?? node;
+	const diag = {
+		range: {
+			start: target.startPosition,
+			end: target.endPosition
+		},
+		severity,
+		message,
+		source: "treelsp"
+	};
+	if (options?.code) diag.code = options.code;
+	diagnostics.push(diag);
+}
+
+//#endregion
+//#region src/runtime/lsp/hover.ts
+/**
+* Provide hover information at position
+*
+* Strategy:
+* 1. Find node at position
+* 2. If node is a reference → resolve to declaration → use declaration's hover
+* 3. If node is a declaration → use its hover directly
+* 4. Fall back to default hover (type + name)
+*/
+function provideHover(document, position, docScope, semantic, lsp, workspace) {
+	const node = findNodeAtPosition(document.root, position);
+	if (node.type === document.root.type) return null;
+	const ctx = createLspContext(docScope, workspace ?? {}, document, semantic);
+	const ref = findReferenceForNode(node, docScope);
+	if (ref) {
+		if (!ref.resolved) return null;
+		const declNode = ref.resolved.node;
+		const declParent = declNode.parent;
+		const declType = ref.resolved.declaredBy;
+		const hoverHandler = lsp?.[declType]?.hover;
+		if (hoverHandler && declParent) {
+			const contents = hoverHandler(declParent, ctx);
+			if (contents) return {
+				contents,
+				range: {
+					start: node.startPosition,
+					end: node.endPosition
+				}
+			};
+		}
+		return {
+			contents: `**${declType}** \`${ref.resolved.name}\``,
+			range: {
+				start: node.startPosition,
+				end: node.endPosition
+			}
+		};
+	}
+	const decl = findDeclarationForNode(node, docScope);
+	if (decl) {
+		const declParent = node.parent;
+		const hoverHandler = lsp?.[decl.declaredBy]?.hover;
+		if (hoverHandler && declParent) {
+			const contents = hoverHandler(declParent, ctx);
+			if (contents) return {
+				contents,
+				range: {
+					start: node.startPosition,
+					end: node.endPosition
+				}
+			};
+		}
+		return {
+			contents: `**${decl.declaredBy}** \`${decl.name}\``,
+			range: {
+				start: node.startPosition,
+				end: node.endPosition
+			}
+		};
+	}
+	return null;
+}
+
+//#endregion
+//#region src/runtime/lsp/definition.ts
+/**
+* Provide definition location for a reference
+*
+* Fully automatic: find reference at position → return declaration location
+*/
+function provideDefinition(document, position, docScope) {
+	const node = findNodeAtPosition(document.root, position);
+	const ref = findReferenceForNode(node, docScope);
+	if (!ref?.resolved) return null;
+	return {
+		uri: document.uri,
+		range: nodeToRange(ref.resolved.node)
+	};
+}
+
+//#endregion
+//#region src/runtime/lsp/references.ts
+/**
+* Find all references to the symbol at position
+*
+* Strategy:
+* 1. Find node at position
+* 2. If reference → resolve to declaration
+* 3. If declaration → use directly
+* 4. Scan all documents in workspace for references to that declaration
+*/
+function provideReferences(document, position, docScope, workspace) {
+	const node = findNodeAtPosition(document.root, position);
+	let targetDecl = null;
+	const ref = findReferenceForNode(node, docScope);
+	if (ref?.resolved) targetDecl = ref.resolved;
+	if (!targetDecl) targetDecl = findDeclarationForNode(node, docScope);
+	if (!targetDecl) return [];
+	const locations = [];
+	if (workspace) for (const wsDoc of workspace.getAllDocuments()) collectReferencesInDocument(wsDoc.document.uri, wsDoc.scope, targetDecl, locations);
+	else collectReferencesInDocument(document.uri, docScope, targetDecl, locations);
+	return locations;
+}
+/**
+* Collect all references to a declaration within a single document
+*/
+function collectReferencesInDocument(uri, docScope, targetDecl, locations) {
+	for (const ref of docScope.references) {
+		if (!ref.resolved) continue;
+		if (ref.resolved.name === targetDecl.name && ref.resolved.declaredBy === targetDecl.declaredBy) locations.push({
+			uri,
+			range: nodeToRange(ref.node)
+		});
+	}
+}
+
+//#endregion
+//#region src/runtime/lsp/completion.ts
+/**
+* LSP CompletionItemKind mapping
+*/
+const COMPLETION_KIND_MAP = {
+	Text: 1,
+	Method: 2,
+	Function: 3,
+	Constructor: 4,
+	Field: 5,
+	Variable: 6,
+	Class: 7,
+	Interface: 8,
+	Module: 9,
+	Property: 10,
+	Enum: 13,
+	Keyword: 14,
+	Snippet: 15,
+	Constant: 21
+};
+/**
+* Provide completions at position
+*
+* Sources:
+* 1. Scope-based: all declarations visible from current scope
+* 2. Keywords: from $keywords config
+* 3. Custom: from per-rule complete() handlers
+*/
+function provideCompletion(document, position, docScope, semantic, lsp, workspace) {
+	const node = findNodeAtPosition(document.root, position);
+	const ctx = createLspContext(docScope, workspace ?? {}, document, semantic);
+	const scopeItems = getScopeCompletions(node, docScope, lsp);
+	const keywordItems = getKeywordCompletions(lsp);
+	const customResult = getCustomCompletions(node, ctx, lsp);
+	if (customResult?.replace) return customResult.items;
+	const allItems = [...scopeItems, ...keywordItems];
+	if (customResult) allItems.push(...customResult.items);
+	return deduplicateCompletions(allItems);
+}
+/**
+* Get completions from all declarations visible in scope
+*/
+function getScopeCompletions(node, docScope, lsp) {
+	const scope = findScopeForNode(node, docScope);
+	const items = [];
+	const seen = /* @__PURE__ */ new Set();
+	let currentScope = scope;
+	while (currentScope) {
+		for (const decl of currentScope.allDeclarations()) {
+			if (seen.has(decl.name)) continue;
+			seen.add(decl.name);
+			const lspRule = lsp?.[decl.declaredBy];
+			const kind = lspRule?.completionKind;
+			const item = {
+				label: decl.name,
+				detail: decl.declaredBy
+			};
+			if (kind) item.kind = kind;
+			items.push(item);
+		}
+		if (currentScope.kind === "isolated") break;
+		currentScope = currentScope.parent;
+	}
+	return items;
+}
+/**
+* Get keyword completions from $keywords config
+*/
+function getKeywordCompletions(lsp) {
+	const keywords = lsp?.$keywords;
+	if (!keywords) return [];
+	return Object.entries(keywords).map(([keyword, descriptor]) => {
+		const item = {
+			label: keyword,
+			kind: "Keyword"
+		};
+		if (descriptor.detail) item.detail = descriptor.detail;
+		if (descriptor.documentation) item.documentation = descriptor.documentation;
+		return item;
+	});
+}
+/**
+* Get custom completions from per-rule complete() handler
+*/
+function getCustomCompletions(node, ctx, lsp) {
+	if (!lsp) return null;
+	let current = node;
+	while (current) {
+		const handler = lsp[current.type]?.complete;
+		if (handler) {
+			const result = handler(current, ctx);
+			if (Array.isArray(result)) return { items: result };
+			return result;
+		}
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Remove duplicate completion items (by label)
+*/
+function deduplicateCompletions(items) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const item of items) if (!seen.has(item.label)) {
+		seen.add(item.label);
+		result.push(item);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/runtime/lsp/rename.ts
+/**
+* Check if rename is possible at position and return the symbol range
+*
+* Returns the range of the symbol and its current name as placeholder,
+* or null if the position is not on a renameable symbol.
+*/
+function prepareRename(document, position, docScope) {
+	const node = findNodeAtPosition(document.root, position);
+	const ref = findReferenceForNode(node, docScope);
+	if (ref?.resolved) return {
+		range: nodeToRange(node),
+		placeholder: ref.name
+	};
+	const decl = findDeclarationForNode(node, docScope);
+	if (decl) return {
+		range: nodeToRange(node),
+		placeholder: decl.name
+	};
+	return null;
+}
+/**
+* Provide rename edits for symbol at position
+*
+* Strategy:
+* 1. Find declaration (directly or via reference resolution)
+* 2. Find all references across workspace
+* 3. Return edits for declaration + all references
+*/
+function provideRename(document, position, newName, docScope, workspace) {
+	const node = findNodeAtPosition(document.root, position);
+	let targetDecl = null;
+	const ref = findReferenceForNode(node, docScope);
+	if (ref?.resolved) targetDecl = ref.resolved;
+	if (!targetDecl) targetDecl = findDeclarationForNode(node, docScope);
+	if (!targetDecl) return null;
+	const changes = {};
+	function addEdit(uri, targetNode) {
+		const edits = changes[uri] ?? (changes[uri] = []);
+		edits.push({
+			range: nodeToRange(targetNode),
+			newText: newName
+		});
+	}
+	if (workspace) for (const wsDoc of workspace.getAllDocuments()) {
+		const uri = wsDoc.document.uri;
+		for (const decl of wsDoc.scope.declarations) if (decl.name === targetDecl.name && decl.declaredBy === targetDecl.declaredBy) addEdit(uri, decl.node);
+		for (const r of wsDoc.scope.references) if (r.resolved && r.resolved.name === targetDecl.name && r.resolved.declaredBy === targetDecl.declaredBy) addEdit(uri, r.node);
+	}
+	else {
+		addEdit(document.uri, targetDecl.node);
+		for (const r of docScope.references) if (r.resolved && r.resolved.name === targetDecl.name && r.resolved.declaredBy === targetDecl.declaredBy) addEdit(document.uri, r.node);
+	}
+	return { changes };
+}
+
+//#endregion
+//#region src/runtime/lsp/symbols.ts
+/**
+* LSP SymbolKind mapping
+*/
+const SYMBOL_KIND_MAP = {
+	File: 1,
+	Module: 2,
+	Namespace: 3,
+	Package: 4,
+	Class: 5,
+	Method: 6,
+	Property: 7,
+	Field: 8,
+	Constructor: 9,
+	Enum: 10,
+	Interface: 11,
+	Function: 12,
+	Variable: 13,
+	Constant: 14,
+	String: 15,
+	Number: 16,
+	Boolean: 17,
+	Array: 18
+};
+/**
+* Provide document symbols
+*
+* Walks all declarations and builds symbol entries for those
+* with a symbol descriptor defined in the LSP config
+*/
+function provideSymbols(docScope, lsp) {
+	if (!lsp) return [];
+	const symbols = [];
+	for (const decl of docScope.declarations) {
+		const lspRule = lsp[decl.declaredBy];
+		if (!lspRule?.symbol) continue;
+		const descriptor = lspRule.symbol;
+		const declParent = decl.node.parent;
+		let name;
+		if (typeof descriptor.label === "function") name = declParent ? descriptor.label(declParent) : decl.name;
+		else name = descriptor.label;
+		let detail;
+		if (typeof descriptor.detail === "function") detail = declParent ? descriptor.detail(declParent) : void 0;
+		else detail = descriptor.detail;
+		const rangeNode = declParent ?? decl.node;
+		const sym = {
+			name,
+			kind: descriptor.kind,
+			kindNumber: SYMBOL_KIND_MAP[descriptor.kind] ?? 13,
+			range: {
+				start: rangeNode.startPosition,
+				end: rangeNode.endPosition
+			},
+			selectionRange: {
+				start: decl.node.startPosition,
+				end: decl.node.endPosition
+			}
+		};
+		if (detail) sym.detail = detail;
+		symbols.push(sym);
+	}
+	return symbols;
+}
+
+//#endregion
+//#region src/runtime/lsp/semantic-tokens.ts
+/**
+* Standard LSP semantic token types
+* Index in this array = tokenType value in the encoded data
+*/
+const SEMANTIC_TOKEN_TYPES = [
+	"namespace",
+	"type",
+	"class",
+	"enum",
+	"interface",
+	"struct",
+	"typeParameter",
+	"parameter",
+	"variable",
+	"property",
+	"enumMember",
+	"event",
+	"function",
+	"method",
+	"macro",
+	"keyword",
+	"modifier",
+	"comment",
+	"string",
+	"number",
+	"regexp",
+	"operator",
+	"decorator"
+];
+/**
+* Standard LSP semantic token modifiers
+* Encoded as bit flags: modifier at index N has value 2^N
+*/
+const SEMANTIC_TOKEN_MODIFIERS = [
+	"declaration",
+	"definition",
+	"readonly",
+	"static",
+	"deprecated",
+	"abstract",
+	"async",
+	"modification",
+	"documentation",
+	"defaultLibrary"
+];
+/** Index lookup for token types */
+const TOKEN_TYPE_INDEX = {};
+for (let i = 0; i < SEMANTIC_TOKEN_TYPES.length; i++) TOKEN_TYPE_INDEX[SEMANTIC_TOKEN_TYPES[i]] = i;
+/** Mapping from CompletionKind to semantic token type name */
+const COMPLETION_KIND_TO_TOKEN_TYPE = {
+	Variable: "variable",
+	Function: "function",
+	Method: "method",
+	Class: "class",
+	Interface: "interface",
+	Module: "namespace",
+	Enum: "enum",
+	Constant: "variable",
+	Property: "property",
+	Field: "property",
+	Constructor: "function"
+};
+const BRACKETS = new Set([
+	"(",
+	")",
+	"{",
+	"}",
+	"[",
+	"]"
+]);
+const DELIMITERS = new Set([
+	";",
+	",",
+	".",
+	":"
+]);
+/**
+* Classify a named token rule by its name (heuristic)
+*/
+function classifyTokenRuleName(ruleName) {
+	const lower = ruleName.toLowerCase();
+	if (lower.includes("comment")) return "comment";
+	if (lower.includes("string")) return "string";
+	if (lower.includes("number") || lower.includes("integer") || lower.includes("float")) return "number";
+	if (lower.includes("bool")) return "boolean";
+	return null;
+}
+/**
+* Compute semantic tokens for a full document
+*
+* Walks the AST and classifies each leaf node into an LSP semantic token type.
+* Uses the semantic and LSP definitions to determine token types for
+* declarations and references. Falls back to heuristics for other tokens.
+*/
+function provideSemanticTokensFull(document, docScope, semantic, lsp) {
+	const tokens = [];
+	const declNodeTokenType = /* @__PURE__ */ new Map();
+	const refNodeTokenType = /* @__PURE__ */ new Map();
+	for (const decl of docScope.declarations) {
+		const lspRule = lsp?.[decl.declaredBy];
+		const kind = lspRule?.completionKind;
+		const typeName = kind ? COMPLETION_KIND_TO_TOKEN_TYPE[kind] ?? "variable" : "variable";
+		const typeIndex = TOKEN_TYPE_INDEX[typeName] ?? TOKEN_TYPE_INDEX["variable"];
+		declNodeTokenType.set(decl.node.id, typeIndex);
+	}
+	for (const ref of docScope.references) if (ref.resolved) {
+		const lspRule = lsp?.[ref.resolved.declaredBy];
+		const kind = lspRule?.completionKind;
+		const typeName = kind ? COMPLETION_KIND_TO_TOKEN_TYPE[kind] ?? "variable" : "variable";
+		const typeIndex = TOKEN_TYPE_INDEX[typeName] ?? TOKEN_TYPE_INDEX["variable"];
+		refNodeTokenType.set(ref.node.id, typeIndex);
+	}
+	walkForTokens(document.root, tokens, declNodeTokenType, refNodeTokenType, semantic);
+	tokens.sort((a, b) => a.line - b.line || a.character - b.character);
+	const data = [];
+	let prevLine = 0;
+	let prevChar = 0;
+	for (const token of tokens) {
+		const deltaLine = token.line - prevLine;
+		const deltaChar = deltaLine === 0 ? token.character - prevChar : token.character;
+		data.push(deltaLine, deltaChar, token.length, token.tokenType, token.modifiers);
+		prevLine = token.line;
+		prevChar = token.character;
+	}
+	return { data };
+}
+/**
+* Walk the AST to collect semantic tokens
+*/
+function walkForTokens(node, tokens, declNodeTokenType, refNodeTokenType, semantic) {
+	if (node.childCount === 0) {
+		const token = classifyLeaf(node, declNodeTokenType, refNodeTokenType, semantic);
+		if (token) tokens.push(token);
+		return;
+	}
+	for (const child of node.children) walkForTokens(child, tokens, declNodeTokenType, refNodeTokenType, semantic);
+}
+/**
+* Classify a leaf node into a semantic token
+*/
+function classifyLeaf(node, declNodeTokenType, refNodeTokenType, semantic) {
+	const start = node.startPosition;
+	const length = node.endIndex - node.startIndex;
+	if (length <= 0) return null;
+	const declType = declNodeTokenType.get(node.id);
+	if (declType !== void 0) return {
+		line: start.line,
+		character: start.character,
+		length,
+		tokenType: declType,
+		modifiers: 1
+	};
+	const refType = refNodeTokenType.get(node.id);
+	if (refType !== void 0) return {
+		line: start.line,
+		character: start.character,
+		length,
+		tokenType: refType,
+		modifiers: 0
+	};
+	if (!node.isNamed) {
+		const text = node.text;
+		if (/^[a-zA-Z_]+$/.test(text)) return {
+			line: start.line,
+			character: start.character,
+			length,
+			tokenType: TOKEN_TYPE_INDEX["keyword"],
+			modifiers: 0
+		};
+		if (BRACKETS.has(text) || DELIMITERS.has(text)) return null;
+		return {
+			line: start.line,
+			character: start.character,
+			length,
+			tokenType: TOKEN_TYPE_INDEX["operator"],
+			modifiers: 0
+		};
+	}
+	const tokenClass = classifyTokenRuleName(node.type);
+	if (tokenClass) {
+		const typeIndex = TOKEN_TYPE_INDEX[tokenClass];
+		if (typeIndex !== void 0) return {
+			line: start.line,
+			character: start.character,
+			length,
+			tokenType: typeIndex,
+			modifiers: 0
+		};
+	}
+	const semRule = semantic[node.type];
+	if (semRule?.references) return {
+		line: start.line,
+		character: start.character,
+		length,
+		tokenType: TOKEN_TYPE_INDEX["variable"],
+		modifiers: 0
+	};
+	return null;
+}
+
+//#endregion
+//#region src/runtime/lsp/server.ts
+/**
+* Create language service from language definition
+*
+* @param definition The language definition from defineLanguage()
+* @returns LanguageService with all LSP handler methods
+*/
+function createServer(definition) {
+	const semantic = definition.semantic ?? {};
+	const lsp = definition.lsp;
+	const validation = definition.validation;
+	const documents = new DocumentManager(semantic);
+	function getDocScope(document) {
+		const wsDoc = documents.get(document.uri);
+		if (wsDoc) {
+			if (wsDoc.document !== document) return documents.change(document);
+			return wsDoc.scope;
+		}
+		return documents.open(document);
+	}
+	return {
+		documents,
+		computeDiagnostics(document) {
+			const docScope = getDocScope(document);
+			return computeDiagnostics(document, docScope, semantic, lsp, validation, documents.getWorkspace());
+		},
+		provideHover(document, position) {
+			const docScope = getDocScope(document);
+			return provideHover(document, position, docScope, semantic, lsp, documents.getWorkspace());
+		},
+		provideDefinition(document, position) {
+			const docScope = getDocScope(document);
+			return provideDefinition(document, position, docScope);
+		},
+		provideReferences(document, position) {
+			const docScope = getDocScope(document);
+			return provideReferences(document, position, docScope, documents.getWorkspace());
+		},
+		provideCompletion(document, position) {
+			const docScope = getDocScope(document);
+			return provideCompletion(document, position, docScope, semantic, lsp, documents.getWorkspace());
+		},
+		prepareRename(document, position) {
+			const docScope = getDocScope(document);
+			return prepareRename(document, position, docScope);
+		},
+		provideRename(document, position, newName) {
+			const docScope = getDocScope(document);
+			return provideRename(document, position, newName, docScope, documents.getWorkspace());
+		},
+		provideSymbols(document) {
+			const docScope = getDocScope(document);
+			return provideSymbols(docScope, lsp);
+		},
+		provideSemanticTokensFull(document) {
+			const docScope = getDocScope(document);
+			return provideSemanticTokensFull(document, docScope, semantic, lsp);
+		}
+	};
+}
+
+//#endregion
+export { COMPLETION_KIND_MAP, DocumentManager, DocumentState, SEMANTIC_TOKEN_MODIFIERS, SEMANTIC_TOKEN_TYPES, Scope, Workspace, buildScopes, createDocumentState, createParser, createServer, loadLanguage, preloadParser };