@askdkc/dsh-lsp-server 0.1.12 → 0.1.13

package/lib/provider.js

@@ -1,8 +1,12 @@
 import { WebstackLspError } from "./errors-DtyWAUi0.js";
 import { SERVER_IDS, createWebstackLspService, initializationOptions, resolveConfig, resolveLaunch, serverConfiguration } from "./launch-ByUvgkVv.js";
 import { mergeCompletions, mergeDiagnostics } from "./completion-B7NPVCEN.js";
+import { DocumentSnapshotStore, createCodeIntelligenceToolServiceV1 } from "./code-intelligence-DvhxPnpu.js";
 import { LspProviderId } from "@deepseek-ai/dsh-lsp";
+import { isAbsolute } from "node:path";
 import { TextDecoder } from "node:util";
+import { randomUUID } from "node:crypto";
+import { symbols } from "@deepseek-ai/cordis";
 
 //#region src/runtime/cancellation.ts
 function abortError() {
@@ -25,11 +29,11 @@ function onAbort(signal, callback) {
 async function withAbort(promise, signal) {
 	throwIfAborted(signal);
 	if (!signal) return promise;
-	return new Promise((resolve, reject) => {
+	return new Promise((resolve$1, reject) => {
 		const remove = onAbort(signal, () => reject(abortError()));
 		promise.then((value) => {
 			remove();
-			resolve(value);
+			resolve$1(value);
 		}, (error) => {
 			remove();
 			reject(error);
@@ -143,17 +147,17 @@ const CLASSIFIERS = [
 ];
 function classifyFile(filePath, bladeSuffixes = [".blade.php"]) {
 	const normalizedPath = filePath.replaceAll("\\", "/");
-	const basename = normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1).toLowerCase();
-	if (!basename || basename === "." || basename === ".." || basename.startsWith(".")) return void 0;
+	const basename$1 = normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1).toLowerCase();
+	if (!basename$1 || basename$1 === "." || basename$1 === ".." || basename$1.startsWith(".")) return void 0;
 	const customBlade = bladeSuffixes.map((suffix) => suffix.toLowerCase()).sort((left, right) => right.length - left.length);
 	const match = [...customBlade.map((suffix) => ({
 		suffix,
 		kind: "blade"
-	})), ...CLASSIFIERS.filter((item) => !customBlade.includes(item.suffix))].find((item) => basename.endsWith(item.suffix));
+	})), ...CLASSIFIERS.filter((item) => !customBlade.includes(item.suffix))].find((item) => basename$1.endsWith(item.suffix));
 	if (!match) return void 0;
 	return {
 		path: normalizedPath,
-		basename,
+		basename: basename$1,
 		suffix: match.suffix,
 		kind: match.kind
 	};
@@ -401,8 +405,8 @@ var JsonRpcConnection = class {
 		throwIfAborted(signal);
 		if (this.closed) throw new Error("connection is closed");
 		const id = this.nextId++;
-		const promise = new Promise((resolve, reject) => this.pending.set(id, {
-			resolve,
+		const promise = new Promise((resolve$1, reject) => this.pending.set(id, {
+			resolve: resolve$1,
 			reject,
 			method
 		}));
@@ -451,7 +455,7 @@ var JsonRpcConnection = class {
 		for (const message of messages) this.dispatch(message);
 	}
 	dispatch(value) {
-		if (!isRecord$4(value) || value.jsonrpc !== "2.0") return this.close(new JsonRpcFrameError("invalid JSON-RPC message"));
+		if (!isRecord$5(value) || value.jsonrpc !== "2.0") return this.close(new JsonRpcFrameError("invalid JSON-RPC message"));
 		if ("method" in value && typeof value.method === "string") {
 			if ("id" in value) {
 				const request = value;
@@ -480,12 +484,12 @@ var JsonRpcConnection = class {
 		}
 	}
 	write(message) {
-		return new Promise((resolve, reject) => {
-			this.output.write(encodeJsonRpc(message), (error) => error ? reject(error) : resolve());
+		return new Promise((resolve$1, reject) => {
+			this.output.write(encodeJsonRpc(message), (error) => error ? reject(error) : resolve$1());
 		});
 	}
 };
-function isRecord$4(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -650,8 +654,8 @@ var ServerPool = class {
 	async serialize(key, task, signal) {
 		const previous = this.queues.get(key) ?? Promise.resolve();
 		let release;
-		const current = new Promise((resolve) => {
-			release = resolve;
+		const current = new Promise((resolve$1) => {
+			release = resolve$1;
 		});
 		this.queues.set(key, current);
 		try {
@@ -718,29 +722,29 @@ function normalizeHover(value) {
 function normalizeContents(value) {
 	if (typeof value === "string") return value;
 	if (Array.isArray(value)) {
-		const parts = value.map((item) => typeof item === "string" ? item : isRecord$3(item) && typeof item.value === "string" ? item.value : void 0);
+		const parts = value.map((item) => typeof item === "string" ? item : isRecord$4(item) && typeof item.value === "string" ? item.value : void 0);
 		return parts.every((item) => item !== void 0) ? parts.join("\n") : void 0;
 	}
-	if (isRecord$3(value) && typeof value.value === "string") return value.value;
+	if (isRecord$4(value) && typeof value.value === "string") return value.value;
 }
 function isRange$2(value) {
-	return isRecord$3(value) && isPosition$2(value.start) && isPosition$2(value.end);
+	return isRecord$4(value) && isPosition$2(value.start) && isPosition$2(value.end);
 }
 function isPosition$2(value) {
-	return isRecord$3(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
+	return isRecord$4(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
 }
-function isRecord$3(value) {
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 //#endregion
 //#region src/protocol/normalize-location.ts
 function normalizeLocation(value) {
-	if (isRecord$2(value) && typeof value.targetUri === "string" && isRange$1(value.targetSelectionRange)) return {
+	if (isRecord$3(value) && typeof value.targetUri === "string" && isRange$1(value.targetSelectionRange)) return {
 		uri: value.targetUri,
 		range: value.targetSelectionRange
 	};
-	if (!isRecord$2(value) || typeof value.uri !== "string" || !isRange$1(value.range)) return void 0;
+	if (!isRecord$3(value) || typeof value.uri !== "string" || !isRange$1(value.range)) return void 0;
 	return {
 		uri: value.uri,
 		range: value.range
@@ -750,19 +754,19 @@ function normalizeLocations(value) {
 	return (Array.isArray(value) ? value : value === null || value === void 0 ? [] : [value]).map(normalizeLocation).filter((location) => location !== void 0);
 }
 function isRange$1(value) {
-	return isRecord$2(value) && isPosition$1(value.start) && isPosition$1(value.end);
+	return isRecord$3(value) && isPosition$1(value.start) && isPosition$1(value.end);
 }
 function isPosition$1(value) {
-	return isRecord$2(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
+	return isRecord$3(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
 }
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 //#endregion
 //#region src/protocol/normalize-diagnostic.ts
 function normalizeDiagnostic(value, server, fallbackUri) {
-	if (!isRecord$1(value) || !isRange(value.range) || typeof value.message !== "string") return void 0;
+	if (!isRecord$2(value) || !isRange(value.range) || typeof value.message !== "string") return void 0;
 	const uri = typeof value.uri === "string" ? value.uri : fallbackUri;
 	const severity = typeof value.severity === "number" && value.severity >= 1 && value.severity <= 4 ? value.severity : void 0;
 	const code = typeof value.code === "string" || typeof value.code === "number" ? value.code : void 0;
@@ -780,19 +784,19 @@ function normalizeDiagnostics(value, server, fallbackUri) {
 	return (Array.isArray(value) ? value : []).map((item) => normalizeDiagnostic(item, server, fallbackUri)).filter((item) => item !== void 0);
 }
 function isRange(value) {
-	return isRecord$1(value) && isPosition(value.start) && isPosition(value.end);
+	return isRecord$2(value) && isPosition(value.start) && isPosition(value.end);
 }
 function isPosition(value) {
-	return isRecord$1(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
+	return isRecord$2(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 //#endregion
 //#region src/protocol/normalize-completion.ts
 function normalizeCompletionItem(value, server) {
-	if (!isRecord(value) || typeof value.label !== "string" || value.label.length === 0) return void 0;
+	if (!isRecord$1(value) || typeof value.label !== "string" || value.label.length === 0) return void 0;
 	return {
 		server,
 		label: value.label,
@@ -807,9 +811,9 @@ function normalizeCompletionItem(value, server) {
 	};
 }
 function normalizeCompletion(value, server) {
-	return (isRecord(value) && Array.isArray(value.items) ? value.items : Array.isArray(value) ? value : []).map((item) => normalizeCompletionItem(item, server)).filter((item) => item !== void 0);
+	return (isRecord$1(value) && Array.isArray(value.items) ? value.items : Array.isArray(value) ? value : []).map((item) => normalizeCompletionItem(item, server)).filter((item) => item !== void 0);
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -831,6 +835,451 @@ function sameRange(left, right) {
 	return JSON.stringify(left) === JSON.stringify(right);
 }
 
+//#endregion
+//#region src/structure/protocol.ts
+const CAPABILITIES = [
+	"snapshots",
+	"structure",
+	"semantic"
+];
+const MAX_FILES = 100;
+const MAX_INPUT_BYTES = 16 * 1024 * 1024;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const MAX_CALLS = 100;
+const MAX_BATCH_MS = 3e4;
+const RESPONSE_BYTES = 32 * 1024;
+/** Host-bound V1 facade. Each lease owns its handles and cumulative evaluation budget. */
+var CodeIntelligenceProtocolService = class {
+	version = 1;
+	capabilities = CAPABILITIES;
+	leases = /* @__PURE__ */ new Set();
+	closed = false;
+	constructor(options) {
+		this.options = options;
+	}
+	async bind(binding, signal) {
+		if (this.closed) throw new WebstackLspError("LSP_DISPOSED", "code-intelligence service is disposed");
+		validateBinding(binding);
+		signal.throwIfAborted();
+		await binding.assertCurrent();
+		const contextFs = binding.context.get("fs", false);
+		const contextSubprocess = binding.context.get("subprocess", false);
+		if (identity(contextFs) !== identity(this.options.fs) || identity(contextSubprocess) !== identity(this.options.subprocess)) throw new WebstackLspError("LSP_CODE_INTELLIGENCE_UNAVAILABLE", "host services do not match the provider scope");
+		const scope = {
+			ownerId: `${binding.owner.agentId}:code:${randomUUID()}`,
+			sessionId: binding.owner.sessionId,
+			workspaceRoot: binding.workspaceRoot
+		};
+		const lease = new CodeLease(binding, scope, this.options.backend, this.options.capabilities, identity(this.options.fs), identity(this.options.subprocess), () => this.leases.delete(lease));
+		this.leases.add(lease);
+		try {
+			await lease.assertCurrent(signal);
+			if (this.closed) throw new WebstackLspError("LSP_DISPOSED", "code-intelligence service is disposed");
+			return lease;
+		} catch (error) {
+			await lease.dispose();
+			throw error;
+		}
+	}
+	async dispose() {
+		if (this.closed) return;
+		this.closed = true;
+		await Promise.all([...this.leases].map((lease) => lease.dispose()));
+	}
+};
+var CodeLease = class {
+	lifetime = new AbortController();
+	snapshots = /* @__PURE__ */ new Map();
+	nodes = /* @__PURE__ */ new Map();
+	calls = 0;
+	files = 0;
+	inputBytes = 0;
+	outputBytes = 0;
+	started = performance.now();
+	disposed = false;
+	disposal;
+	constructor(binding, scope, backend, capabilities, fsIdentity, subprocessIdentity, onDispose) {
+		this.binding = binding;
+		this.scope = scope;
+		this.backend = backend;
+		this.capabilities = capabilities;
+		this.fsIdentity = fsIdentity;
+		this.subprocessIdentity = subprocessIdentity;
+		this.onDispose = onDispose;
+	}
+	async assertCurrent(signal) {
+		signal.throwIfAborted();
+		if (this.disposed) throw new WebstackLspError("LSP_STALE_SNAPSHOT", "code evaluation has ended");
+		await this.binding.assertCurrent();
+		if (identity(this.binding.context.get("fs", false)) !== this.fsIdentity || identity(this.binding.context.get("subprocess", false)) !== this.subprocessIdentity) throw new WebstackLspError("LSP_STALE_SNAPSHOT", "host service scope changed");
+		signal.throwIfAborted();
+	}
+	async request(input, caller) {
+		const release = input?.method === "snapshot.release";
+		if (!release) this.calls++;
+		if (this.disposed) return this.account(outcome("stale", "evaluation_closed"));
+		if (!validCodeRequest(input)) return this.account(outcome("unsupported", "invalid_request"));
+		if (caller.aborted) return this.account(outcome(caller.reason?.name === "TimeoutError" ? "timeout" : "cancelled", caller.reason?.name === "TimeoutError" ? "caller_deadline" : "caller_cancelled"));
+		if (release) return this.release(input.handle);
+		if (this.calls > MAX_CALLS || this.outputBytes >= MAX_OUTPUT_BYTES || this.files >= MAX_FILES && input.method === "snapshot.open" || this.inputBytes >= MAX_INPUT_BYTES && input.method === "snapshot.open") return this.account(outcome("limit_exceeded", "evaluation_budget"));
+		const remaining = MAX_BATCH_MS - (performance.now() - this.started);
+		if (remaining <= 0) return this.account(outcome("timeout", "batch_deadline"));
+		if ("handle" in input && !this.snapshots.has(input.handle) || "nodeHandle" in input && !this.nodes.has(input.nodeHandle)) return this.account(outcome("stale", "unknown_handle"));
+		const duration = input.method === "semantic.query" ? 1e4 : 2e3;
+		const timeout = AbortSignal.timeout(Math.max(1, Math.floor(Math.min(remaining, duration))));
+		const signal = AbortSignal.any([
+			caller,
+			this.lifetime.signal,
+			timeout
+		]);
+		try {
+			await this.assertCurrent(signal);
+			let response;
+			if (input.method === "capabilities") response = this.capabilitiesResponse(await this.capabilities(signal));
+			else if (input.method === "snapshot.open") response = await this.open(input, signal);
+			else response = await this.query(input, signal);
+			await this.assertCurrent(signal);
+			return this.account(boundResponse(response));
+		} catch (error) {
+			if (signal.aborted) return this.account(outcome(this.lifetime.signal.aborted || caller.aborted && caller.reason?.name !== "TimeoutError" ? "cancelled" : "timeout", caller.aborted ? caller.reason?.name === "TimeoutError" ? "caller_deadline" : "caller_cancelled" : "operation_deadline"));
+			if (error instanceof WebstackLspError) return this.account(mapError(error));
+			return this.account(outcome("unavailable", "provider_operation_failed"));
+		}
+	}
+	async open(input, signal) {
+		this.files++;
+		const opened = await this.backend.snapshot.open(this.scope, input.path, signal);
+		const version = `${opened.version}:${opened.contentHash}`;
+		const response = {
+			protocol: "code-intelligence/v1",
+			status: "ok",
+			sourceKind: "disk",
+			freshness: "pinned",
+			snapshotVersion: version,
+			truncated: false,
+			omitted: 0,
+			inputBytes: opened.sourceBytes,
+			data: {
+				handle: opened.handle,
+				path: opened.filePath,
+				language: opened.language ?? "unsupported",
+				parseErrors: opened.parseErrors
+			}
+		};
+		if (this.inputBytes + opened.sourceBytes > MAX_INPUT_BYTES) {
+			await this.backend.snapshot.release(this.scope, opened.handle).catch(() => {});
+			return outcome("limit_exceeded", "input_budget");
+		}
+		this.inputBytes += opened.sourceBytes;
+		this.snapshots.set(opened.handle, {
+			version,
+			path: opened.filePath
+		});
+		return response;
+	}
+	async query(input, signal) {
+		const handle = "handle" in input ? input.handle : this.nodes.get(input.nodeHandle);
+		const snapshot = this.snapshots.get(handle);
+		if (!snapshot) return outcome("stale", "unknown_handle");
+		const metadata = {
+			snapshotVersion: snapshot.version,
+			freshness: "current"
+		};
+		if (input.method === "structure.outline") {
+			const result = await this.backend.structure.outline(this.scope, input.handle, {
+				...input.range ? { range: input.range } : {},
+				...input.limit ? { limit: input.limit } : {}
+			}, signal);
+			const items = result.declarations.map(projectNode);
+			this.rememberNodes(handle, items);
+			const status = result.truncated && result.status === "ok" ? "partial" : result.status;
+			return responseFor(status, result.status === "unsupported" ? "grammar_missing" : result.errors.hasError ? "parse_errors" : void 0, metadata, { items }, result.truncated, result.truncated ? 1 : 0);
+		}
+		if (input.method === "structure.enclosing") {
+			const result = await this.backend.structure.enclosing(this.scope, input.handle, input.position, input.kinds ? { kinds: input.kinds } : void 0, signal);
+			const items = [...result.node ? [result.node] : [], ...result.ancestors].map(projectNode);
+			this.rememberNodes(handle, items);
+			return responseFor(result.status, result.status === "unsupported" ? "grammar_missing" : result.errors?.hasError ? "parse_errors" : void 0, metadata, { items });
+		}
+		if (input.method === "structure.query") {
+			const result = await this.backend.structure.query(this.scope, input.handle, input.queryId, {
+				...input.range ? { range: input.range } : {},
+				...input.limit ? { limit: input.limit } : {}
+			}, signal);
+			const items = result.captures.map((capture) => ({
+				handle: capture.nodeHandle,
+				kind: capture.kind,
+				range: capture.range,
+				...capture.name ? { name: capture.name } : {}
+			}));
+			this.rememberNodes(handle, items);
+			return responseFor(result.truncated && result.status === "ok" ? "partial" : result.status, void 0, metadata, {
+				items,
+				queryId: result.queryId
+			}, result.truncated, result.truncated ? 1 : 0);
+		}
+		if (input.method === "structure.span") {
+			const result = await this.backend.structure.span(this.scope, input.nodeHandle, input.maxChars, signal);
+			return responseFor(result.status, void 0, metadata, {
+				text: result.text,
+				range: result.range
+			}, result.truncated, result.truncated ? 1 : 0);
+		}
+		return this.semantic(input, metadata, signal);
+	}
+	async semantic(input, metadata, signal) {
+		const result = await this.backend.semantic.query(this.scope, input.handle, {
+			operation: input.kind,
+			...input.position ? { position: input.position } : {},
+			...input.limit ? { maxResults: input.limit } : {}
+		}, signal);
+		if (result.status === "unsupported" || result.status === "unavailable" || result.status === "stale" || result.status === "timeout" || result.status === "cancelled" || result.status === "limit_exceeded") return responseFor(result.status, `semantic_${result.status}`, metadata);
+		const value = result.result;
+		if (input.kind === "hover") {
+			if (!isRecord(value) || value.kind !== "hover") return outcome("unavailable", "semantic_result_invalid");
+			const hover = value.hover;
+			if (hover === null) return responseFor(result.status, void 0, metadata, { hover: null });
+			if (!isRecord(hover) || typeof hover.contents !== "string") return outcome("unavailable", "semantic_result_invalid");
+			const contents = trimUtf16(hover.contents, 16e3);
+			const truncated = contents !== hover.contents;
+			return responseFor(result.status, void 0, metadata, { hover: {
+				contents,
+				...hover.range ? { range: hover.range } : {}
+			} }, truncated, truncated ? hover.contents.length - contents.length : 0);
+		}
+		if (input.kind === "completion") {
+			if (!isRecord(value) || !Array.isArray(value.items)) return outcome("unavailable", "semantic_result_invalid");
+			let truncated = Boolean(result.truncated);
+			const items = value.items.map((item) => ({
+				label: typeof item.label === "string" ? item.label.slice(0, 1e3) : "",
+				...typeof item.detail === "string" ? { detail: item.detail.slice(0, 4e3) } : {},
+				...typeof item.documentation === "string" ? { documentation: item.documentation.slice(0, 8e3) } : {},
+				...Number.isInteger(item.kind) ? { kind: item.kind } : {},
+				...typeof item.insertText === "string" ? { insertText: item.insertText.slice(0, 8e3) } : {}
+			}));
+			if (items.some((item, index) => item.label !== value.items[index]?.label || item.detail !== value.items[index]?.detail || item.documentation !== value.items[index]?.documentation || item.insertText !== value.items[index]?.insertText)) truncated = true;
+			const limit = input.limit ?? 200;
+			const omitted = (result.omitted ?? 0) + Math.max(0, items.length - limit);
+			return responseFor(truncated || omitted ? "partial" : result.status, void 0, metadata, { items: items.slice(0, limit) }, truncated || omitted > 0, omitted);
+		}
+		if (input.kind === "diagnostics") {
+			if (!isRecord(value) || !Array.isArray(value.diagnostics)) return outcome("unavailable", "semantic_result_invalid");
+			if (value.skipped) return responseFor("unsupported", "unsupported_file_type", metadata);
+			let truncated = Boolean(result.truncated);
+			const items = value.diagnostics.map((item) => {
+				const message = typeof item.message === "string" ? item.message.slice(0, 8e3) : "";
+				if (message !== item.message) truncated = true;
+				return {
+					uri: item.uri,
+					range: item.range,
+					message,
+					...Number.isInteger(item.severity) ? { severity: item.severity } : {}
+				};
+			});
+			const limit = input.limit ?? 200;
+			const omitted = (result.omitted ?? 0) + Math.max(0, items.length - limit);
+			return responseFor(truncated || omitted || result.status === "partial" ? "partial" : result.status, void 0, metadata, { items: items.slice(0, limit) }, truncated || omitted > 0, omitted);
+		}
+		if (!isRecord(value) || value.kind !== "locations" || !Array.isArray(value.locations)) return outcome("unavailable", "semantic_result_invalid");
+		return responseFor(result.status, void 0, metadata, { items: value.locations }, Boolean(result.truncated), result.omitted ?? 0);
+	}
+	async release(handle) {
+		const known = this.snapshots.delete(handle);
+		for (const [node, snapshot] of this.nodes) if (snapshot === handle) this.nodes.delete(node);
+		if (!known) return responseFor("ok", "released", {
+			sourceKind: "disk",
+			freshness: "unknown"
+		}, { released: false });
+		const result = await this.backend.snapshot.release(this.scope, handle);
+		return responseFor("ok", "released", {
+			sourceKind: "disk",
+			freshness: "unknown"
+		}, result);
+	}
+	capabilitiesResponse(capabilities) {
+		return responseFor("ok", "capabilities", {
+			sourceKind: "disk",
+			freshness: "unknown"
+		}, capabilities);
+	}
+	rememberNodes(snapshotHandle, items) {
+		for (const item of items) this.nodes.set(item.handle, snapshotHandle);
+	}
+	account(response) {
+		if (Buffer.byteLength(JSON.stringify(response)) > RESPONSE_BYTES) response = outcome("limit_exceeded", "response_limit");
+		this.outputBytes += Buffer.byteLength(JSON.stringify(response));
+		if (this.outputBytes > MAX_OUTPUT_BYTES) return outcome("limit_exceeded", "response_budget");
+		return response;
+	}
+	dispose() {
+		if (this.disposal) return this.disposal;
+		this.disposed = true;
+		this.lifetime.abort();
+		this.snapshots.clear();
+		this.nodes.clear();
+		this.onDispose();
+		this.disposal = Promise.resolve(this.backend.releaseOwner?.(this.scope)).then(() => void 0, () => void 0);
+		return this.disposal;
+	}
+};
+function outcome(status, reason) {
+	return {
+		protocol: "code-intelligence/v1",
+		status,
+		reason,
+		sourceKind: "disk",
+		freshness: status === "stale" ? "stale" : "unknown",
+		truncated: false,
+		omitted: 0
+	};
+}
+function responseFor(status, reason, metadata, data, truncated = false, omitted = 0) {
+	const successful = status === "ok" || status === "partial";
+	return {
+		protocol: "code-intelligence/v1",
+		status,
+		...reason ? { reason } : {},
+		sourceKind: "disk",
+		freshness: metadata.freshness,
+		...metadata.snapshotVersion ? { snapshotVersion: metadata.snapshotVersion } : {},
+		truncated,
+		omitted,
+		...successful && data !== void 0 ? { data } : {}
+	};
+}
+function boundResponse(response) {
+	if (Buffer.byteLength(JSON.stringify(response), "utf8") <= RESPONSE_BYTES) return response;
+	if (isRecord(response.data) && Array.isArray(response.data.items)) {
+		const items = [...response.data.items];
+		let omitted = response.omitted;
+		while (items.length && Buffer.byteLength(JSON.stringify({
+			...response,
+			data: {
+				...response.data,
+				items
+			}
+		}), "utf8") > RESPONSE_BYTES) {
+			items.pop();
+			omitted++;
+		}
+		const shortened = {
+			...response,
+			status: "partial",
+			reason: response.reason ?? "response_truncated",
+			truncated: true,
+			omitted,
+			data: {
+				...response.data,
+				items
+			}
+		};
+		if (Buffer.byteLength(JSON.stringify(shortened), "utf8") <= RESPONSE_BYTES) return shortened;
+	}
+	return outcome("limit_exceeded", "response_limit");
+}
+function mapError(error) {
+	if (error.code === "LSP_STALE_SNAPSHOT") return outcome("stale", "source_changed");
+	if (error.code === "LSP_STRUCTURE_TIMEOUT") return outcome("timeout", "parser_deadline");
+	if (error.code === "LSP_STRUCTURE_LIMIT" || error.code === "LSP_SNAPSHOT_LIMIT") return outcome("limit_exceeded", "provider_limit");
+	if (error.code === "LSP_STRUCTURE_UNSUPPORTED" || error.code === "LSP_UNSUPPORTED_OPERATION") return outcome("unsupported", "capability_missing");
+	if (error.code === "LSP_STRUCTURE_BUSY") return outcome("unavailable", "parser_busy");
+	if (error.code === "LSP_CODE_INTELLIGENCE_UNAVAILABLE" || error.code === "LSP_STRUCTURE_UNAVAILABLE" || error.code === "LSP_UNAVAILABLE") return outcome("unavailable", "provider_unavailable");
+	if (error.code === "LSP_WORKSPACE_REQUIRED") return outcome("unavailable", "invalid_path");
+	return outcome("unavailable", "provider_operation_failed");
+}
+function projectNode(node) {
+	return {
+		handle: node.handle,
+		kind: node.kind,
+		range: node.range,
+		...node.name ? { name: node.name } : {}
+	};
+}
+function trimUtf16(value, limit) {
+	if (value.length <= limit) return value;
+	const end = value.charCodeAt(limit - 1) >= 55296 && value.charCodeAt(limit - 1) <= 56319 ? limit - 1 : limit;
+	return value.slice(0, end);
+}
+function validCodeRequest(value) {
+	if (!isRecord(value) || typeof value.method !== "string") return false;
+	const allowed = {
+		capabilities: ["method"],
+		"snapshot.open": ["method", "path"],
+		"snapshot.release": ["method", "handle"],
+		"structure.outline": [
+			"method",
+			"handle",
+			"range",
+			"limit"
+		],
+		"structure.enclosing": [
+			"method",
+			"handle",
+			"position",
+			"kinds"
+		],
+		"structure.query": [
+			"method",
+			"handle",
+			"queryId",
+			"range",
+			"limit"
+		],
+		"structure.span": [
+			"method",
+			"nodeHandle",
+			"maxChars"
+		],
+		"semantic.query": [
+			"method",
+			"handle",
+			"kind",
+			"position",
+			"limit"
+		]
+	}[value.method];
+	if (!allowed || Object.keys(value).some((key) => !allowed.includes(key))) return false;
+	const handle = "handle" in value ? value.handle : "nodeHandle" in value ? value.nodeHandle : void 0;
+	if (handle !== void 0 && (typeof handle !== "string" || !handle.length || handle.length > 256)) return false;
+	if (value.method === "snapshot.open") return typeof value.path === "string" && value.path.length > 0 && value.path.length <= 4096;
+	if (value.method === "capabilities" || value.method === "snapshot.release") return true;
+	if ("limit" in value && value.limit !== void 0 && (!Number.isSafeInteger(value.limit) || value.limit < 1 || value.limit > 200)) return false;
+	if ("range" in value && value.range !== void 0 && !validRange(value.range)) return false;
+	if (value.method === "structure.outline") return value.limit === void 0 || value.limit <= 100;
+	if (value.method === "structure.enclosing") return validPosition(value.position) && (value.kinds === void 0 || Array.isArray(value.kinds) && value.kinds.length <= 30 && value.kinds.every((kind) => typeof kind === "string" && kind.length <= 100));
+	if (value.method === "structure.query") return [
+		"declarations",
+		"calls",
+		"imports"
+	].includes(String(value.queryId));
+	if (value.method === "structure.span") return value.maxChars === void 0 || Number.isSafeInteger(value.maxChars) && value.maxChars >= 1 && value.maxChars <= 8e3;
+	if (value.method === "semantic.query") return [
+		"definition",
+		"references",
+		"implementation",
+		"hover",
+		"diagnostics",
+		"completion"
+	].includes(String(value.kind)) && (value.kind === "diagnostics" || validPosition(value.position));
+	return false;
+}
+function validRange(value) {
+	if (!isRecord(value) || !validPosition(value.start) || !validPosition(value.end)) return false;
+	return value.end.line > value.start.line || value.end.line === value.start.line && value.end.character >= value.start.character;
+}
+function validPosition(value) {
+	return isRecord(value) && Number.isSafeInteger(value.line) && Number.isSafeInteger(value.character) && value.line >= 0 && value.character >= 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function identity(value) {
+	return value && typeof value === "object" ? value[symbols.original] ?? value : value;
+}
+function validateBinding(binding) {
+	if (!binding || !binding.owner || typeof binding.owner.agentId !== "string" || typeof binding.owner.sessionId !== "string" || typeof binding.workspaceRoot !== "string" || !isAbsolute(binding.workspaceRoot) || !binding.scope || typeof binding.assertCurrent !== "function" || !binding.context || typeof binding.context.get !== "function") throw new WebstackLspError("LSP_CODE_INTELLIGENCE_UNAVAILABLE", "invalid trusted code host binding");
+}
+
 //#endregion
 //#region src/runtime/webstack-runtime.ts
 const methods = {
@@ -862,6 +1311,10 @@ const clientCapabilities = {
 };
 var WebstackLspRuntime = class {
 	pool;
+	snapshots;
+	codeIntelligence;
+	codeIntelligenceRuntime;
+	semanticOperations = /* @__PURE__ */ new Map();
 	workspaces = /* @__PURE__ */ new Map();
 	lifetime = new AbortController();
 	live = /* @__PURE__ */ new Map();
@@ -871,6 +1324,17 @@ var WebstackLspRuntime = class {
 		this.config = config;
 		this.fs = fs;
 		this.subprocess = subprocess;
+		this.snapshots = new DocumentSnapshotStore((workspaceRoot, filePath, maxBytes, signal) => readSource(this.fs, workspaceRoot, filePath, maxBytes, signal), config.limits.maxDocumentBytes);
+		this.codeIntelligenceRuntime = createCodeIntelligenceToolServiceV1({
+			snapshots: this.snapshots,
+			semanticQuery: (scope, snapshot, request, signal) => this.semanticFromSnapshot(scope, snapshot, request, signal)
+		});
+		this.codeIntelligence = new CodeIntelligenceProtocolService({
+			backend: this.codeIntelligenceRuntime,
+			fs: this.fs,
+			subprocess: this.subprocess,
+			capabilities: (signal) => this.codeCapabilities(signal)
+		});
 		this.pool = new ServerPool(async (rawId, key, signal) => {
 			const id = rawId, source = this.workspaces.get(key);
 			const spec = await resolveLaunch(id, config, source.workspace);
@@ -921,6 +1385,9 @@ var WebstackLspRuntime = class {
 	async navigation(request, signal) {
 		const deadline = this.signal(request.operation === "hover" ? this.config.timeouts.primaryHoverMs : this.config.timeouts.navigationMs, signal);
 		const [source, route] = await this.prepare(request, deadline);
+		return this.navigationFromSource(request, source, route, deadline, signal);
+	}
+	async navigationFromSource(request, source, route, deadline, signal) {
 		this.validatePosition(source.text, request.position);
 		const result = await this.document(route.primary.server, source, route.primary.languageId, deadline, async (session, connection) => {
 			if (!supportsOperation(session.capabilities, request.operation)) throw new WebstackLspError("LSP_UNSUPPORTED_OPERATION", `${route.primary.server} does not support ${request.operation}`);
@@ -969,6 +1436,9 @@ var WebstackLspRuntime = class {
 	async completion(request, signal) {
 		const deadline = this.signal(this.config.timeouts.completionMs, signal);
 		const [source, route] = await this.prepare(request, deadline);
+		return this.completionFromSource(request, source, route, deadline, signal);
+	}
+	async completionFromSource(request, source, route, deadline, signal) {
 		this.validatePosition(source.text, request.position);
 		const query = (id, language) => this.document(id, source, language, deadline, (session, connection) => {
 			if (!session.capabilities.completionProvider) throw new WebstackLspError("LSP_UNSUPPORTED_OPERATION", `${id} does not support completion`);
@@ -1000,7 +1470,7 @@ var WebstackLspRuntime = class {
 	async diagnostics(request, signal) {
 		const deadline = this.signal(this.config.timeouts.diagnosticsMs, signal);
 		if (!classifyFile(request.filePath, this.config.routing.bladeSuffixes)) {
-			await readSource(this.fs, request.workspaceRoot, request.filePath, this.config.limits.maxDocumentBytes, deadline);
+			await this.snapshots.readFresh(providerScope(request.workspaceRoot), request.filePath, deadline);
 			return {
 				diagnostics: [],
 				skipped: {
@@ -1010,6 +1480,9 @@ var WebstackLspRuntime = class {
 			};
 		}
 		const [source, route] = await this.prepare(request, deadline);
+		return this.diagnosticsFromSource(request, source, route, deadline, signal);
+	}
+	async diagnosticsFromSource(request, source, route, deadline, signal) {
 		const selected = [route.primary, ...route.auxiliary && this.config.tailwind.enabled ? [route.auxiliary] : []].filter((item) => this.config.servers[item.server].enabled && (!request.servers || request.servers.includes(item.server)));
 		if (!selected.length) throw new WebstackLspError("LSP_UNAVAILABLE", "no selected diagnostic server supports this file");
 		const omittedServers = [];
@@ -1021,10 +1494,10 @@ var WebstackLspRuntime = class {
 						return (await connection.request("textDocument/diagnostic", { textDocument: { uri: source.uri } }, deadline))?.items ?? [];
 					}
 					let remove = () => {};
-					const published = new Promise((resolve) => {
+					const published = new Promise((resolve$1) => {
 						remove = connection.onNotification((message) => {
 							const p = message.params;
-							if (message.method === "textDocument/publishDiagnostics" && p?.uri === source.uri && (p.version === void 0 || p.version === 1)) resolve(p.diagnostics);
+							if (message.method === "textDocument/publishDiagnostics" && p?.uri === source.uri && (p.version === void 0 || p.version === 1)) resolve$1(p.diagnostics);
 						});
 					});
 					try {
@@ -1051,7 +1524,62 @@ var WebstackLspRuntime = class {
 			...omittedServers.length ? { omittedServers: omittedServers.sort() } : {}
 		};
 	}
-	async status() {
+	async semanticFromSnapshot(scope, snapshot, request, signal) {
+		const source = snapshot.source;
+		this.rememberWorkspace(source);
+		const file = classifyFile(snapshot.descriptor.filePath, this.config.routing.bladeSuffixes);
+		if (!file) {
+			if (request.operation === "diagnostics") return {
+				diagnostics: [],
+				skipped: {
+					reason: "unsupported_file_type",
+					filePath: snapshot.descriptor.filePath
+				}
+			};
+			throw new WebstackLspError("LSP_UNAVAILABLE", "unsupported file extension");
+		}
+		const route = routeFor(file);
+		let result;
+		if (request.operation === "diagnostics") {
+			const deadline = this.signal(this.config.timeouts.diagnosticsMs, signal);
+			result = await this.diagnosticsFromSource({
+				workspaceRoot: scope.workspaceRoot,
+				filePath: snapshot.descriptor.filePath,
+				...request.severity ? { severity: request.severity } : {},
+				...request.servers ? { servers: request.servers } : {}
+			}, source, route, deadline, signal);
+		} else if (request.operation === "completion") {
+			const deadline = this.signal(this.config.timeouts.completionMs, signal);
+			result = await this.completionFromSource({
+				workspaceRoot: scope.workspaceRoot,
+				filePath: snapshot.descriptor.filePath,
+				position: request.position
+			}, source, route, deadline, signal);
+		} else {
+			const operation = {
+				definition: "goToDefinition",
+				references: "findReferences",
+				implementation: "goToImplementation",
+				hover: "hover"
+			}[request.operation];
+			const position = request.position;
+			const deadline = this.signal(request.operation === "hover" ? this.config.timeouts.primaryHoverMs : this.config.timeouts.navigationMs, signal);
+			result = await this.navigationFromSource({
+				workspaceRoot: scope.workspaceRoot,
+				filePath: snapshot.descriptor.filePath,
+				languageId: route.primary.languageId,
+				operation,
+				position
+			}, source, route, deadline, signal);
+		}
+		if (!("skipped" in result && result.skipped)) {
+			const operations = this.semanticOperations.get(route.primary.languageId) ?? /* @__PURE__ */ new Set();
+			operations.add(request.operation);
+			this.semanticOperations.set(route.primary.languageId, operations);
+		}
+		return result;
+	}
+	async status(signal) {
 		return {
 			providerId: this.config.providerId,
 			supportedFileSuffixes: supportedFileSuffixes(this.config.routing.bladeSuffixes),
@@ -1060,7 +1588,7 @@ var WebstackLspRuntime = class {
 				let available = false;
 				try {
 					const launch = await resolveLaunch(id, this.config, ".");
-					await this.subprocess.resolveExecutable(launch.command, launch.env, this.signal(5e3));
+					await this.subprocess.resolveExecutable(launch.command, launch.env, this.signal(5e3, signal));
 					available = true;
 				} catch {}
 				return {
@@ -1074,11 +1602,69 @@ var WebstackLspRuntime = class {
 			}))
 		};
 	}
+	async codeCapabilities(signal) {
+		signal.throwIfAborted();
+		const [provider, lsp] = await Promise.all([Promise.resolve(this.codeIntelligenceRuntime.capabilities()), this.status(signal)]);
+		const server = lsp.servers.find((item) => item.id === "typescript");
+		const languageCapabilities = provider.parsers.map((parser) => {
+			const semanticIds = parser.language === "javascript" ? ["javascript", "javascriptreact"] : parser.language === "tsx" ? ["typescriptreact"] : ["typescript"];
+			const semantic = [...new Set(semanticIds.flatMap((id) => [...this.semanticOperations.get(id) ?? []]))];
+			const semanticReady = semantic.length > 0 && Boolean(server?.enabled && server.available);
+			const reason = !parser.available ? "grammar_unavailable" : !server?.enabled || !server.available ? "server_unavailable" : !semanticReady ? "not_yet_verified" : void 0;
+			return {
+				language: parser.language,
+				structure: parser.available,
+				semantic,
+				semanticReady,
+				...reason ? { reason } : {}
+			};
+		});
+		signal.throwIfAborted();
+		return {
+			version: 1,
+			capabilities: [
+				"snapshots",
+				"structure",
+				"semantic"
+			],
+			languages: provider.parsers.filter((parser) => parser.available).map((parser) => parser.language),
+			queryIds: [
+				"declarations",
+				"calls",
+				"imports"
+			],
+			semanticReady: languageCapabilities.some((language) => language.semanticReady),
+			sourceKinds: ["disk"],
+			languageCapabilities,
+			limits: {
+				documentBytes: provider.limits.maxDocumentBytes,
+				captureItems: provider.limits.maxCaptures,
+				outlineItems: provider.limits.maxOutline,
+				spanChars: provider.limits.maxSpanChars,
+				responseBytes: provider.limits.maxResponseBytes,
+				files: 100,
+				inputBytes: 16777216,
+				outputBytes: 65536,
+				calls: 100,
+				batchMs: 3e4,
+				structureMs: 2e3,
+				semanticMs: 1e4
+			}
+		};
+	}
 	async dispose() {
 		this.lifetime.abort();
-		await this.pool.disposeAll();
-		this.workspaces.clear();
-		this.live.clear();
+		try {
+			await this.codeIntelligence.dispose?.();
+		} finally {
+			try {
+				await this.pool.disposeAll();
+			} finally {
+				await this.codeIntelligenceRuntime.dispose?.();
+				this.workspaces.clear();
+				this.live.clear();
+			}
+		}
 	}
 	signal(ms, signal) {
 		return AbortSignal.any([
@@ -1091,15 +1677,18 @@ var WebstackLspRuntime = class {
 		throwIfAborted(signal);
 		const file = classifyFile(request.filePath, this.config.routing.bladeSuffixes);
 		if (!file) throw new WebstackLspError("LSP_UNAVAILABLE", "unsupported file extension");
-		const source = await readSource(this.fs, request.workspaceRoot, request.filePath, this.config.limits.maxDocumentBytes, signal).catch((error) => {
+		const source = await this.snapshots.readFresh(providerScope(request.workspaceRoot), request.filePath, signal).catch((error) => {
 			throwIfAborted(signal);
 			throw error;
 		});
+		this.rememberWorkspace(source);
+		return [source, routeFor(file)];
+	}
+	rememberWorkspace(source) {
 		this.workspaces.set(source.key, {
 			...source,
 			text: ""
 		});
-		return [source, routeFor(file)];
 	}
 	validatePosition(text, position) {
 		const line = text.split(/\r?\n/)[position.line];
@@ -1132,6 +1721,13 @@ var WebstackLspRuntime = class {
 		} : void 0);
 	}
 };
+function providerScope(workspaceRoot) {
+	return {
+		ownerId: "lsp-provider",
+		sessionId: "lsp-provider",
+		workspaceRoot
+	};
+}
 
 //#endregion
 //#region src/provider.ts
@@ -1175,6 +1771,8 @@ async function apply(ctx, config = {}) {
 		}
 		yield ctx.lsp.registerProvider(createCompositeProvider(runtime, resolved));
 		yield ctx.provide("webstackLsp", createWebstackLspService(runtime));
+		yield ctx.provide("codeIntelligence", runtime.codeIntelligence);
+		yield ctx.provide("codeIntelligenceRuntime", runtime.codeIntelligenceRuntime);
 	}, "webstack LSP provider");
 }