@soda-gql/lsp 0.14.1 → 0.14.2

package/dist/{server-CqOUHwDk.mjs → server-wPCHK04O.mjs}

@@ -1,19 +1,154 @@
 import { createRequire } from "node:module";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { createSwcSpanConverter } from "@soda-gql/common";
-import { formatTemplatesInSource, walkAndExtract } from "@soda-gql/common/template-extraction";
-import { TypeInfo, buildASTSchema, concatAST, getNamedType, isTypeDefinitionNode, parse, print, visit, visitWithTypeInfo } from "graphql";
 import { readFileSync } from "node:fs";
 import { dirname, resolve, sep } from "node:path";
-import { hashSchema } from "@soda-gql/tools/codegen";
-import { err, ok } from "neverthrow";
+import { createGraphqlSystemIdentifyHelper } from "@soda-gql/builder";
 import { findAllConfigFiles, findConfigFile, loadConfig } from "@soda-gql/config";
+import { GraphQLUnionType, Kind, TypeInfo, buildASTSchema, concatAST, getNamedType, isObjectType, isTypeDefinitionNode, parse, print, visit, visitWithTypeInfo } from "graphql";
+import { getAutocompleteSuggestions, getContextAtPosition, getDefinitionQueryResultForField, getDefinitionQueryResultForFragmentSpread, getDefinitionQueryResultForNamedType, getDiagnostics, getHoverInformation, getOutline } from "graphql-language-service";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createSwcSpanConverter } from "@soda-gql/common";
+import { formatTemplatesInSource, walkAndExtract, walkAndExtractFieldTrees } from "@soda-gql/common/template-extraction";
+import { err, ok } from "neverthrow";
+import { hashSchema } from "@soda-gql/tools/codegen";
 import { DidChangeWatchedFilesNotification, FileChangeType, ProposedFeatures, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { createGraphqlSystemIdentifyHelper } from "@soda-gql/builder";
 import ts from "typescript";
-import { getAutocompleteSuggestions, getContextAtPosition, getDefinitionQueryResultForField, getDefinitionQueryResultForFragmentSpread, getDiagnostics, getHoverInformation, getOutline } from "graphql-language-service";
 
+//#region packages/lsp/src/field-tree-resolver.ts
+/** Get the root type name for an operation kind from the schema. */
+const getRootTypeName = (schema, kind) => {
+	switch (kind) {
+		case "query": return schema.getQueryType()?.name ?? null;
+		case "mutation": return schema.getMutationType()?.name ?? null;
+		case "subscription": return schema.getSubscriptionType()?.name ?? null;
+		default: return null;
+	}
+};
+/** Classify a GraphQL named type into a kind string. */
+const classifyType = (namedType) => {
+	if (isObjectType(namedType)) return "object";
+	if (namedType instanceof GraphQLUnionType) return "union";
+	if ("getValues" in namedType) return "enum";
+	return "scalar";
+};
+/** Resolve a single field from a parent object type. */
+const resolveField = (schema, parentTypeName, fieldName) => {
+	const parentType = schema.getType(parentTypeName);
+	if (!parentType || !isObjectType(parentType)) return null;
+	const fields = parentType.getFields();
+	const fieldDef = fields[fieldName];
+	if (!fieldDef) return null;
+	const namedType = getNamedType(fieldDef.type);
+	if (!namedType) return null;
+	return {
+		fieldDef,
+		namedType
+	};
+};
+/** Resolve untyped FieldCallNode children into typed nodes. */
+const resolveChildren = (schema, parentTypeName, children) => {
+	return children.map((child) => resolveNode(schema, parentTypeName, child));
+};
+/** Resolve a single FieldCallNode into a TypedFieldNode. */
+const resolveNode = (schema, parentTypeName, node) => {
+	const resolved = resolveField(schema, parentTypeName, node.fieldName);
+	const fieldTypeName = resolved?.namedType.name ?? null;
+	const fieldTypeKind = resolved ? classifyType(resolved.namedType) : null;
+	let nested = null;
+	if (node.nested) {
+		if (node.nested.kind === "object" && fieldTypeName) {
+			nested = {
+				kind: "object",
+				span: node.nested.span,
+				children: resolveChildren(schema, fieldTypeName, node.nested.children)
+			};
+		} else if (node.nested.kind === "union") {
+			nested = resolveUnionNested(schema, resolved?.namedType ?? null, node.nested);
+		}
+	}
+	return {
+		fieldName: node.fieldName,
+		fieldNameSpan: node.fieldNameSpan,
+		callSpan: node.callSpan,
+		parentTypeName,
+		fieldTypeName,
+		fieldTypeKind,
+		nested
+	};
+};
+/** Resolve union branches against a union type. */
+const resolveUnionNested = (schema, unionType, nested) => {
+	const memberNames = new Set();
+	if (unionType instanceof GraphQLUnionType) {
+		for (const member of unionType.getTypes()) {
+			memberNames.add(member.name);
+		}
+	}
+	const branches = nested.branches.map((branch) => ({
+		typeName: branch.typeName,
+		typeNameSpan: branch.typeNameSpan,
+		branchSpan: branch.branchSpan,
+		valid: memberNames.has(branch.typeName),
+		children: resolveChildren(schema, branch.typeName, branch.children)
+	}));
+	return {
+		kind: "union",
+		span: nested.span,
+		branches
+	};
+};
+/**
+* Resolve an ExtractedFieldTree against a GraphQL schema.
+* Returns null if the operation kind has no corresponding root type.
+*/
+const resolveFieldTree = (tree, schema) => {
+	const rootTypeName = getRootTypeName(schema, tree.kind);
+	if (!rootTypeName) return null;
+	return {
+		schemaName: tree.schemaName,
+		rootTypeName,
+		rootSpan: tree.rootSpan,
+		children: resolveChildren(schema, rootTypeName, tree.children)
+	};
+};
+/**
+* Find the TypedFieldNode or TypedUnionBranch at a given offset.
+* Searches fieldNameSpan for field matches and typeNameSpan for union member matches.
+*/
+const findNodeAtOffset = (tree, offset) => {
+	return findInChildren(tree.children, offset, null);
+};
+const findInChildren = (children, offset, _parentForUnion) => {
+	for (const node of children) {
+		if (offset >= node.fieldNameSpan.start && offset <= node.fieldNameSpan.end) {
+			return {
+				kind: "field",
+				node
+			};
+		}
+		if (node.nested) {
+			if (node.nested.kind === "object") {
+				const result = findInChildren(node.nested.children, offset, null);
+				if (result) return result;
+			} else if (node.nested.kind === "union") {
+				for (const branch of node.nested.branches) {
+					if (offset >= branch.typeNameSpan.start && offset <= branch.typeNameSpan.end) {
+						return {
+							kind: "unionMember",
+							branch,
+							parentNode: node
+						};
+					}
+					const result = findInChildren(branch.children, offset, node);
+					if (result) return result;
+				}
+			}
+		}
+	}
+	return null;
+};
+
+//#endregion
 //#region packages/lsp/src/fragment-args-preprocessor.ts
 /**
 * Find the matching closing parenthesis for a balanced group.
@@ -171,9 +306,17 @@ const collectGqlIdentifiers = (module, filePath, helper) => {
 /**
 * Reconstruct full GraphQL source from an extracted template.
 * Prepends the definition header from curried tag call arguments.
+*
+* For callback-variables templates (source === "callback-variables"), wraps the
+* partial variables string in a dummy operation to produce valid GraphQL that
+* graphql-language-service can parse.
 */
 const reconstructGraphql = (template) => {
 	const content = template.content;
+	if (template.source === "callback-variables") {
+		const name = template.elementName ?? "__variables__";
+		return `${template.kind} ${name} ${content} { __typename }`;
+	}
 	if (template.elementName) {
 		if (template.kind === "fragment" && template.typeName) {
 			return `fragment ${template.elementName} on ${template.typeName} ${content}`;
@@ -182,6 +325,21 @@ const reconstructGraphql = (template) => {
 	}
 	return content;
 };
+/**
+* Compute the length of the synthesized prefix before the template content
+* in the reconstructed GraphQL string.
+*
+* For tagged templates, headerLen = reconstructed.length - content.length (content is at the end).
+* For callback-variables, content is in the MIDDLE (prefix + content + suffix), so we must
+* compute the prefix length explicitly.
+*/
+const computeHeaderLen = (template, reconstructed) => {
+	if (template.source === "callback-variables") {
+		const name = template.elementName ?? "__variables__";
+		return `${template.kind} ${name} `.length;
+	}
+	return reconstructed.length - template.content.length;
+};
 const indexFragments = (uri, templates, source) => {
 	const fragments = [];
 	for (const template of templates) {
@@ -189,7 +347,7 @@ const indexFragments = (uri, templates, source) => {
 			continue;
 		}
 		const reconstructed = reconstructGraphql(template);
-		const headerLen = reconstructed.length - template.content.length;
+		const headerLen = computeHeaderLen(template, reconstructed);
 		const { preprocessed } = preprocessFragmentArgs(reconstructed);
 		try {
 			const ast = parse(preprocessed, { noLocation: false });
@@ -263,33 +421,45 @@ const createDocumentManager = (helper, swcOptions) => {
 	};
 	const cache = new Map();
 	const fragmentIndex = new Map();
-	const extractTemplates = (uri, source) => {
+	const extractAll = (uri, source) => {
 		const isTsx = uri.endsWith(".tsx");
 		const program = safeParseSync(source, isTsx);
 		if (!program) {
-			return [];
+			return {
+				templates: [],
+				fieldTrees: []
+			};
 		}
 		const converter = createSwcSpanConverter(source);
 		const spanOffset = program.span.end - converter.byteLength + 1;
 		const filePath = uri.startsWith("file://") ? fileURLToPath(uri) : uri;
 		const gqlIdentifiers = collectGqlIdentifiers(program, filePath, helper);
 		if (gqlIdentifiers.size === 0) {
-			return [];
+			return {
+				templates: [],
+				fieldTrees: []
+			};
 		}
 		const positionCtx = {
 			spanOffset,
 			converter
 		};
-		return walkAndExtract(program, gqlIdentifiers, positionCtx);
+		const templates = walkAndExtract(program, gqlIdentifiers, positionCtx);
+		const fieldTrees = walkAndExtractFieldTrees(program, gqlIdentifiers, positionCtx);
+		return {
+			templates,
+			fieldTrees
+		};
 	};
 	return {
 		update: (uri, version, source) => {
-			const templates = extractTemplates(uri, source);
+			const { templates, fieldTrees } = extractAll(uri, source);
 			const state = {
 				uri,
 				version,
 				source,
 				templates,
+				fieldTrees,
 				...swcUnavailable ? { swcUnavailable: true } : {}
 			};
 			cache.set(uri, state);
@@ -312,6 +482,20 @@ const createDocumentManager = (helper, swcOptions) => {
 			}
 			return state.templates.find((t) => offset >= t.contentRange.start && offset <= t.contentRange.end);
 		},
+		findFieldTreeAtOffset: (uri, offset) => {
+			const state = cache.get(uri);
+			if (!state) {
+				return undefined;
+			}
+			return state.fieldTrees.find((t) => offset >= t.rootSpan.start && offset <= t.rootSpan.end);
+		},
+		findTemplateByTypeNameOffset: (uri, offset) => {
+			const state = cache.get(uri);
+			if (!state) {
+				return undefined;
+			}
+			return state.templates.find((t) => t.typeNameSpan && offset >= t.typeNameSpan.start && offset <= t.typeNameSpan.end);
+		},
 		getExternalFragments: (uri, schemaName) => {
 			const result = [];
 			for (const [fragmentUri, fragments] of fragmentIndex) {
@@ -345,7 +529,7 @@ const createDocumentManager = (helper, swcOptions) => {
 						continue;
 					}
 					const reconstructed = reconstructGraphql(template);
-					const headerLen = reconstructed.length - template.content.length;
+					const headerLen = computeHeaderLen(template, reconstructed);
 					const { preprocessed } = preprocessFragmentArgs(reconstructed);
 					try {
 						const ast = parse(preprocessed, { noLocation: false });
@@ -380,50 +564,6 @@ const createDocumentManager = (helper, swcOptions) => {
 	};
 };
 
-//#endregion
-//#region packages/lsp/src/errors.ts
-/** Error constructor helpers for concise error creation. */
-const lspErrors = {
-	configLoadFailed: (message, cause) => ({
-		code: "CONFIG_LOAD_FAILED",
-		message,
-		cause
-	}),
-	schemaLoadFailed: (schemaName, message, cause) => ({
-		code: "SCHEMA_LOAD_FAILED",
-		message: message ?? `Failed to load schema: ${schemaName}`,
-		schemaName,
-		cause
-	}),
-	schemaBuildFailed: (schemaName, message, cause) => ({
-		code: "SCHEMA_BUILD_FAILED",
-		message: message ?? `Failed to build schema: ${schemaName}`,
-		schemaName,
-		cause
-	}),
-	schemaNotConfigured: (schemaName) => ({
-		code: "SCHEMA_NOT_CONFIGURED",
-		message: `Schema "${schemaName}" is not configured in soda-gql.config`,
-		schemaName
-	}),
-	parseFailed: (uri, message, cause) => ({
-		code: "PARSE_FAILED",
-		message: message ?? `Failed to parse: ${uri}`,
-		uri,
-		cause
-	}),
-	internalInvariant: (message, context, cause) => ({
-		code: "INTERNAL_INVARIANT",
-		message,
-		context,
-		cause
-	}),
-	swcResolutionFailed: (message) => ({
-		code: "SWC_RESOLUTION_FAILED",
-		message: message ?? "@swc/core not found. Install @soda-gql/builder (which provides @swc/core) in your project and restart the LSP server to enable template extraction."
-	})
-};
-
 //#endregion
 //#region packages/lsp/src/position-mapping.ts
 /** Compute byte offsets for the start of each line in the source text. */
@@ -501,164 +641,67 @@ const createPositionMapper = (input) => {
 };
 
 //#endregion
-//#region packages/lsp/src/schema-resolver.ts
-/**
-* Schema resolver: maps schema names to GraphQLSchema objects.
-* @module
-*/
-/** Wrap buildASTSchema (which throws) in a Result. */
-const safeBuildASTSchema = (schemaName, documentNode) => {
-	try {
-		return ok(buildASTSchema(documentNode));
-	} catch (e) {
-		return err(lspErrors.schemaBuildFailed(schemaName, e instanceof Error ? e.message : String(e), e));
-	}
-};
-const loadAndBuildSchema = (schemaName, schemaPaths) => {
-	const documents = [];
-	const files = [];
-	for (const schemaPath of schemaPaths) {
-		const resolvedPath = resolve(schemaPath);
-		try {
-			const content = readFileSync(resolvedPath, "utf8");
-			documents.push(parse(content));
-			files.push({
-				filePath: resolvedPath,
-				content
-			});
-		} catch (e) {
-			return err(lspErrors.schemaLoadFailed(schemaName, e instanceof Error ? e.message : String(e)));
-		}
-	}
-	const documentNode = concatAST(documents);
-	const hash = hashSchema(documentNode);
-	const buildResult = safeBuildASTSchema(schemaName, documentNode);
-	if (buildResult.isErr()) {
-		return err(buildResult.error);
-	}
-	return ok({
-		name: schemaName,
-		schema: buildResult.value,
-		documentNode,
-		hash,
-		files
+//#region packages/lsp/src/handlers/diagnostics.ts
+/** Compute LSP diagnostics for a single GraphQL template. */
+const computeTemplateDiagnostics = (input) => {
+	const { template, schema, tsSource } = input;
+	const reconstructed = reconstructGraphql(template);
+	const headerLen = computeHeaderLen(template, reconstructed);
+	const { preprocessed } = preprocessFragmentArgs(reconstructed);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
 	});
-};
-/** Create a schema resolver from config. Loads all schemas eagerly. */
-const createSchemaResolver = (config) => {
-	const cache = new Map();
-	for (const [name, schemaConfig] of Object.entries(config.schemas)) {
-		const result = loadAndBuildSchema(name, schemaConfig.schema);
-		if (result.isErr()) {
-			return err(result.error);
+	const gqlDiagnostics = getDiagnostics(preprocessed, schema, undefined, undefined, input.externalFragments);
+	const placeholderPattern = /__FRAG_SPREAD_\d+__/;
+	const isCallbackVariables = template.source === "callback-variables";
+	const reconstructedLineOffsets = computeLineOffsets(preprocessed);
+	const contentLineOffsets = computeLineOffsets(template.content);
+	const toContentPosition = (pos) => {
+		const offset = positionToOffset$1(reconstructedLineOffsets, pos);
+		const contentOffset = Math.max(0, offset - headerLen);
+		return offsetToPosition(contentLineOffsets, contentOffset);
+	};
+	return gqlDiagnostics.filter((diag) => {
+		if (placeholderPattern.test(diag.message)) {
+			return false;
 		}
-		cache.set(name, result.value);
-	}
-	const resolver = {
-		getSchema: (schemaName) => cache.get(schemaName),
-		getSchemaNames: () => [...cache.keys()],
-		reloadSchema: (schemaName) => {
-			const schemaConfig = config.schemas[schemaName];
-			if (!schemaConfig) {
-				return err(lspErrors.schemaNotConfigured(schemaName));
-			}
-			const result = loadAndBuildSchema(schemaName, schemaConfig.schema);
-			if (result.isErr()) {
-				return err(result.error);
-			}
-			cache.set(schemaName, result.value);
-			return ok(result.value);
-		},
-		reloadAll: () => {
-			const errors = [];
-			for (const [name, schemaConfig] of Object.entries(config.schemas)) {
-				const result = loadAndBuildSchema(name, schemaConfig.schema);
-				if (result.isErr()) {
-					errors.push(result.error);
-				} else {
-					cache.set(name, result.value);
-				}
+		if (isCallbackVariables && diag.message.includes("is never used")) {
+			return false;
+		}
+		const offset = positionToOffset$1(reconstructedLineOffsets, diag.range.start);
+		if (offset < headerLen) {
+			return false;
+		}
+		if (isCallbackVariables) {
+			const contentEnd = headerLen + template.content.length;
+			if (offset >= contentEnd) {
+				return false;
 			}
-			return errors.length > 0 ? err(errors) : ok(undefined);
 		}
-	};
-	return ok(resolver);
-};
-
-//#endregion
-//#region packages/lsp/src/config-registry.ts
-/**
-* Config registry: maps document URIs to their nearest config context.
-* Supports multiple soda-gql configs in a monorepo workspace.
-* @module
-*/
-const createConfigRegistry = (configPaths) => {
-	const sortedPaths = [...configPaths].sort((a, b) => b.length - a.length);
-	const contexts = new Map();
-	for (const configPath of sortedPaths) {
-		const configResult = loadConfig(configPath);
-		if (configResult.isErr()) {
-			return err(lspErrors.configLoadFailed(`Failed to load config ${configPath}: ${configResult.error.message}`, configResult.error));
-		}
-		const config = configResult.value;
-		const helper = createGraphqlSystemIdentifyHelper(config);
-		const resolverResult = createSchemaResolver(config);
-		if (resolverResult.isErr()) {
-			return err(resolverResult.error);
-		}
-		contexts.set(configPath, {
-			configPath,
-			config,
-			helper,
-			schemaResolver: resolverResult.value,
-			documentManager: createDocumentManager(helper, { resolveFrom: configPath })
-		});
-	}
-	const uriCache = new Map();
-	const resolveConfigPath = (dirPath) => {
-		const cached = uriCache.get(dirPath);
-		if (cached !== undefined) {
-			return cached;
-		}
-		for (const configPath of sortedPaths) {
-			const configDir = dirname(configPath);
-			if (dirPath === configDir || dirPath.startsWith(`${configDir}${sep}`)) {
-				uriCache.set(dirPath, configPath);
-				return configPath;
-			}
-		}
-		uriCache.set(dirPath, null);
-		return null;
-	};
-	return ok({
-		resolveForUri: (uri) => {
-			if (!uri.startsWith("file://") && !uri.startsWith("/")) {
-				return undefined;
-			}
-			const filePath = uri.startsWith("file://") ? fileURLToPath(uri) : uri;
-			const dirPath = dirname(filePath);
-			const configPath = resolveConfigPath(dirPath);
-			return configPath ? contexts.get(configPath) : undefined;
-		},
-		getAllContexts: () => [...contexts.values()],
-		reloadSchemas: (configPath) => {
-			const ctx = contexts.get(configPath);
-			if (!ctx) {
-				return err([lspErrors.configLoadFailed(`Config not found: ${configPath}`)]);
-			}
-			return ctx.schemaResolver.reloadAll();
-		},
-		reloadAllSchemas: () => {
-			const errors = [];
-			for (const ctx of contexts.values()) {
-				const result = ctx.schemaResolver.reloadAll();
-				if (result.isErr()) {
-					errors.push(...result.error);
-				}
-			}
-			return errors.length > 0 ? err(errors) : ok(undefined);
-		}
-	});
+		return true;
+	}).map((diag) => {
+		const startContent = toContentPosition(diag.range.start);
+		const endContent = toContentPosition(diag.range.end);
+		const startTs = mapper.graphqlToTs(startContent);
+		const endTs = mapper.graphqlToTs(endContent);
+		return {
+			range: {
+				start: {
+					line: startTs.line,
+					character: startTs.character
+				},
+				end: {
+					line: endTs.line,
+					character: endTs.character
+				}
+			},
+			message: diag.message,
+			severity: diag.severity,
+			source: "soda-gql"
+		};
+	});
 };
 
 //#endregion
@@ -2921,6 +2964,303 @@ var Is;
 	Is$1.typedArray = typedArray;
 })(Is || (Is = {}));
 
+//#endregion
+//#region packages/lsp/src/handlers/field-tree-diagnostics.ts
+/**
+* Diagnostics handler for callback builder field tree nodes.
+* Reports unknown fields and invalid union member types.
+* @module
+*/
+/** Compute LSP diagnostics for a callback builder field tree. */
+const computeFieldTreeDiagnostics = (input) => {
+	const { fieldTree, tsSource } = input;
+	const lineOffsets = computeLineOffsets(tsSource);
+	const diagnostics = [];
+	const walkNodes = (nodes) => {
+		for (const node of nodes) {
+			if (node.fieldTypeName === null) {
+				const start = offsetToPosition(lineOffsets, node.fieldNameSpan.start);
+				const end = offsetToPosition(lineOffsets, node.fieldNameSpan.end);
+				diagnostics.push({
+					range: {
+						start,
+						end
+					},
+					message: `Unknown field "${node.fieldName}" on type "${node.parentTypeName}"`,
+					severity: DiagnosticSeverity.Error,
+					source: "soda-gql"
+				});
+			}
+			if (node.nested) {
+				walkNested(node.nested);
+			}
+		}
+	};
+	const walkNested = (nested) => {
+		if (nested.kind === "object") {
+			walkNodes(nested.children);
+		} else {
+			for (const branch of nested.branches) {
+				if (!branch.valid) {
+					const start = offsetToPosition(lineOffsets, branch.typeNameSpan.start);
+					const end = offsetToPosition(lineOffsets, branch.typeNameSpan.end);
+					diagnostics.push({
+						range: {
+							start,
+							end
+						},
+						message: `Type "${branch.typeName}" is not a member of union type`,
+						severity: DiagnosticSeverity.Error,
+						source: "soda-gql"
+					});
+				}
+				walkNodes(branch.children);
+			}
+		}
+	};
+	walkNodes(fieldTree.children);
+	return diagnostics;
+};
+
+//#endregion
+//#region packages/lsp/src/diagnostics-collector.ts
+/** Collect all diagnostics (template + field tree) for a document state. */
+const collectRawDiagnostics = (state, ctx) => {
+	const templateDiagnostics = state.templates.flatMap((template) => {
+		const entry = ctx.schemaResolver.getSchema(template.schemaName);
+		if (!entry) {
+			return [];
+		}
+		const externalFragments = ctx.documentManager.getExternalFragments(state.uri, template.schemaName).map((f) => f.definition);
+		return [...computeTemplateDiagnostics({
+			template,
+			schema: entry.schema,
+			tsSource: state.source,
+			externalFragments
+		})];
+	});
+	const fieldTreeDiagnostics = state.fieldTrees.flatMap((tree) => {
+		const entry = ctx.schemaResolver.getSchema(tree.schemaName);
+		if (!entry) {
+			return [];
+		}
+		const typedTree = resolveFieldTree(tree, entry.schema);
+		if (!typedTree) {
+			return [];
+		}
+		return [...computeFieldTreeDiagnostics({
+			fieldTree: typedTree,
+			tsSource: state.source
+		})];
+	});
+	return [...templateDiagnostics, ...fieldTreeDiagnostics];
+};
+
+//#endregion
+//#region packages/lsp/src/errors.ts
+/** Error constructor helpers for concise error creation. */
+const lspErrors = {
+	configLoadFailed: (message, cause) => ({
+		code: "CONFIG_LOAD_FAILED",
+		message,
+		cause
+	}),
+	schemaLoadFailed: (schemaName, message, cause) => ({
+		code: "SCHEMA_LOAD_FAILED",
+		message: message ?? `Failed to load schema: ${schemaName}`,
+		schemaName,
+		cause
+	}),
+	schemaBuildFailed: (schemaName, message, cause) => ({
+		code: "SCHEMA_BUILD_FAILED",
+		message: message ?? `Failed to build schema: ${schemaName}`,
+		schemaName,
+		cause
+	}),
+	schemaNotConfigured: (schemaName) => ({
+		code: "SCHEMA_NOT_CONFIGURED",
+		message: `Schema "${schemaName}" is not configured in soda-gql.config`,
+		schemaName
+	}),
+	parseFailed: (uri, message, cause) => ({
+		code: "PARSE_FAILED",
+		message: message ?? `Failed to parse: ${uri}`,
+		uri,
+		cause
+	}),
+	internalInvariant: (message, context, cause) => ({
+		code: "INTERNAL_INVARIANT",
+		message,
+		context,
+		cause
+	}),
+	swcResolutionFailed: (message) => ({
+		code: "SWC_RESOLUTION_FAILED",
+		message: message ?? "@swc/core not found. Install @soda-gql/builder (which provides @swc/core) in your project and restart the LSP server to enable template extraction."
+	})
+};
+
+//#endregion
+//#region packages/lsp/src/schema-resolver.ts
+/**
+* Schema resolver: maps schema names to GraphQLSchema objects.
+* @module
+*/
+/** Wrap buildASTSchema (which throws) in a Result. */
+const safeBuildASTSchema = (schemaName, documentNode) => {
+	try {
+		return ok(buildASTSchema(documentNode));
+	} catch (e) {
+		return err(lspErrors.schemaBuildFailed(schemaName, e instanceof Error ? e.message : String(e), e));
+	}
+};
+const loadAndBuildSchema = (schemaName, schemaPaths) => {
+	const documents = [];
+	const files = [];
+	for (const schemaPath of schemaPaths) {
+		const resolvedPath = resolve(schemaPath);
+		try {
+			const content = readFileSync(resolvedPath, "utf8");
+			documents.push(parse(content));
+			files.push({
+				filePath: resolvedPath,
+				content
+			});
+		} catch (e) {
+			return err(lspErrors.schemaLoadFailed(schemaName, e instanceof Error ? e.message : String(e)));
+		}
+	}
+	const documentNode = concatAST(documents);
+	const hash = hashSchema(documentNode);
+	const buildResult = safeBuildASTSchema(schemaName, documentNode);
+	if (buildResult.isErr()) {
+		return err(buildResult.error);
+	}
+	return ok({
+		name: schemaName,
+		schema: buildResult.value,
+		documentNode,
+		hash,
+		files
+	});
+};
+/** Create a schema resolver from config. Loads all schemas eagerly. */
+const createSchemaResolver = (config) => {
+	const cache = new Map();
+	for (const [name, schemaConfig] of Object.entries(config.schemas)) {
+		const result = loadAndBuildSchema(name, schemaConfig.schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		cache.set(name, result.value);
+	}
+	const resolver = {
+		getSchema: (schemaName) => cache.get(schemaName),
+		getSchemaNames: () => [...cache.keys()],
+		reloadSchema: (schemaName) => {
+			const schemaConfig = config.schemas[schemaName];
+			if (!schemaConfig) {
+				return err(lspErrors.schemaNotConfigured(schemaName));
+			}
+			const result = loadAndBuildSchema(schemaName, schemaConfig.schema);
+			if (result.isErr()) {
+				return err(result.error);
+			}
+			cache.set(schemaName, result.value);
+			return ok(result.value);
+		},
+		reloadAll: () => {
+			const errors = [];
+			for (const [name, schemaConfig] of Object.entries(config.schemas)) {
+				const result = loadAndBuildSchema(name, schemaConfig.schema);
+				if (result.isErr()) {
+					errors.push(result.error);
+				} else {
+					cache.set(name, result.value);
+				}
+			}
+			return errors.length > 0 ? err(errors) : ok(undefined);
+		}
+	};
+	return ok(resolver);
+};
+
+//#endregion
+//#region packages/lsp/src/config-registry.ts
+/**
+* Config registry: maps document URIs to their nearest config context.
+* Supports multiple soda-gql configs in a monorepo workspace.
+* @module
+*/
+const createConfigRegistry = (configPaths) => {
+	const sortedPaths = [...configPaths].sort((a, b) => b.length - a.length);
+	const contexts = new Map();
+	for (const configPath of sortedPaths) {
+		const configResult = loadConfig(configPath);
+		if (configResult.isErr()) {
+			return err(lspErrors.configLoadFailed(`Failed to load config ${configPath}: ${configResult.error.message}`, configResult.error));
+		}
+		const config = configResult.value;
+		const helper = createGraphqlSystemIdentifyHelper(config);
+		const resolverResult = createSchemaResolver(config);
+		if (resolverResult.isErr()) {
+			return err(resolverResult.error);
+		}
+		contexts.set(configPath, {
+			configPath,
+			config,
+			helper,
+			schemaResolver: resolverResult.value,
+			documentManager: createDocumentManager(helper, { resolveFrom: configPath })
+		});
+	}
+	const uriCache = new Map();
+	const resolveConfigPath = (dirPath) => {
+		const cached = uriCache.get(dirPath);
+		if (cached !== undefined) {
+			return cached;
+		}
+		for (const configPath of sortedPaths) {
+			const configDir = dirname(configPath);
+			if (dirPath === configDir || dirPath.startsWith(`${configDir}${sep}`)) {
+				uriCache.set(dirPath, configPath);
+				return configPath;
+			}
+		}
+		uriCache.set(dirPath, null);
+		return null;
+	};
+	return ok({
+		resolveForUri: (uri) => {
+			if (!uri.startsWith("file://") && !uri.startsWith("/")) {
+				return undefined;
+			}
+			const filePath = uri.startsWith("file://") ? fileURLToPath(uri) : uri;
+			const dirPath = dirname(filePath);
+			const configPath = resolveConfigPath(dirPath);
+			return configPath ? contexts.get(configPath) : undefined;
+		},
+		getAllContexts: () => [...contexts.values()],
+		reloadSchemas: (configPath) => {
+			const ctx = contexts.get(configPath);
+			if (!ctx) {
+				return err([lspErrors.configLoadFailed(`Config not found: ${configPath}`)]);
+			}
+			return ctx.schemaResolver.reloadAll();
+		},
+		reloadAllSchemas: () => {
+			const errors = [];
+			for (const ctx of contexts.values()) {
+				const result = ctx.schemaResolver.reloadAll();
+				if (result.isErr()) {
+					errors.push(...result.error);
+				}
+			}
+			return errors.length > 0 ? err(errors) : ok(undefined);
+		}
+	});
+};
+
 //#endregion
 //#region packages/lsp/src/handlers/code-action.ts
 /** Handle a code action request for a GraphQL template. */
@@ -3078,7 +3418,7 @@ const findStatementStart = (source, offset) => {
 const handleCompletion = (input) => {
 	const { template, schema, tsSource, tsPosition } = input;
 	const reconstructed = reconstructGraphql(template);
-	const headerLen = reconstructed.length - template.content.length;
+	const headerLen = computeHeaderLen(template, reconstructed);
 	const { preprocessed } = preprocessFragmentArgs(reconstructed);
 	const mapper = createPositionMapper({
 		tsSource,
@@ -3101,6 +3441,27 @@ const handleCompletion = (input) => {
 //#endregion
 //#region packages/lsp/src/handlers/_utils.ts
 /**
+* Shared handler utilities for fragment spread and definition lookup.
+* @module
+*/
+/** Build ObjectTypeInfo[] from schema file info for graphql-language-service definition APIs. */
+const buildObjectTypeInfos = (files) => {
+	const result = [];
+	for (const file of files) {
+		const doc = parse(file.content);
+		for (const def of doc.definitions) {
+			if (isTypeDefinitionNode(def)) {
+				result.push({
+					filePath: pathToFileURL(file.filePath).href,
+					content: file.content,
+					definition: def
+				});
+			}
+		}
+	}
+	return result;
+};
+/**
 * Find the fragment spread node at the given GraphQL offset using AST.
 * Returns the FragmentSpreadNode if cursor is on a `...FragmentName` pattern.
 */
@@ -3230,35 +3591,41 @@ const computeSpreadLocationRanges = (spreadLocations) => {
 	}
 	return ranges;
 };
-
-//#endregion
-//#region packages/lsp/src/handlers/definition.ts
 /**
-* Definition handler: provides go-to-definition for fragment spreads and schema fields/types.
-* @module
+* Resolve a directive name to its definition in schema files.
+* Parses each schema file and finds DirectiveDefinitionNode matching the name.
 */
-/** Build ObjectTypeInfo[] from schema file info for graphql-language-service definition APIs. */
-const buildObjectTypeInfos = (files) => {
-	const result = [];
-	for (const file of files) {
-		const doc = parse(file.content);
-		for (const def of doc.definitions) {
-			if (isTypeDefinitionNode(def)) {
-				result.push({
-					filePath: pathToFileURL(file.filePath).href,
-					content: file.content,
-					definition: def
-				});
+const resolveDirectiveDefinition = (directiveName, schemaFiles) => {
+	const locations = [];
+	for (const file of schemaFiles) {
+		try {
+			const doc = parse(file.content, { noLocation: false });
+			const lineOffsets = computeLineOffsets(file.content);
+			for (const def of doc.definitions) {
+				if (def.kind === "DirectiveDefinition" && def.name.value === directiveName && def.name.loc) {
+					const start = offsetToPosition(lineOffsets, def.name.loc.start);
+					const end = offsetToPosition(lineOffsets, def.name.loc.end);
+					locations.push({
+						uri: pathToFileURL(file.filePath).href,
+						range: {
+							start,
+							end
+						}
+					});
+				}
 			}
-		}
+		} catch {}
 	}
-	return result;
+	return locations;
 };
+
+//#endregion
+//#region packages/lsp/src/handlers/definition.ts
 /** Handle a definition request for a GraphQL template. */
 const handleDefinition = async (input) => {
 	const { template, tsSource, tsPosition, externalFragments } = input;
 	const reconstructed = reconstructGraphql(template);
-	const headerLen = reconstructed.length - template.content.length;
+	const headerLen = computeHeaderLen(template, reconstructed);
 	const { preprocessed } = preprocessFragmentArgs(reconstructed);
 	const mapper = createPositionMapper({
 		tsSource,
@@ -3276,10 +3643,16 @@ const handleDefinition = async (input) => {
 	if (fragmentSpread) {
 		return resolveFragmentSpreadDefinition(preprocessed, fragmentSpread, externalFragments);
 	}
+	if (input.schemaFiles && input.schemaFiles.length > 0) {
+		const varTypeResult = await resolveVariableTypeDefinition(preprocessed, reconstructedOffset, input.schemaFiles);
+		if (varTypeResult.length > 0) {
+			return varTypeResult;
+		}
+	}
 	if (input.schema && input.schemaFiles && input.schemaFiles.length > 0) {
 		const reconstructedLineOffsets = computeLineOffsets(preprocessed);
 		const reconstructedPosition = offsetToPosition(reconstructedLineOffsets, reconstructedOffset);
-		return resolveSchemaDefinition(preprocessed, reconstructedPosition, input.schema, input.schemaFiles);
+		return resolveSchemaDefinition(preprocessed, reconstructedPosition, reconstructedOffset, input.schema, input.schemaFiles);
 	}
 	return [];
 };
@@ -3338,28 +3711,84 @@ const resolveFragmentSpreadDefinition = async (preprocessed, fragmentSpread, ext
 						character: endChar
 					}
 				}
-			};
-		});
+			};
+		});
+	} catch {
+		return [];
+	}
+};
+/** Unwrap NonNullType/ListType wrappers to get the inner NamedType node. */
+const unwrapToNamedType = (typeNode) => {
+	if (typeNode.kind === "NamedType") return typeNode;
+	if (typeNode.kind === "NonNullType" || typeNode.kind === "ListType") {
+		return unwrapToNamedType(typeNode.type);
+	}
+	return null;
+};
+/**
+* Resolve variable type reference to its definition in a schema file.
+* Parses the GraphQL source to find VariableDefinition nodes, checks if the
+* cursor offset falls within a type name, and resolves via getDefinitionQueryResultForNamedType.
+*/
+const resolveVariableTypeDefinition = async (preprocessed, reconstructedOffset, schemaFiles) => {
+	let ast;
+	try {
+		ast = parse(preprocessed, { noLocation: false });
+	} catch {
+		return [];
+	}
+	let matchedNode = null;
+	visit(ast, { VariableDefinition(node) {
+		if (matchedNode) return;
+		const namedType = unwrapToNamedType(node.type);
+		if (!namedType?.name.loc) return;
+		const { start, end } = namedType.name.loc;
+		if (reconstructedOffset >= start && reconstructedOffset < end) {
+			matchedNode = namedType;
+		}
+	} });
+	if (!matchedNode) return [];
+	const objectTypeInfos = buildObjectTypeInfos(schemaFiles);
+	try {
+		const result = await getDefinitionQueryResultForNamedType(preprocessed, matchedNode, objectTypeInfos);
+		return result.definitions.map((def) => ({
+			uri: def.path ?? "",
+			range: {
+				start: {
+					line: def.position.line,
+					character: def.position.character
+				},
+				end: {
+					line: def.range?.end?.line ?? def.position.line,
+					character: def.range?.end?.character ?? def.position.character
+				}
+			}
+		}));
 	} catch {
 		return [];
 	}
 };
 /** Resolve field or type name to its definition in a schema .graphql file. */
-const resolveSchemaDefinition = (preprocessed, position, schema, schemaFiles) => {
+const resolveSchemaDefinition = async (preprocessed, position, reconstructedOffset, schema, schemaFiles) => {
+	const astResult = await tryResolveTypeConditionOrDirective(preprocessed, reconstructedOffset, schemaFiles);
+	if (astResult.matched) {
+		return astResult.locations;
+	}
 	const context = getContextAtPosition(preprocessed, toIPosition(position), schema);
 	if (!context) {
-		return Promise.resolve([]);
+		return [];
 	}
 	const { typeInfo } = context;
 	if (typeInfo.fieldDef && typeInfo.parentType) {
 		const fieldName = typeInfo.fieldDef.name;
 		const namedParentType = getNamedType(typeInfo.parentType);
 		if (!namedParentType) {
-			return Promise.resolve([]);
+			return [];
 		}
 		const parentTypeName = namedParentType.name;
 		const objectTypeInfos = buildObjectTypeInfos(schemaFiles);
-		return getDefinitionQueryResultForField(fieldName, parentTypeName, objectTypeInfos).then((result) => result.definitions.map((def) => ({
+		const result = await getDefinitionQueryResultForField(fieldName, parentTypeName, objectTypeInfos);
+		return result.definitions.map((def) => ({
 			uri: def.path ?? "",
 			range: {
 				start: {
@@ -3371,63 +3800,99 @@ const resolveSchemaDefinition = (preprocessed, position, schema, schemaFiles) =>
 					character: def.range?.end?.character ?? def.position.character
 				}
 			}
-		})));
+		}));
 	}
-	return Promise.resolve([]);
+	return [];
 };
-
-//#endregion
-//#region packages/lsp/src/handlers/diagnostics.ts
-/** Compute LSP diagnostics for a single GraphQL template. */
-const computeTemplateDiagnostics = (input) => {
-	const { template, schema, tsSource } = input;
-	const reconstructed = reconstructGraphql(template);
-	const headerLen = reconstructed.length - template.content.length;
-	const { preprocessed } = preprocessFragmentArgs(reconstructed);
-	const mapper = createPositionMapper({
-		tsSource,
-		contentStartOffset: template.contentRange.start,
-		graphqlContent: template.content
-	});
-	const gqlDiagnostics = getDiagnostics(preprocessed, schema, undefined, undefined, input.externalFragments);
-	const placeholderPattern = /__FRAG_SPREAD_\d+__/;
-	const reconstructedLineOffsets = computeLineOffsets(preprocessed);
-	const contentLineOffsets = computeLineOffsets(template.content);
-	const toContentPosition = (pos) => {
-		const offset = positionToOffset$1(reconstructedLineOffsets, pos);
-		const contentOffset = Math.max(0, offset - headerLen);
-		return offsetToPosition(contentLineOffsets, contentOffset);
-	};
-	return gqlDiagnostics.filter((diag) => {
-		if (placeholderPattern.test(diag.message)) {
-			return false;
-		}
-		const offset = positionToOffset$1(reconstructedLineOffsets, diag.range.start);
-		if (offset < headerLen) {
-			return false;
+/**
+* Try to resolve inline fragment type conditions and directive names via AST walking.
+* Returns { matched: true, locations } when cursor is on a type condition or directive,
+* or { matched: false } when cursor is on neither (caller should try field resolution).
+*/
+const tryResolveTypeConditionOrDirective = async (preprocessed, reconstructedOffset, schemaFiles) => {
+	let ast;
+	try {
+		ast = parse(preprocessed, { noLocation: false });
+	} catch {
+		return { matched: false };
+	}
+	let matchedTypeName = null;
+	let matchedDirectiveName = null;
+	visit(ast, {
+		InlineFragment(node) {
+			const loc = node.typeCondition?.name.loc;
+			if (loc && reconstructedOffset >= loc.start && reconstructedOffset < loc.end) {
+				matchedTypeName = node.typeCondition.name.value;
+			}
+		},
+		FragmentDefinition(node) {
+			const loc = node.typeCondition.name.loc;
+			if (loc && reconstructedOffset >= loc.start && reconstructedOffset < loc.end) {
+				matchedTypeName = node.typeCondition.name.value;
+			}
+		},
+		Directive(node) {
+			const loc = node.name.loc;
+			if (loc && reconstructedOffset >= loc.start && reconstructedOffset < loc.end) {
+				matchedDirectiveName = node.name.value;
+			}
 		}
-		return true;
-	}).map((diag) => {
-		const startContent = toContentPosition(diag.range.start);
-		const endContent = toContentPosition(diag.range.end);
-		const startTs = mapper.graphqlToTs(startContent);
-		const endTs = mapper.graphqlToTs(endContent);
+	});
+	if (matchedTypeName) {
+		return {
+			matched: true,
+			locations: await resolveTypeNameToSchemaDefinition(matchedTypeName, schemaFiles)
+		};
+	}
+	if (matchedDirectiveName) {
 		return {
+			matched: true,
+			locations: resolveDirectiveDefinition(matchedDirectiveName, schemaFiles)
+		};
+	}
+	return { matched: false };
+};
+/**
+* Resolve a type name to its definition in a schema file.
+* Used for fragment type names and inline fragment type conditions.
+*/
+const resolveTypeNameToSchemaDefinition = async (typeName, schemaFiles) => {
+	const typeNameLen = typeName.length;
+	const dummyLoc = {
+		start: 0,
+		end: typeNameLen,
+		startToken: null,
+		endToken: null,
+		source: null
+	};
+	const namedTypeNode = {
+		kind: Kind.NAMED_TYPE,
+		name: {
+			kind: Kind.NAME,
+			value: typeName,
+			loc: dummyLoc
+		},
+		loc: dummyLoc
+	};
+	const objectTypeInfos = buildObjectTypeInfos(schemaFiles);
+	try {
+		const result = await getDefinitionQueryResultForNamedType("", namedTypeNode, objectTypeInfos);
+		return result.definitions.map((def) => ({
+			uri: def.path ?? "",
 			range: {
 				start: {
-					line: startTs.line,
-					character: startTs.character
+					line: def.position.line,
+					character: def.position.character
 				},
 				end: {
-					line: endTs.line,
-					character: endTs.character
+					line: def.range?.end?.line ?? def.position.line,
+					character: def.range?.end?.character ?? def.position.character
 				}
-			},
-			message: diag.message,
-			severity: diag.severity,
-			source: "soda-gql"
-		};
-	});
+			}
+		}));
+	} catch {
+		return [];
+	}
 };
 
 //#endregion
@@ -3495,7 +3960,7 @@ const handleDocumentSymbol = (input) => {
 	const symbols = [];
 	for (const template of templates) {
 		const reconstructed = reconstructGraphql(template);
-		const headerLen = reconstructed.length - template.content.length;
+		const headerLen = computeHeaderLen(template, reconstructed);
 		const { preprocessed } = preprocessFragmentArgs(reconstructed);
 		const outline = getOutline(preprocessed);
 		if (!outline) {
@@ -3516,6 +3981,11 @@ const handleDocumentSymbol = (input) => {
 		for (const tree of outline.outlineTrees) {
 			const symbol = convertTree(tree, toContentPos, mapper);
 			if (symbol) {
+				if (template.kind === "fragment" && template.typeName) {
+					symbol.detail = `on ${template.typeName}`;
+				} else if (template.kind !== "fragment") {
+					symbol.detail = template.kind;
+				}
 				symbols.push(symbol);
 			}
 		}
@@ -3523,6 +3993,129 @@ const handleDocumentSymbol = (input) => {
 	return symbols;
 };
 
+//#endregion
+//#region packages/lsp/src/handlers/field-tree-completion.ts
+/** Handle a completion request for a callback builder field tree node. */
+const handleFieldTreeCompletion = (input) => {
+	const { fieldTree, schema, tsSource, offset } = input;
+	const result = findNodeAtOffset(fieldTree, offset);
+	if (!result) return [];
+	if (result.kind === "field") {
+		const { node } = result;
+		const prefix = tsSource.slice(node.fieldNameSpan.start, offset);
+		const parentType = schema.getType(node.parentTypeName);
+		if (!parentType || !isObjectType(parentType)) return [];
+		const fields = parentType.getFields();
+		const items = [];
+		for (const [name, field] of Object.entries(fields)) {
+			if (!name.startsWith(prefix)) continue;
+			const namedType = getNamedType(field.type);
+			items.push({
+				label: name,
+				kind: CompletionItemKind.Field,
+				detail: namedType?.name
+			});
+		}
+		return items;
+	}
+	if (result.kind === "unionMember") {
+		const { parentNode } = result;
+		const fieldType = parentNode.fieldTypeName ? schema.getType(parentNode.fieldTypeName) : null;
+		if (!fieldType || !(fieldType instanceof GraphQLUnionType)) return [];
+		const prefix = tsSource.slice(result.branch.typeNameSpan.start, offset);
+		return fieldType.getTypes().filter((member) => member.name.startsWith(prefix)).map((member) => ({
+			label: member.name,
+			kind: CompletionItemKind.Class,
+			detail: `member of ${parentNode.fieldTypeName}`
+		}));
+	}
+	return [];
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/field-tree-definition.ts
+/** Handle a definition request for a callback builder field tree. */
+const handleFieldTreeDefinition = async (input) => {
+	const { fieldTree, offset, schemaFiles } = input;
+	const result = findNodeAtOffset(fieldTree, offset);
+	if (!result) return [];
+	const objectTypeInfos = buildObjectTypeInfos(schemaFiles);
+	if (result.kind === "field") {
+		const { node } = result;
+		try {
+			const defResult = await getDefinitionQueryResultForField(node.fieldName, node.parentTypeName, objectTypeInfos);
+			return defResult.definitions.map((def) => ({
+				uri: def.path ?? "",
+				range: {
+					start: {
+						line: def.position.line,
+						character: def.position.character
+					},
+					end: {
+						line: def.range?.end?.line ?? def.position.line,
+						character: def.range?.end?.character ?? def.position.character
+					}
+				}
+			}));
+		} catch {
+			return [];
+		}
+	}
+	if (result.kind === "unionMember") {
+		const typeNameLen = result.branch.typeName.length;
+		const dummyLoc = {
+			start: 0,
+			end: typeNameLen,
+			startToken: null,
+			endToken: null,
+			source: null
+		};
+		const namedTypeNode = {
+			kind: Kind.NAMED_TYPE,
+			name: {
+				kind: Kind.NAME,
+				value: result.branch.typeName,
+				loc: dummyLoc
+			},
+			loc: dummyLoc
+		};
+		try {
+			const defResult = await getDefinitionQueryResultForNamedType("", namedTypeNode, objectTypeInfos);
+			return defResult.definitions.map((def) => ({
+				uri: def.path ?? "",
+				range: {
+					start: {
+						line: def.position.line,
+						character: def.position.character
+					},
+					end: {
+						line: def.range?.end?.line ?? def.position.line,
+						character: def.range?.end?.character ?? def.position.character
+					}
+				}
+			}));
+		} catch {
+			return [];
+		}
+	}
+	return [];
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/field-tree-hover.ts
+/** Handle a hover request for a callback builder field tree node. */
+const handleFieldTreeHover = (input) => {
+	const { fieldTree, offset } = input;
+	const result = findNodeAtOffset(fieldTree, offset);
+	if (!result || result.kind !== "field") return null;
+	const { node } = result;
+	if (!node.fieldTypeName) return null;
+	return { contents: {
+		kind: "markdown",
+		value: `${node.fieldName}: ${node.fieldTypeName}`
+	} };
+};
+
 //#endregion
 //#region packages/lsp/src/handlers/formatting.ts
 /**
@@ -3554,7 +4147,7 @@ const handleFormatting = (input) => {
 const handleHover = (input) => {
 	const { template, schema, tsSource, tsPosition } = input;
 	const reconstructed = reconstructGraphql(template);
-	const headerLen = reconstructed.length - template.content.length;
+	const headerLen = computeHeaderLen(template, reconstructed);
 	const { preprocessed } = preprocessFragmentArgs(reconstructed);
 	const mapper = createPositionMapper({
 		tsSource,
@@ -3718,6 +4311,115 @@ const handleRename = (input) => {
 * LSP server: wires all components together via vscode-languageserver.
 * @module
 */
+/**
+* Shared 3-phase dispatch: registry/ctx/doc guard → field-tree → template.
+* Used by completion, hover, and definition handlers.
+*/
+const resolvePositionContext = (registry, documents, uri, position) => {
+	if (!registry) {
+		return undefined;
+	}
+	const ctx = registry.resolveForUri(uri);
+	if (!ctx) {
+		return undefined;
+	}
+	const doc = documents.get(uri);
+	if (!doc) {
+		return undefined;
+	}
+	const tsSource = doc.getText();
+	const offset = positionToOffset(tsSource, position);
+	const tsPosition = {
+		line: position.line,
+		character: position.character
+	};
+	const untypedTree = ctx.documentManager.findFieldTreeAtOffset(uri, offset);
+	if (untypedTree) {
+		const schemaEntry$1 = ctx.schemaResolver.getSchema(untypedTree.schemaName);
+		if (schemaEntry$1) {
+			const typedTree = resolveFieldTree(untypedTree, schemaEntry$1.schema);
+			if (typedTree) {
+				return {
+					kind: "fieldTree",
+					ctx,
+					tsSource,
+					offset,
+					tsPosition,
+					typedTree,
+					schema: schemaEntry$1.schema,
+					schemaEntry: schemaEntry$1
+				};
+			}
+		}
+	}
+	const template = ctx.documentManager.findTemplateAtOffset(uri, offset);
+	if (!template) {
+		return undefined;
+	}
+	const schemaEntry = ctx.schemaResolver.getSchema(template.schemaName);
+	return {
+		kind: "template",
+		ctx,
+		tsSource,
+		offset,
+		tsPosition,
+		template,
+		schemaEntry
+	};
+};
+/** Server capabilities shared between direct and proxy initialization. */
+const serverCapabilities = {
+	textDocumentSync: TextDocumentSyncKind.Full,
+	hoverProvider: true,
+	documentSymbolProvider: true,
+	definitionProvider: true,
+	referencesProvider: true,
+	renameProvider: { prepareProvider: true },
+	documentFormattingProvider: true,
+	completionProvider: { triggerCharacters: [
+		"{",
+		"(",
+		":",
+		"@",
+		"$",
+		" ",
+		"\n",
+		".",
+		"\""
+	] },
+	codeActionProvider: { codeActionKinds: ["refactor.extract"] }
+};
+/** Initialize the LSP server from InitializeParams. Used by both direct and proxy modes. */
+const initializeFromParams = (params, connection) => {
+	const roots = resolveWorkspaceRoots(params);
+	if (roots.length === 0) {
+		connection.window.showErrorMessage("soda-gql LSP: no workspace root provided");
+		return {
+			result: { capabilities: {} },
+			registry: undefined
+		};
+	}
+	const configPaths = discoverConfigs(roots);
+	if (configPaths.length === 0) {
+		connection.window.showErrorMessage("soda-gql LSP: no config file found");
+		return {
+			result: { capabilities: {} },
+			registry: undefined
+		};
+	}
+	const registryResult = createConfigRegistry(configPaths);
+	if (registryResult.isErr()) {
+		connection.window.showErrorMessage(`soda-gql LSP: ${registryResult.error.message}`);
+		return {
+			result: { capabilities: {} },
+			registry: undefined
+		};
+	}
+	return {
+		result: { capabilities: serverCapabilities },
+		registry: registryResult.value
+	};
+};
 const createLspServer = (options) => {
 	const connection = options?.connection ?? createConnection(ProposedFeatures.all);
 	const documents = new TextDocuments(TextDocument);
@@ -3743,22 +4445,10 @@ const createLspServer = (options) => {
 			});
 			return;
 		}
-		const allDiagnostics = state.templates.flatMap((template) => {
-			const entry = ctx.schemaResolver.getSchema(template.schemaName);
-			if (!entry) {
-				return [];
-			}
-			const externalFragments = ctx.documentManager.getExternalFragments(uri, template.schemaName).map((f) => f.definition);
-			return [...computeTemplateDiagnostics({
-				template,
-				schema: entry.schema,
-				tsSource: state.source,
-				externalFragments
-			})];
-		});
+		const diagnostics = collectRawDiagnostics(state, ctx);
 		connection.sendDiagnostics({
 			uri,
-			diagnostics: allDiagnostics
+			diagnostics: [...diagnostics]
 		});
 	};
 	const publishDiagnosticsForAllOpen = () => {
@@ -3766,46 +4456,20 @@ const createLspServer = (options) => {
 			publishDiagnosticsForDocument(doc.uri);
 		}
 	};
-	connection.onInitialize((params) => {
-		const roots = resolveWorkspaceRoots(params);
-		if (roots.length === 0) {
-			connection.window.showErrorMessage("soda-gql LSP: no workspace root provided");
-			return { capabilities: {} };
-		}
-		const configPaths = discoverConfigs(roots);
-		if (configPaths.length === 0) {
-			connection.window.showErrorMessage("soda-gql LSP: no config file found");
-			return { capabilities: {} };
-		}
-		const registryResult = createConfigRegistry(configPaths);
-		if (registryResult.isErr()) {
-			connection.window.showErrorMessage(`soda-gql LSP: ${registryResult.error.message}`);
-			return { capabilities: {} };
-		}
-		registry = registryResult.value;
-		return { capabilities: {
-			textDocumentSync: TextDocumentSyncKind.Full,
-			hoverProvider: true,
-			documentSymbolProvider: true,
-			definitionProvider: true,
-			referencesProvider: true,
-			renameProvider: { prepareProvider: true },
-			documentFormattingProvider: true,
-			completionProvider: { triggerCharacters: [
-				"{",
-				"(",
-				":",
-				"@",
-				"$",
-				" ",
-				"\n",
-				"."
-			] },
-			codeActionProvider: { codeActionKinds: ["refactor.extract"] }
-		} };
-	});
+	let initializeResult;
+	if (options?.initializeParams) {
+		const init = initializeFromParams(options.initializeParams, connection);
+		registry = init.registry;
+		initializeResult = init.result;
+	} else {
+		connection.onInitialize((params) => {
+			const init = initializeFromParams(params, connection);
+			registry = init.registry;
+			return init.result;
+		});
+	}
 	connection.onInitialized(() => {
-		connection.client.register(DidChangeWatchedFilesNotification.type, { watchers: [{ globPattern: "**/*.graphql" }] });
+		connection.client.register(DidChangeWatchedFilesNotification.type, { watchers: [{ globPattern: "**/*.graphql" }, { globPattern: "**/soda-gql.config.*" }] });
 	});
 	documents.onDidChangeContent((change) => {
 		if (!registry) {
@@ -3833,95 +4497,97 @@ const createLspServer = (options) => {
 		});
 	});
 	connection.onCompletion((params) => {
-		if (!registry) {
-			return [];
-		}
-		const ctx = registry.resolveForUri(params.textDocument.uri);
-		if (!ctx) {
-			return [];
-		}
-		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(documents.get(params.textDocument.uri)?.getText() ?? "", params.position));
-		if (!template) {
+		const resolved = resolvePositionContext(registry, documents, params.textDocument.uri, params.position);
+		if (!resolved) {
 			return [];
 		}
-		const entry = ctx.schemaResolver.getSchema(template.schemaName);
-		if (!entry) {
-			return [];
+		if (resolved.kind === "fieldTree") {
+			return handleFieldTreeCompletion({
+				fieldTree: resolved.typedTree,
+				schema: resolved.schema,
+				tsSource: resolved.tsSource,
+				tsPosition: resolved.tsPosition,
+				offset: resolved.offset
+			});
 		}
-		const doc = documents.get(params.textDocument.uri);
-		if (!doc) {
+		if (!resolved.schemaEntry) {
 			return [];
 		}
-		const externalFragments = ctx.documentManager.getExternalFragments(params.textDocument.uri, template.schemaName).map((f) => f.definition);
+		const externalFragments = resolved.ctx.documentManager.getExternalFragments(params.textDocument.uri, resolved.template.schemaName).map((f) => f.definition);
 		return handleCompletion({
-			template,
-			schema: entry.schema,
-			tsSource: doc.getText(),
-			tsPosition: {
-				line: params.position.line,
-				character: params.position.character
-			},
+			template: resolved.template,
+			schema: resolved.schemaEntry.schema,
+			tsSource: resolved.tsSource,
+			tsPosition: resolved.tsPosition,
 			externalFragments
 		});
 	});
 	connection.onHover((params) => {
-		if (!registry) {
-			return null;
-		}
-		const ctx = registry.resolveForUri(params.textDocument.uri);
-		if (!ctx) {
-			return null;
-		}
-		const doc = documents.get(params.textDocument.uri);
-		if (!doc) {
+		const resolved = resolvePositionContext(registry, documents, params.textDocument.uri, params.position);
+		if (!resolved) {
 			return null;
 		}
-		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(doc.getText(), params.position));
-		if (!template) {
-			return null;
+		if (resolved.kind === "fieldTree") {
+			return handleFieldTreeHover({
+				fieldTree: resolved.typedTree,
+				offset: resolved.offset
+			});
 		}
-		const entry = ctx.schemaResolver.getSchema(template.schemaName);
-		if (!entry) {
+		if (!resolved.schemaEntry) {
 			return null;
 		}
 		return handleHover({
-			template,
-			schema: entry.schema,
-			tsSource: doc.getText(),
-			tsPosition: {
-				line: params.position.line,
-				character: params.position.character
-			}
+			template: resolved.template,
+			schema: resolved.schemaEntry.schema,
+			tsSource: resolved.tsSource,
+			tsPosition: resolved.tsPosition
 		});
 	});
 	connection.onDefinition(async (params) => {
-		if (!registry) {
-			return [];
-		}
-		const ctx = registry.resolveForUri(params.textDocument.uri);
-		if (!ctx) {
-			return [];
-		}
-		const doc = documents.get(params.textDocument.uri);
-		if (!doc) {
+		const resolved = resolvePositionContext(registry, documents, params.textDocument.uri, params.position);
+		if (!resolved) {
+			if (!registry) {
+				return [];
+			}
+			const ctx = registry.resolveForUri(params.textDocument.uri);
+			if (!ctx) {
+				return [];
+			}
+			const doc = documents.get(params.textDocument.uri);
+			if (!doc) {
+				return [];
+			}
+			const offset = positionToOffset(doc.getText(), params.position);
+			const typeNameTemplate = ctx.documentManager.findTemplateByTypeNameOffset(params.textDocument.uri, offset);
+			if (typeNameTemplate?.typeName) {
+				const typeNameEntry = ctx.schemaResolver.getSchema(typeNameTemplate.schemaName);
+				if (typeNameEntry?.files) {
+					return resolveTypeNameToSchemaDefinition(typeNameTemplate.typeName, typeNameEntry.files);
+				}
+			}
 			return [];
 		}
-		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(doc.getText(), params.position));
-		if (!template) {
-			return [];
+		if (resolved.kind === "fieldTree") {
+			if (!resolved.schemaEntry.files) {
+				return [];
+			}
+			return handleFieldTreeDefinition({
+				fieldTree: resolved.typedTree,
+				schema: resolved.schema,
+				tsSource: resolved.tsSource,
+				tsPosition: resolved.tsPosition,
+				offset: resolved.offset,
+				schemaFiles: resolved.schemaEntry.files
+			});
 		}
-		const externalFragments = ctx.documentManager.getExternalFragments(params.textDocument.uri, template.schemaName);
-		const entry = ctx.schemaResolver.getSchema(template.schemaName);
+		const externalFragments = resolved.ctx.documentManager.getExternalFragments(params.textDocument.uri, resolved.template.schemaName);
 		return handleDefinition({
-			template,
-			tsSource: doc.getText(),
-			tsPosition: {
-				line: params.position.line,
-				character: params.position.character
-			},
+			template: resolved.template,
+			tsSource: resolved.tsSource,
+			tsPosition: resolved.tsPosition,
 			externalFragments,
-			schema: entry?.schema,
-			schemaFiles: entry?.files
+			schema: resolved.schemaEntry?.schema,
+			schemaFiles: resolved.schemaEntry?.files
 		});
 	});
 	connection.onReferences((params) => {
@@ -4089,11 +4755,18 @@ const createLspServer = (options) => {
 				}
 			}
 		}
+		const configChanged = _params.changes.some((change) => /soda-gql\.config\.[cm]?[jt]s$/.test(change.uri) && (change.type === FileChangeType.Changed || change.type === FileChangeType.Created));
+		if (configChanged) {
+			connection.window.showInformationMessage("soda-gql: config file changed. Restart the language server to apply.");
+		}
 	});
 	documents.listen(connection);
-	return { start: () => {
-		connection.listen();
-	} };
+	return {
+		start: () => {
+			connection.listen();
+		},
+		initializeResult
+	};
 };
 /** Check if SWC is unavailable and show a one-time error notification. */
 const checkSwcUnavailable = (swcUnavailable, state, showError) => {
@@ -4150,5 +4823,5 @@ const positionToOffset = (source, position) => {
 };
 
 //#endregion
-export { createDocumentManager as a, lspErrors as i, createSchemaResolver as n, preprocessFragmentArgs as o, createPositionMapper as r, createLspServer as t };
-//# sourceMappingURL=server-CqOUHwDk.mjs.map
+export { collectRawDiagnostics as a, preprocessFragmentArgs as c, lspErrors as i, createConfigRegistry as n, createPositionMapper as o, createSchemaResolver as r, createDocumentManager as s, createLspServer as t };
+//# sourceMappingURL=server-wPCHK04O.mjs.map