@askdkc/dsh-lsp-server 0.1.12 → 0.1.14

package/lib/code-intelligence-DvhxPnpu.js

@@ -0,0 +1,890 @@
+import { WebstackLspError } from "./errors-DtyWAUi0.js";
+import { isAbsolute } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { Worker } from "node:worker_threads";
+
+//#region src/structure/snapshots.ts
+const SNAPSHOT_TTL_MS = 5 * 6e4;
+const SNAPSHOT_MAX_DOCUMENTS = 32;
+const SNAPSHOT_MAX_BYTES = 32 * 1024 * 1024;
+const STRUCTURE_MAX_DOCUMENT_BYTES = 2 * 1024 * 1024;
+const EXTENSION_LANGUAGE = {
+	".js": "javascript",
+	".jsx": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".ts": "typescript",
+	".mts": "typescript",
+	".cts": "typescript",
+	".tsx": "tsx"
+};
+var DocumentSnapshotStore = class {
+	records = /* @__PURE__ */ new Map();
+	versions = /* @__PURE__ */ new Map();
+	constructor(readSource, maxDocumentBytes) {
+		this.readSource = readSource;
+		this.maxDocumentBytes = maxDocumentBytes;
+	}
+	async open(scope, filePath, signal) {
+		validateScope(scope);
+		const normalizedPath = normalizeRelativePath(filePath);
+		signal?.throwIfAborted();
+		const first = await this.readSource(scope.workspaceRoot, normalizedPath, Math.min(this.maxDocumentBytes, STRUCTURE_MAX_DOCUMENT_BYTES), signal);
+		signal?.throwIfAborted();
+		const second = await this.readSource(scope.workspaceRoot, normalizedPath, Math.min(this.maxDocumentBytes, STRUCTURE_MAX_DOCUMENT_BYTES), signal);
+		if (hashText(first.text) !== hashText(second.text) || first.uri !== second.uri || first.key !== second.key) throw new WebstackLspError("LSP_STALE_SNAPSHOT", "document changed while opening the snapshot");
+		const ownerKey = scopeKey(scope);
+		const hash = hashText(second.text);
+		const fileKey = JSON.stringify([
+			ownerKey,
+			second.key,
+			second.uri
+		]);
+		const version = this.rememberVersion(fileKey, scope, hash);
+		const sourceBytes = Buffer.byteLength(second.text, "utf8");
+		this.evictExpired();
+		if (this.records.size >= SNAPSHOT_MAX_DOCUMENTS || this.totalBytes() + sourceBytes > SNAPSHOT_MAX_BYTES) throw new WebstackLspError("LSP_SNAPSHOT_LIMIT", "snapshot capacity is full; release an existing snapshot and retry");
+		const descriptor = {
+			handle: randomUUID(),
+			version,
+			filePath: normalizedPath,
+			language: languageForPath(normalizedPath),
+			sourceKind: "disk",
+			contentHash: hash,
+			sourceBytes
+		};
+		const previous = [...this.records.values()].filter((item) => item.scopeKey === ownerKey && item.source.key === second.key && item.source.uri === second.uri).sort((a, b) => b.openedAt - a.openedAt)[0];
+		const record = {
+			descriptor,
+			scopeKey: ownerKey,
+			source: second,
+			openedAt: Date.now(),
+			lastUsedAt: Date.now(),
+			...previous ? { previousSnapshotHandle: previous.descriptor.handle } : {}
+		};
+		this.records.set(descriptor.handle, record);
+		return record;
+	}
+	async current(scope, handle, signal) {
+		validateScope(scope);
+		signal?.throwIfAborted();
+		const record = this.records.get(handle);
+		if (!record || record.scopeKey !== scopeKey(scope)) throw staleSnapshot();
+		if (Date.now() - record.openedAt > SNAPSHOT_TTL_MS) {
+			this.records.delete(handle);
+			throw staleSnapshot();
+		}
+		const current = await this.readSource(scope.workspaceRoot, record.descriptor.filePath, Math.min(this.maxDocumentBytes, STRUCTURE_MAX_DOCUMENT_BYTES), signal);
+		signal?.throwIfAborted();
+		if (current.uri !== record.source.uri || current.key !== record.source.key || hashText(current.text) !== record.descriptor.contentHash) {
+			this.records.delete(handle);
+			throw staleSnapshot();
+		}
+		record.lastUsedAt = Date.now();
+		return record;
+	}
+	async readFresh(scope, filePath, signal) {
+		validateScope(scope);
+		signal?.throwIfAborted();
+		const source = await this.readSource(scope.workspaceRoot, filePath, this.maxDocumentBytes, signal);
+		signal?.throwIfAborted();
+		const fileKey = JSON.stringify([
+			scopeKey(scope),
+			source.key,
+			source.uri
+		]);
+		this.rememberVersion(fileKey, scope, hashText(source.text));
+		return source;
+	}
+	release(scope, handle) {
+		validateScope(scope);
+		const record = this.records.get(handle);
+		if (!record || record.scopeKey !== scopeKey(scope)) return false;
+		return this.records.delete(handle);
+	}
+	releaseOwner(scope) {
+		validateScope(scope);
+		const owner = scopeKey(scope);
+		let released = 0;
+		for (const [handle, record] of this.records) if (record.scopeKey === owner) {
+			this.records.delete(handle);
+			released++;
+		}
+		for (const [key, version] of this.versions) if (version.scopeKey === owner) this.versions.delete(key);
+		return released;
+	}
+	clear() {
+		this.records.clear();
+		this.versions.clear();
+	}
+	get size() {
+		return this.records.size;
+	}
+	get documentByteLimit() {
+		return this.maxDocumentBytes;
+	}
+	totalBytes() {
+		let bytes = 0;
+		for (const record of this.records.values()) bytes += record.descriptor.sourceBytes;
+		return bytes;
+	}
+	rememberVersion(fileKey, scope, hash) {
+		const owner = scopeKey(scope), previous = this.versions.get(fileKey);
+		const version = previous ? previous.hash === hash ? previous.version : previous.version + 1 : 1;
+		this.versions.delete(fileKey);
+		this.versions.set(fileKey, {
+			hash,
+			version,
+			scopeKey: owner
+		});
+		while (this.versions.size > 4096) this.versions.delete(this.versions.keys().next().value);
+		return version;
+	}
+	evictExpired() {
+		const now = Date.now();
+		for (const [handle, record] of this.records) if (now - record.openedAt > SNAPSHOT_TTL_MS) this.records.delete(handle);
+	}
+};
+function languageForPath(filePath) {
+	const suffix = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+	return EXTENSION_LANGUAGE[suffix] ?? null;
+}
+function validateScope(scope) {
+	if (!scope || typeof scope !== "object" || !scope.ownerId?.trim() || !scope.sessionId?.trim() || !scope.workspaceRoot?.trim() || !isAbsolute(scope.workspaceRoot) || /[\u0000-\u001f\u007f]/u.test(`${scope.ownerId}${scope.sessionId}${scope.workspaceRoot}`)) throw new WebstackLspError("LSP_WORKSPACE_REQUIRED", "trusted owner, session and absolute workspace root are required");
+}
+function normalizeRelativePath(filePath) {
+	if (typeof filePath !== "string" || !filePath.trim() || filePath.length > 4096 || /[\u0000-\u001f\u007f]/u.test(filePath) || isAbsolute(filePath)) throw new WebstackLspError("LSP_WORKSPACE_REQUIRED", "file path must be a relative workspace path");
+	const segments = filePath.replaceAll("\\", "/").split("/");
+	if (segments.some((segment) => segment === ".." || segment === "")) throw new WebstackLspError("LSP_WORKSPACE_REQUIRED", "file path contains an invalid segment");
+	return segments.filter((segment) => segment !== ".").join("/");
+}
+function scopeIdentity(scope) {
+	return JSON.stringify([
+		scope.ownerId,
+		scope.sessionId,
+		scope.workspaceRoot
+	]);
+}
+function scopeKey(scope) {
+	return scopeIdentity(scope);
+}
+function hashText(text) {
+	return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function staleSnapshot() {
+	return new WebstackLspError("LSP_STALE_SNAPSHOT", "snapshot is stale, expired or belongs to another owner");
+}
+
+//#endregion
+//#region src/structure/coordinates.ts
+/** web-tree-sitter 0.27.1 exposes JS-string indices as UTF-16 code-unit offsets. */
+var Utf16Coordinates = class {
+	lines;
+	constructor(text) {
+		this.text = text;
+		this.lines = [];
+		let start = 0;
+		for (let index = 0; index < text.length;) {
+			const char = text[index];
+			if (char !== "\r" && char !== "\n") {
+				index++;
+				continue;
+			}
+			this.lines.push({
+				start,
+				end: index
+			});
+			if (char === "\r" && text[index + 1] === "\n") index++;
+			index++;
+			start = index;
+		}
+		this.lines.push({
+			start,
+			end: text.length
+		});
+	}
+	positionToIndex(position) {
+		if (!isPosition(position)) throw new RangeError("position must use non-negative zero-based UTF-16 coordinates");
+		const line = this.lines[position.line];
+		if (!line || position.character > line.end - line.start) throw new RangeError("position is outside document");
+		const index = line.start + position.character;
+		if (isBetweenSurrogatePair(this.text, index)) throw new RangeError("position splits a UTF-16 surrogate pair");
+		return index;
+	}
+	indexToPosition(index) {
+		if (!Number.isSafeInteger(index) || index < 0 || index > this.text.length) throw new RangeError("Tree-sitter index is outside document");
+		let low = 0, high = this.lines.length;
+		while (low < high) {
+			const middle = low + high >>> 1;
+			if (this.lines[middle].start <= index) low = middle + 1;
+			else high = middle;
+		}
+		const lineNumber = Math.max(0, low - 1);
+		const line = this.lines[lineNumber];
+		return {
+			line: lineNumber,
+			character: Math.min(index, line.end) - line.start
+		};
+	}
+	rangeToIndices(range) {
+		const startIndex = this.positionToIndex(range.start);
+		const endIndex = this.positionToIndex(range.end);
+		if (endIndex < startIndex) throw new RangeError("range end precedes range start");
+		return {
+			startIndex,
+			endIndex
+		};
+	}
+	indicesToRange(startIndex, endIndex) {
+		if (endIndex < startIndex) throw new RangeError("range end precedes range start");
+		return {
+			start: this.indexToPosition(startIndex),
+			end: this.indexToPosition(endIndex)
+		};
+	}
+};
+function isPosition(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const position = value;
+	return Number.isSafeInteger(position.line) && Number.isSafeInteger(position.character) && position.line >= 0 && position.character >= 0;
+}
+function isBetweenSurrogatePair(text, index) {
+	if (index <= 0 || index >= text.length) return false;
+	const previous = text.charCodeAt(index - 1), next = text.charCodeAt(index);
+	return previous >= 55296 && previous <= 56319 && next >= 56320 && next <= 57343;
+}
+
+//#endregion
+//#region src/structure/queries.ts
+const declarations = {
+	javascript: [
+		"(function_declaration name: (_) @name) @declaration",
+		"(class_declaration name: (_) @name) @declaration",
+		"(method_definition name: (_) @name) @declaration",
+		"(variable_declarator name: (_) @name) @declaration"
+	],
+	typescript: [
+		"(function_declaration name: (_) @name) @declaration",
+		"(class_declaration name: (_) @name) @declaration",
+		"(interface_declaration name: (_) @name) @declaration",
+		"(type_alias_declaration name: (_) @name) @declaration",
+		"(enum_declaration name: (_) @name) @declaration",
+		"(method_definition name: (_) @name) @declaration",
+		"(variable_declarator name: (_) @name) @declaration"
+	],
+	tsx: [
+		"(function_declaration name: (_) @name) @declaration",
+		"(class_declaration name: (_) @name) @declaration",
+		"(interface_declaration name: (_) @name) @declaration",
+		"(type_alias_declaration name: (_) @name) @declaration",
+		"(enum_declaration name: (_) @name) @declaration",
+		"(method_definition name: (_) @name) @declaration",
+		"(variable_declarator name: (_) @name) @declaration"
+	]
+};
+const imports = {
+	javascript: ["(import_statement) @import", "(export_statement) @export"],
+	typescript: ["(import_statement) @import", "(export_statement) @export"],
+	tsx: ["(import_statement) @import", "(export_statement) @export"]
+};
+const calls = {
+	javascript: ["(call_expression function: (_) @call) @callsite"],
+	typescript: ["(call_expression function: (_) @call) @callsite"],
+	tsx: ["(call_expression function: (_) @call) @callsite"]
+};
+function getRegisteredQuery(language, queryId) {
+	return (queryId === "declarations" ? declarations[language] : queryId === "calls" ? calls[language] : queryId === "imports" ? imports[language] : void 0)?.join("\n");
+}
+function isRegisteredQueryId(value) {
+	return value === "declarations" || value === "calls" || value === "imports";
+}
+
+//#endregion
+//#region src/structure/worker-pool.ts
+const MAX_WORKERS = 2;
+const MAX_QUEUE = 16;
+const WORKER_TASK_LIMIT = 100;
+const PARSE_TIMEOUT_MS = 2e3;
+/** CPU-bound parsing runs off the event loop; cancellation terminates the active worker. */
+var StructureWorkerPool = class {
+	slots = /* @__PURE__ */ new Set();
+	queue = [];
+	disposed = false;
+	execute(request, signal) {
+		if (this.disposed) return Promise.reject(new WebstackLspError("LSP_DISPOSED", "structure worker pool is disposed"));
+		if (signal?.aborted) return Promise.reject(abortError());
+		if (this.queue.length >= MAX_QUEUE) return Promise.reject(new WebstackLspError("LSP_STRUCTURE_BUSY", "structure worker queue is full"));
+		return new Promise((resolve$1, reject) => {
+			const task = {
+				id: randomUUID(),
+				request,
+				...signal ? { signal } : {},
+				resolve: resolve$1,
+				reject
+			};
+			if (signal) {
+				const abort = () => {
+					const index = this.queue.indexOf(task);
+					if (index >= 0) {
+						this.queue.splice(index, 1);
+						this.finishTask(task, abortError());
+					} else {
+						const slot = [...this.slots].find((candidate) => candidate.current === task);
+						if (slot) this.retire(slot, abortError());
+					}
+				};
+				signal.addEventListener("abort", abort, { once: true });
+				task.removeAbort = () => signal.removeEventListener("abort", abort);
+			}
+			this.queue.push(task);
+			this.pump();
+		});
+	}
+	async dispose() {
+		this.disposed = true;
+		for (const task of this.queue.splice(0)) this.finishTask(task, new WebstackLspError("LSP_DISPOSED", "structure worker pool is disposed"));
+		await Promise.all([...this.slots].map((slot) => this.retire(slot, new WebstackLspError("LSP_DISPOSED", "structure worker pool is disposed"))));
+	}
+	releaseSnapshot(snapshotHandle) {
+		for (const slot of this.slots) if (!slot.failed) try {
+			slot.worker.postMessage({ releaseSnapshotHandle: snapshotHandle });
+		} catch {
+			this.retire(slot, new WebstackLspError("LSP_STRUCTURE_UNAVAILABLE", "structure worker could not release a cached snapshot"));
+		}
+	}
+	get queued() {
+		return this.queue.length;
+	}
+	get active() {
+		return [...this.slots].filter((slot) => slot.current !== void 0).length;
+	}
+	pump() {
+		if (this.disposed) return;
+		while (this.queue.length) {
+			let slot = [...this.slots].find((candidate) => !candidate.current && !candidate.failed);
+			if (!slot && this.slots.size < MAX_WORKERS) slot = this.createWorker();
+			if (!slot) return;
+			const task = this.queue.shift();
+			if (task.signal?.aborted) {
+				this.finishTask(task, abortError());
+				continue;
+			}
+			slot.current = task;
+			task.timer = setTimeout(() => {
+				this.retire(slot, new WebstackLspError("LSP_STRUCTURE_TIMEOUT", "structure parsing exceeded its time limit"));
+			}, PARSE_TIMEOUT_MS);
+			try {
+				slot.worker.postMessage({
+					id: task.id,
+					...task.request
+				});
+			} catch (error) {
+				this.retire(slot, error);
+			}
+		}
+	}
+	createWorker() {
+		const worker = new Worker(new URL("./parser-worker.mjs", import.meta.url));
+		const slot = {
+			worker,
+			current: void 0,
+			completed: 0,
+			failed: false
+		};
+		this.slots.add(slot);
+		worker.on("message", (reply) => {
+			if (!slot.current || reply.id !== slot.current.id) {
+				this.retire(slot, new WebstackLspError("LSP_MALFORMED_RESPONSE", "structure worker returned an unexpected task identity"));
+				return;
+			}
+			const task = slot.current;
+			slot.current = void 0;
+			slot.completed++;
+			if (!reply.ok || !reply.value) this.finishTask(task, new WebstackLspError("LSP_STRUCTURE_UNAVAILABLE", reply.error ?? "structure parsing failed"));
+			else this.finishTask(task, void 0, reply.value);
+			if (slot.completed >= WORKER_TASK_LIMIT) this.retire(slot);
+			this.pump();
+		});
+		worker.on("error", (error) => {
+			this.retire(slot, error);
+		});
+		worker.on("exit", (code) => {
+			if (this.slots.has(slot) && !slot.failed) this.retire(slot, code === 0 ? void 0 : new WebstackLspError("LSP_STRUCTURE_UNAVAILABLE", `structure worker exited (${code})`));
+		});
+		return slot;
+	}
+	async retire(slot, error) {
+		if (slot.failed) return;
+		slot.failed = true;
+		this.slots.delete(slot);
+		const task = slot.current;
+		slot.current = void 0;
+		if (task) this.finishTask(task, error ?? new WebstackLspError("LSP_STRUCTURE_UNAVAILABLE", "structure worker was restarted"));
+		await slot.worker.terminate().catch(() => 0);
+		this.pump();
+	}
+	finishTask(task, error, value) {
+		if (task.timer) clearTimeout(task.timer);
+		task.removeAbort?.();
+		if (error !== void 0) task.reject(error);
+		else task.resolve(value);
+	}
+};
+function abortError() {
+	return new DOMException("The operation was aborted", "AbortError");
+}
+
+//#endregion
+//#region src/structure/engine.ts
+const MAX_CAPTURES = 200;
+const MAX_OUTLINE = 100;
+const MAX_SPAN_CHARS = 8e3;
+const MAX_STRUCTURE_RESPONSE_BYTES = 32 * 1024;
+const MAX_NODE_HANDLES = 1e4;
+var StructureEngine = class {
+	nodeHandles = /* @__PURE__ */ new Map();
+	snapshotOwners = /* @__PURE__ */ new Map();
+	parserFailures = /* @__PURE__ */ new Map();
+	constructor(workers = new StructureWorkerPool()) {
+		this.workers = workers;
+	}
+	async inspect(record, signal) {
+		this.snapshotOwners.set(record.descriptor.handle, record.scopeKey);
+		const language = record.descriptor.language;
+		if (!language) return {
+			available: false,
+			parseErrors: false,
+			reason: "grammar_missing"
+		};
+		try {
+			const result = await this.runWorker(language, {
+				operation: "inspect",
+				language,
+				text: record.source.text,
+				querySource: "",
+				limit: 1,
+				snapshotHandle: record.descriptor.handle,
+				...record.previousSnapshotHandle ? { previousSnapshotHandle: record.previousSnapshotHandle } : {}
+			}, signal);
+			this.parserFailures.delete(language);
+			return {
+				available: true,
+				parseErrors: result.errors.hasError
+			};
+		} catch (error) {
+			return {
+				available: false,
+				parseErrors: false,
+				reason: error instanceof Error ? error.message.slice(0, 128) : "parser_unavailable"
+			};
+		}
+	}
+	async outline(record, scope, options = {}, signal) {
+		const language = record.descriptor.language;
+		if (!language) return {
+			status: "unsupported",
+			handle: record.descriptor.handle,
+			version: record.descriptor.version,
+			declarations: [],
+			truncated: false,
+			processed: 0,
+			errors: {
+				hasError: false,
+				errorNodes: 0,
+				missingNodes: 0,
+				truncated: false
+			}
+		};
+		const limit = positiveLimit(options.limit, MAX_OUTLINE, "outline limit");
+		const coordinates = new Utf16Coordinates(record.source.text);
+		const range = options.range ? coordinates.rangeToIndices(options.range) : void 0;
+		const result = await this.runMatches(language, record, "declarations", limit, range, signal);
+		const declarations$1 = [];
+		for (const match of result.matches ?? []) {
+			const declaration = match.captures.find((capture) => capture.name === "declaration");
+			const nameCapture = match.captures.find((capture) => capture.name === "name");
+			if (!declaration) continue;
+			const node = this.node(record, scope, declaration.kind, declaration.startIndex, declaration.endIndex, nameCapture ? record.source.text.slice(nameCapture.startIndex, nameCapture.endIndex).slice(0, 256) : void 0, declaration.childCount, coordinates);
+			declarations$1.push(node);
+		}
+		return this.outlineResult(record, declarations$1, result);
+	}
+	async enclosing(record, scope, position, kinds, signal) {
+		const language = record.descriptor.language;
+		if (!language) return {
+			status: "unsupported",
+			handle: record.descriptor.handle,
+			version: record.descriptor.version,
+			ancestors: []
+		};
+		const coordinates = new Utf16Coordinates(record.source.text);
+		const index = coordinates.positionToIndex(position);
+		if (kinds && (!Array.isArray(kinds) || kinds.length > 32 || kinds.some((kind) => typeof kind !== "string" || kind.length > 128 || !/^[a-z][a-z0-9_]*$/u.test(kind)))) throw new WebstackLspError("LSP_STRUCTURE_LIMIT", "kinds must be a list of at most 32 node type names");
+		const result = await this.runWorker(language, {
+			operation: "enclosing",
+			language,
+			text: record.source.text,
+			querySource: "",
+			limit: 16,
+			snapshotHandle: record.descriptor.handle,
+			index,
+			...kinds ? { kinds: [...kinds] } : {}
+		}, signal);
+		const [node, ...ancestors] = (result.nodes ?? []).map((item) => this.node(record, scope, item.kind, item.startIndex, item.endIndex, void 0, item.childCount, coordinates));
+		return {
+			status: result.status,
+			handle: record.descriptor.handle,
+			version: record.descriptor.version,
+			...node ? { node } : {},
+			ancestors,
+			errors: publicErrors(result.errors)
+		};
+	}
+	async query(record, scope, queryId, options = {}, signal) {
+		const language = record.descriptor.language;
+		if (!language) throw new WebstackLspError("LSP_STRUCTURE_UNSUPPORTED", "no bundled Tree-sitter grammar is available for this document");
+		if (!isRegisteredQueryId(queryId)) throw new WebstackLspError("LSP_STRUCTURE_UNSUPPORTED", "queryId is not in the registered query allowlist");
+		const limit = positiveLimit(options.limit, MAX_CAPTURES, "capture limit");
+		const coordinates = new Utf16Coordinates(record.source.text);
+		const range = options.range ? coordinates.rangeToIndices(options.range) : void 0;
+		const result = await this.runMatches(language, record, queryId, limit, range, signal);
+		const captures = [];
+		captureLoop: for (const match of result.matches ?? []) for (const capture of match.captures) {
+			const node = this.node(record, scope, capture.kind, capture.startIndex, capture.endIndex, void 0, capture.childCount, coordinates);
+			captures.push({
+				capture: capture.name,
+				kind: capture.kind,
+				range: node.range,
+				nodeHandle: node.handle,
+				...capture.name === "name" ? { name: record.source.text.slice(capture.startIndex, capture.endIndex).slice(0, 256) } : {}
+			});
+			if (captures.length >= limit) break captureLoop;
+		}
+		if (Buffer.byteLength(JSON.stringify(captures), "utf8") > MAX_STRUCTURE_RESPONSE_BYTES) throw new WebstackLspError("LSP_STRUCTURE_LIMIT", "query result exceeds the response byte limit");
+		return {
+			status: result.status,
+			handle: record.descriptor.handle,
+			version: record.descriptor.version,
+			queryId,
+			captures,
+			truncated: Boolean(result.truncated || (result.matches?.length ?? 0) > limit),
+			processed: captures.length,
+			errors: publicErrors(result.errors)
+		};
+	}
+	async span(record, scope, nodeHandle, maxChars = MAX_SPAN_CHARS) {
+		const handle = this.nodeHandles.get(nodeHandle);
+		if (!handle || handle.snapshotHandle !== record.descriptor.handle || handle.scopeKey !== scopeIdentity(scope)) throw new WebstackLspError("LSP_STALE_SNAPSHOT", "node handle is stale or belongs to another owner");
+		if (!Number.isSafeInteger(maxChars) || maxChars < 1 || maxChars > MAX_SPAN_CHARS) throw new WebstackLspError("LSP_STRUCTURE_LIMIT", `maxChars must be between 1 and ${MAX_SPAN_CHARS}`);
+		const full = record.source.text.slice(handle.startIndex, handle.endIndex);
+		const codePoints = Array.from(full);
+		const truncated = codePoints.length > maxChars;
+		const text = codePoints.slice(0, maxChars).join("");
+		if (Buffer.byteLength(text, "utf8") > MAX_STRUCTURE_RESPONSE_BYTES) throw new WebstackLspError("LSP_STRUCTURE_LIMIT", "span result exceeds the response byte limit");
+		return {
+			status: truncated ? "partial" : "ok",
+			text,
+			truncated,
+			range: handle.range
+		};
+	}
+	releaseSnapshot(handle) {
+		for (const [nodeHandle, node] of this.nodeHandles) if (node.snapshotHandle === handle) this.nodeHandles.delete(nodeHandle);
+		this.snapshotOwners.delete(handle);
+		this.workers.releaseSnapshot(handle);
+	}
+	releaseSnapshotForOwner(scope, handle) {
+		if (this.snapshotOwners.get(handle) === scopeIdentity(scope)) this.releaseSnapshot(handle);
+	}
+	snapshotForNode(scope, nodeHandle) {
+		const record = this.nodeHandles.get(nodeHandle);
+		if (!record || record.scopeKey !== scopeIdentity(scope)) throw new WebstackLspError("LSP_STALE_SNAPSHOT", "node handle is stale or belongs to another owner");
+		return record.snapshotHandle;
+	}
+	releaseOwner(scope) {
+		const owner = scopeIdentity(scope);
+		for (const [nodeHandle, node] of this.nodeHandles) if (node.scopeKey === owner) this.nodeHandles.delete(nodeHandle);
+		for (const [snapshotHandle, snapshotOwner] of this.snapshotOwners) if (snapshotOwner === owner) this.releaseSnapshot(snapshotHandle);
+	}
+	capabilities() {
+		return [
+			this.capability("javascript", [
+				".js",
+				".jsx",
+				".mjs",
+				".cjs"
+			], 15),
+			this.capability("typescript", [
+				".ts",
+				".mts",
+				".cts"
+			], 14),
+			this.capability("tsx", [".tsx"], 14)
+		];
+	}
+	async dispose() {
+		this.nodeHandles.clear();
+		this.snapshotOwners.clear();
+		await this.workers.dispose();
+	}
+	async runMatches(language, record, queryId, limit, range, signal) {
+		const querySource = getRegisteredQuery(language, queryId);
+		if (!querySource) throw new WebstackLspError("LSP_STRUCTURE_UNSUPPORTED", `query ${queryId} is not registered for ${language}`);
+		return this.runWorker(language, {
+			operation: "matches",
+			language,
+			text: record.source.text,
+			querySource,
+			limit,
+			snapshotHandle: record.descriptor.handle,
+			...range ?? {}
+		}, signal);
+	}
+	capability(language, extensions, abiVersion) {
+		const lastError = this.parserFailures.get(language);
+		return {
+			language,
+			extensions,
+			available: !lastError,
+			abiVersion,
+			...lastError ? { lastError } : {}
+		};
+	}
+	async runWorker(language, request, signal) {
+		try {
+			const result = await this.workers.execute(request, signal);
+			this.parserFailures.delete(language);
+			return result;
+		} catch (error) {
+			if (error instanceof WebstackLspError && ["LSP_STRUCTURE_TIMEOUT", "LSP_STRUCTURE_UNAVAILABLE"].includes(error.code)) this.parserFailures.set(language, error.message.slice(0, 128));
+			throw error;
+		}
+	}
+	outlineResult(record, declarations$1, result) {
+		const truncated = Boolean(result.truncated || declarations$1.length > MAX_OUTLINE);
+		const selected = declarations$1.slice(0, MAX_OUTLINE);
+		if (Buffer.byteLength(JSON.stringify(selected), "utf8") > MAX_STRUCTURE_RESPONSE_BYTES) throw new WebstackLspError("LSP_STRUCTURE_LIMIT", "outline result exceeds the response byte limit");
+		return {
+			status: result.status,
+			handle: record.descriptor.handle,
+			version: record.descriptor.version,
+			declarations: selected,
+			truncated,
+			processed: selected.length,
+			errors: publicErrors(result.errors)
+		};
+	}
+	node(record, scope, kind, startIndex, endIndex, name, childCount, coordinates = new Utf16Coordinates(record.source.text)) {
+		if (this.nodeHandles.size >= MAX_NODE_HANDLES) throw new WebstackLspError("LSP_SNAPSHOT_LIMIT", "node handle capacity is full; release a snapshot and retry");
+		const handle = randomUUID();
+		const range = coordinates.indicesToRange(startIndex, endIndex);
+		this.nodeHandles.set(handle, {
+			scopeKey: scopeIdentity(scope),
+			snapshotHandle: record.descriptor.handle,
+			startIndex,
+			endIndex,
+			kind,
+			range
+		});
+		return {
+			handle,
+			kind: publicNodeKind(kind),
+			range,
+			...name ? { name } : {},
+			...childCount === void 0 ? {} : { childCount }
+		};
+	}
+};
+function positiveLimit(value, maximum, label) {
+	const limit = value ?? maximum;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > maximum) throw new WebstackLspError("LSP_STRUCTURE_LIMIT", `${label} must be between 1 and ${maximum}`);
+	return limit;
+}
+function publicErrors(errors) {
+	return { ...errors };
+}
+function publicNodeKind(kind) {
+	return {
+		function_declaration: "function",
+		class_declaration: "class",
+		interface_declaration: "interface",
+		type_alias_declaration: "type",
+		enum_declaration: "enum",
+		method_definition: "method",
+		variable_declarator: "variable"
+	}[kind] ?? kind;
+}
+
+//#endregion
+//#region src/structure/code-intelligence.ts
+var CodeIntelligenceRuntime = class {
+	version = 1;
+	snapshot;
+	structure;
+	semantic;
+	store;
+	engine;
+	constructor(options) {
+		this.store = options.snapshots;
+		this.engine = new StructureEngine();
+		this.snapshot = {
+			open: async (scope, filePath, signal) => {
+				const record = await this.store.open(scope, filePath, signal);
+				try {
+					const parser = await this.engine.inspect(record, signal);
+					await this.store.current(scope, record.descriptor.handle, signal);
+					return {
+						status: "ok",
+						...record.descriptor,
+						parserAvailable: parser.available,
+						parseErrors: parser.parseErrors
+					};
+				} catch (error) {
+					this.store.release(scope, record.descriptor.handle);
+					this.engine.releaseSnapshot(record.descriptor.handle);
+					throw error;
+				}
+			},
+			release: async (scope, handle) => {
+				const released = this.store.release(scope, handle);
+				if (released) this.engine.releaseSnapshot(handle);
+				return { released };
+			}
+		};
+		this.structure = {
+			outline: (scope, handle, request, signal) => this.withSnapshot(scope, handle, signal, (record) => this.engine.outline(record, scope, request, signal)),
+			enclosing: (scope, handle, position, request, signal) => this.withSnapshot(scope, handle, signal, (record) => this.engine.enclosing(record, scope, position, request?.kinds, signal)),
+			query: (scope, handle, queryId, request, signal) => this.withSnapshot(scope, handle, signal, (record) => this.engine.query(record, scope, queryId, request, signal)),
+			span: (scope, nodeHandle, maxChars, signal) => this.span(scope, nodeHandle, maxChars, signal)
+		};
+		this.semantic = { query: async (scope, handle, request, signal) => {
+			validateSemanticQuery(request);
+			return this.withSnapshot(scope, handle, signal, async (record) => {
+				const raw = await options.semanticQuery(scope, record, request, signal ?? new AbortController().signal);
+				await this.store.current(scope, handle, signal);
+				const bounded = limitSemanticResult(raw, request.maxResults ?? 200);
+				const truncated = "truncated" in bounded && Boolean(bounded.truncated);
+				const value = {
+					status: semanticIsPartial(bounded) || truncated ? "partial" : "ok",
+					operation: request.operation,
+					result: bounded,
+					...truncated ? {
+						truncated: true,
+						omitted: "omitted" in bounded && typeof bounded.omitted === "number" ? bounded.omitted : 0
+					} : {}
+				};
+				if (Buffer.byteLength(JSON.stringify(value), "utf8") > MAX_STRUCTURE_RESPONSE_BYTES) throw new WebstackLspError("LSP_STRUCTURE_LIMIT", "semantic result exceeds the response byte limit");
+				return value;
+			});
+		} };
+	}
+	capabilities() {
+		return {
+			version: 1,
+			parsers: this.engine.capabilities().map((parser) => ({
+				...parser,
+				runtimeAbi: {
+					minimum: 13,
+					current: 15
+				}
+			})),
+			sourceKind: "disk",
+			overlay: "unavailable",
+			limits: {
+				maxDocumentBytes: Math.min(this.store.documentByteLimit, 2 * 1024 * 1024),
+				maxCaptures: MAX_CAPTURES,
+				maxOutline: MAX_OUTLINE,
+				maxSpanChars: MAX_SPAN_CHARS,
+				maxResponseBytes: MAX_STRUCTURE_RESPONSE_BYTES
+			},
+			incrementalParsing: true
+		};
+	}
+	async releaseOwner(scope) {
+		this.engine.releaseOwner(scope);
+		return this.store.releaseOwner(scope);
+	}
+	async dispose() {
+		this.store.clear();
+		await this.engine.dispose();
+	}
+	async span(scope, nodeHandle, maxChars = MAX_SPAN_CHARS, signal) {
+		const snapshotHandle = this.engine.snapshotForNode(scope, nodeHandle);
+		return this.withSnapshot(scope, snapshotHandle, signal, (record) => this.engine.span(record, scope, nodeHandle, maxChars));
+	}
+	async withSnapshot(scope, handle, signal, execute) {
+		let record;
+		try {
+			record = await this.store.current(scope, handle, signal);
+		} catch (error) {
+			if (error instanceof WebstackLspError && error.code === "LSP_STALE_SNAPSHOT") this.engine.releaseSnapshotForOwner(scope, handle);
+			throw error;
+		}
+		try {
+			const result = await execute(record);
+			await this.store.current(scope, handle, signal);
+			return result;
+		} catch (error) {
+			if (error instanceof WebstackLspError && error.code === "LSP_STALE_SNAPSHOT") this.engine.releaseSnapshotForOwner(scope, handle);
+			throw error;
+		}
+	}
+};
+function createCodeIntelligenceToolServiceV1(options) {
+	return new CodeIntelligenceRuntime(options);
+}
+function validateSemanticQuery(request) {
+	if (!request || ![
+		"definition",
+		"references",
+		"implementation",
+		"hover",
+		"diagnostics",
+		"completion"
+	].includes(request.operation)) throw new WebstackLspError("LSP_UNSUPPORTED_OPERATION", "semantic operation is not supported");
+	if (request.operation !== "diagnostics" && !request.position) throw new WebstackLspError("LSP_WORKSPACE_REQUIRED", "semantic position is required for this operation");
+	if (request.position && (!Number.isSafeInteger(request.position.line) || !Number.isSafeInteger(request.position.character) || request.position.line < 0 || request.position.character < 0)) throw new WebstackLspError("LSP_WORKSPACE_REQUIRED", "semantic position must be a zero-based UTF-16 position");
+	if (request.servers && (!Array.isArray(request.servers) || request.servers.length > 6 || request.servers.some((server) => typeof server !== "string" || server.length > 64))) throw new WebstackLspError("LSP_WORKSPACE_REQUIRED", "semantic server filter is invalid");
+	if (request.maxResults !== void 0 && (!Number.isSafeInteger(request.maxResults) || request.maxResults < 1 || request.maxResults > 200)) throw new WebstackLspError("LSP_STRUCTURE_LIMIT", "maxResults must be between 1 and 200");
+}
+function semanticIsPartial(result) {
+	if ("diagnostics" in result) return Boolean(result.omittedServers?.length || result.truncated);
+	if ("items" in result) return Boolean(result.truncated);
+	if (result.kind === "locations") return Boolean(result.truncated);
+	return false;
+}
+function limitSemanticResult(result, limit) {
+	if ("items" in result) {
+		if (result.items.length <= limit) return result;
+		return {
+			...result,
+			items: result.items.slice(0, limit),
+			truncated: {
+				items: result.items.length - limit,
+				characters: 0
+			}
+		};
+	}
+	if ("diagnostics" in result) {
+		if (result.diagnostics.length <= limit) return result;
+		return {
+			...result,
+			diagnostics: result.diagnostics.slice(0, limit),
+			truncated: {
+				diagnostics: result.diagnostics.length - limit,
+				characters: 0
+			}
+		};
+	}
+	if (result.kind === "locations" && result.locations.length > limit) return {
+		...result,
+		locations: result.locations.slice(0, limit),
+		truncated: true,
+		omitted: result.locations.length - limit
+	};
+	return result;
+}
+
+//#endregion
+export { DocumentSnapshotStore, createCodeIntelligenceToolServiceV1 };
+//# sourceMappingURL=code-intelligence-DvhxPnpu.js.map