xq-lsp 1.8.0 → 1.8.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.8.1](https://github.com/DrRataplan/xq-lsp/compare/lsp-v1.8.0...lsp-v1.8.1) (2026-07-29)
+
+
+### Bug Fixes
+
+* stop retaining full ASTs for every glob-matched file to prevent OOM ([b44460f](https://github.com/DrRataplan/xq-lsp/commit/b44460f1de449b48903ebddff4f56b7524b99234))
+
 ## [1.8.0](https://github.com/DrRataplan/xq-lsp/compare/lsp-v1.7.0...lsp-v1.8.0) (2026-07-28)
 
 

package/dist/call-hierarchy.d.ts

@@ -1,6 +1,6 @@
 import type { CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from "vscode-languageserver/node.js";
 import type { FileAnalysis } from "./types.ts";
-import type { FileRecord } from "./references.ts";
+import type { FileRecord, LoadAst } from "./references.ts";
 /**
  * Resolve the function under the cursor (declaration name or call-site name) to a
  * `CallHierarchyItem[]`, the same way `getDefinition` resolves go-to-definition targets.
@@ -17,4 +17,4 @@ export declare function getOutgoingCalls(item: CallHierarchyItem, text: string,
  * namespace + local name + arity), grouped by each call site's enclosing
  * `declare function` — found by walking up the AST from the call-site offset.
  */
-export declare function getIncomingCalls(item: CallHierarchyItem, itemText: string, itemAnalysis: FileAnalysis, getOtherFiles: () => FileRecord[]): CallHierarchyIncomingCall[];
+export declare function getIncomingCalls(item: CallHierarchyItem, itemText: string, itemAnalysis: FileAnalysis, getOtherFiles: () => FileRecord[], loadAst: LoadAst): CallHierarchyIncomingCall[];

package/dist/call-hierarchy.js

@@ -143,34 +143,49 @@ export function getOutgoingCalls(item, text, analysis, imported) {
  * namespace + local name + arity), grouped by each call site's enclosing
  * `declare function` — found by walking up the AST from the call-site offset.
  */
-export function getIncomingCalls(item, itemText, itemAnalysis, getOtherFiles) {
+export function getIncomingCalls(item, itemText, itemAnalysis, getOtherFiles, loadAst) {
     const offset = toOffset(itemText, item.selectionRange.start);
     // includeDeclaration:false — we only want actual call sites, not the declaration itself.
-    const callSites = getReferences(item.uri, itemText, offset, itemAnalysis, false, getOtherFiles);
+    const callSites = getReferences(item.uri, itemText, offset, itemAnalysis, false, getOtherFiles, loadAst);
     if (callSites.length === 0)
         return [];
-    const fileByUri = new Map(getOtherFiles().map((f) => [f.uri, f]));
-    if (!fileByUri.has(item.uri))
-        fileByUri.set(item.uri, { uri: item.uri, text: itemText, analysis: itemAnalysis });
+    // getOtherFiles() returns cached, ast-free records — cheap to re-iterate for a uri->text
+    // lookup. The full (ast-bearing) analysis for each call site's file is fetched below, once
+    // per distinct uri, via loadAst.
+    const textByUri = new Map([[item.uri, itemText]]);
+    for (const file of getOtherFiles())
+        if (!textByUri.has(file.uri))
+            textByUri.set(file.uri, file.text);
+    const analysisByUri = new Map([[item.uri, itemAnalysis]]);
     const groups = new Map();
     for (const loc of callSites) {
-        const record = fileByUri.get(loc.uri);
-        if (!record?.analysis.ast)
+        const text = textByUri.get(loc.uri);
+        if (text === undefined)
             continue;
-        const callOffset = toOffset(record.text, loc.range.start);
-        const stack = nodeStackAtOffset(record.analysis.ast, callOffset);
+        let fileAnalysis = analysisByUri.get(loc.uri);
+        if (!fileAnalysis) {
+            const loaded = loadAst(loc.uri, text);
+            if (!loaded)
+                continue;
+            fileAnalysis = loaded;
+            analysisByUri.set(loc.uri, fileAnalysis);
+        }
+        if (!fileAnalysis.ast)
+            continue;
+        const callOffset = toOffset(text, loc.range.start);
+        const stack = nodeStackAtOffset(fileAnalysis.ast, callOffset);
         // Function declarations can't nest in XQuery, so at most one AnnotatedDecl/FunctionDecl
         // pair appears in the stack; a call at module level (no enclosing function) has none.
         const enclosingDecl = stack.find((n) => n.type === "AnnotatedDecl" && directChildOf(n, "FunctionDecl"));
         if (!enclosingDecl)
             continue;
-        const enclosingFn = record.analysis.functions.find((f) => f.sourceOffset === enclosingDecl.start);
+        const enclosingFn = fileAnalysis.functions.find((f) => f.sourceOffset === enclosingDecl.start);
         if (!enclosingFn)
             continue;
         const key = `${qnameKey(enclosingFn.qname)}#${enclosingFn.arity}@${loc.uri}`;
         let group = groups.get(key);
         if (!group) {
-            const from = buildItemForFunction(enclosingFn, record.analysis, loc.uri, record.text);
+            const from = buildItemForFunction(enclosingFn, fileAnalysis, loc.uri, text);
             if (!from)
                 continue;
             group = { from, ranges: [] };

package/dist/code-lens.d.ts

@@ -1,7 +1,7 @@
 import { CodeLens } from "vscode-languageserver/node.js";
 import type { TextDocument } from "vscode-languageserver-textdocument";
 import type { FileAnalysis } from "./types.ts";
-import type { FileRecord } from "./references.ts";
+import type { FileRecord, LoadAst } from "./references.ts";
 /** Carried on each unresolved lens so `resolveCodeLens` can find the declaration again later. */
 export interface CodeLensData {
     uri: string;
@@ -20,4 +20,4 @@ export declare function buildCodeLenses(doc: TextDocument, analysis: FileAnalysi
  * reference search `textDocument/references` uses. Declarations aren't counted as
  * references. 0 references is reported as-is — it's a useful signal, not hidden.
  */
-export declare function resolveCodeLens(lens: CodeLens, text: string, analysis: FileAnalysis, getOtherFiles: () => FileRecord[]): CodeLens;
+export declare function resolveCodeLens(lens: CodeLens, text: string, analysis: FileAnalysis, getOtherFiles: () => FileRecord[], loadAst: LoadAst): CodeLens;

package/dist/code-lens.js

@@ -60,10 +60,10 @@ function findNameOffset(ast, analysis, data) {
  * reference search `textDocument/references` uses. Declarations aren't counted as
  * references. 0 references is reported as-is — it's a useful signal, not hidden.
  */
-export function resolveCodeLens(lens, text, analysis, getOtherFiles) {
+export function resolveCodeLens(lens, text, analysis, getOtherFiles, loadAst) {
     const data = lens.data;
     const ast = analysis.ast;
     const offset = data && ast ? findNameOffset(ast, analysis, data) : null;
-    const count = data && offset !== null ? getReferences(data.uri, text, offset, analysis, false, getOtherFiles).length : 0;
+    const count = data && offset !== null ? getReferences(data.uri, text, offset, analysis, false, getOtherFiles, loadAst).length : 0;
     return { ...lens, command: { title: `${count} references`, command: "" } };
 }

package/dist/references.d.ts

@@ -10,6 +10,14 @@ export declare function offsetToPosition(text: string, offset: number): {
     line: number;
     character: number;
 };
+/**
+ * Parses one glob-matched file's full AST on demand for a cross-file occurrence walk.
+ * Reuses `analysisCache` (open documents, explicit imports) when the file is already
+ * resident; otherwise parses fresh and returns without caching the result, so a
+ * cross-file search never retains more than the file currently being walked. See
+ * `getGlobFileAccess` in server.ts.
+ */
+export type LoadAst = (uri: string, text: string) => FileAnalysis | null;
 /**
  * Find all references to the symbol at `offset` in the current file.
  *
@@ -26,9 +34,11 @@ export declare function offsetToPosition(text: string, offset: number): {
  * Requires a valid AST (returns `[]` on the regex-fallback path, since parse
  * failures don't produce reliable node positions).
  * `getOtherFiles` is only invoked for symbol kinds that need a cross-file
- * search, so callers can make it lazy.
+ * search, so callers can make it lazy. `getOtherFiles` returns lightweight,
+ * ast-free records for cheap candidate filtering; `loadAst` parses a specific
+ * candidate's full AST on demand once it survives that filter (see `LoadAst`).
  */
-export declare function getReferences(currentUri: string, currentText: string, offset: number, analysis: FileAnalysis, includeDeclaration: boolean, getOtherFiles: () => FileRecord[]): Location[];
+export declare function getReferences(currentUri: string, currentText: string, offset: number, analysis: FileAnalysis, includeDeclaration: boolean, getOtherFiles: () => FileRecord[], loadAst: LoadAst): Location[];
 /**
  * Range of the renameable identifier at `offset`, trimmed to the local-name part
  * (namespace-prefix qualifiers are left untouched) or the bare prefix NCName for
@@ -48,7 +58,7 @@ export declare function getRenameRangeAtOffset(currentText: string, offset: numb
  * recognizable at `offset`, or no resolvable local declaration (e.g. a builtin
  * function or a predeclared runtime namespace prefix).
  */
-export declare function getRenameLocations(currentUri: string, currentText: string, offset: number, analysis: FileAnalysis, getOtherFiles: () => FileRecord[]): Location[] | null;
+export declare function getRenameLocations(currentUri: string, currentText: string, offset: number, analysis: FileAnalysis, getOtherFiles: () => FileRecord[], loadAst: LoadAst): Location[] | null;
 /**
  * Highlight every occurrence of the symbol at `offset` within the current
  * document only (`textDocument/documentHighlight` is file-scoped by spec, even

package/dist/references.js

@@ -277,8 +277,7 @@ function getPrefixReferences(currentUri, currentText, ast, analysis, prefix, inc
     }
     return locs;
 }
-// ── Cross-file orchestration ──────────────────────────────────────────────────
-function getVariableReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles, trimToLocalName = false) {
+function getVariableReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles, loadAst, trimToLocalName = false) {
     const occurrences = [];
     walkVariables(ast, analysis, new ScopeStack(), occurrences);
     const target = occurrences.find((o) => offset >= o.start && offset <= o.end);
@@ -301,10 +300,16 @@ function getVariableReferences(currentUri, currentText, ast, analysis, offset, i
         o,
     }));
     for (const file of getOtherFiles()) {
-        if (file.uri === currentUri || !file.analysis.ast)
+        // Cheap pre-filter: localName always appears verbatim in source regardless of EQName
+        // syntax (prefixed, URIQualified, or unprefixed), so its absence rules out a match
+        // without needing to parse the file at all.
+        if (file.uri === currentUri || !file.text.includes(localName))
+            continue;
+        const fileAnalysis = loadAst(file.uri, file.text);
+        if (!fileAnalysis?.ast)
             continue;
         const fileOccs = [];
-        walkVariables(file.analysis.ast, file.analysis, new ScopeStack(), fileOccs);
+        walkVariables(fileAnalysis.ast, fileAnalysis, new ScopeStack(), fileOccs);
         for (const o of matches(fileOccs))
             all.push({ uri: file.uri, text: file.text, o });
     }
@@ -313,7 +318,7 @@ function getVariableReferences(currentUri, currentText, ast, analysis, offset, i
         return [];
     return all.filter((m) => includeDeclaration || !m.o.isDeclaration).map((m) => toLoc(m.uri, m.text, m.o));
 }
-function getFunctionReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles, trimToLocalName = false) {
+function getFunctionReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles, loadAst, trimToLocalName = false) {
     const occurrences = [];
     walkFunctions(ast, analysis, occurrences);
     const target = occurrences.find((o) => offset >= o.start && offset <= o.end);
@@ -328,10 +333,13 @@ function getFunctionReferences(currentUri, currentText, ast, analysis, offset, i
         o,
     }));
     for (const file of getOtherFiles()) {
-        if (file.uri === currentUri || !file.analysis.ast)
+        if (file.uri === currentUri || !file.text.includes(localName))
+            continue;
+        const fileAnalysis = loadAst(file.uri, file.text);
+        if (!fileAnalysis?.ast)
             continue;
         const fileOccs = [];
-        walkFunctions(file.analysis.ast, file.analysis, fileOccs);
+        walkFunctions(fileAnalysis.ast, fileAnalysis, fileOccs);
         for (const o of matches(fileOccs))
             all.push({ uri: file.uri, text: file.text, o });
     }
@@ -385,9 +393,11 @@ function prefixHasDeclaration(analysis, prefix) {
  * Requires a valid AST (returns `[]` on the regex-fallback path, since parse
  * failures don't produce reliable node positions).
  * `getOtherFiles` is only invoked for symbol kinds that need a cross-file
- * search, so callers can make it lazy.
+ * search, so callers can make it lazy. `getOtherFiles` returns lightweight,
+ * ast-free records for cheap candidate filtering; `loadAst` parses a specific
+ * candidate's full AST on demand once it survives that filter (see `LoadAst`).
  */
-export function getReferences(currentUri, currentText, offset, analysis, includeDeclaration, getOtherFiles) {
+export function getReferences(currentUri, currentText, offset, analysis, includeDeclaration, getOtherFiles, loadAst) {
     const ast = analysis.ast;
     if (!ast)
         return [];
@@ -397,8 +407,8 @@ export function getReferences(currentUri, currentText, offset, analysis, include
     if (target.kind === "prefix")
         return getPrefixReferences(currentUri, currentText, ast, analysis, target.prefix, includeDeclaration);
     if (target.kind === "variable")
-        return getVariableReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles);
-    return getFunctionReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles);
+        return getVariableReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles, loadAst);
+    return getFunctionReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles, loadAst);
 }
 /**
  * Range of the renameable identifier at `offset`, trimmed to the local-name part
@@ -430,7 +440,7 @@ export function getRenameRangeAtOffset(currentText, offset, analysis) {
  * recognizable at `offset`, or no resolvable local declaration (e.g. a builtin
  * function or a predeclared runtime namespace prefix).
  */
-export function getRenameLocations(currentUri, currentText, offset, analysis, getOtherFiles) {
+export function getRenameLocations(currentUri, currentText, offset, analysis, getOtherFiles, loadAst) {
     const ast = analysis.ast;
     if (!ast)
         return null;
@@ -443,8 +453,8 @@ export function getRenameLocations(currentUri, currentText, offset, analysis, ge
         return getPrefixReferences(currentUri, currentText, ast, analysis, target.prefix, true);
     }
     const locs = target.kind === "variable"
-        ? getVariableReferences(currentUri, currentText, ast, analysis, offset, true, getOtherFiles, true)
-        : getFunctionReferences(currentUri, currentText, ast, analysis, offset, true, getOtherFiles, true);
+        ? getVariableReferences(currentUri, currentText, ast, analysis, offset, true, getOtherFiles, loadAst, true)
+        : getFunctionReferences(currentUri, currentText, ast, analysis, offset, true, getOtherFiles, loadAst, true);
     return locs.length > 0 ? locs : null;
 }
 /**

package/dist/server.js

@@ -107,6 +107,38 @@ function mergeAnalyses(a, b) {
         moduleVariables: [...a.moduleVariables, ...b.moduleVariables],
     };
 }
+// Lightweight (ast-free) per-file records for every glob-matched file: source text plus the
+// *extracted* FileAnalysis (functions, module variables, imports, namespace decls, ...), with
+// the AST itself dropped once those fields are pulled out. xq-parser's AST runs roughly two
+// orders of magnitude larger than the source text — XQuery's operator-precedence grammar wraps
+// even a bare `$x` variable reference in ~30 levels of single-child wrapper nodes, none of them
+// collapsed — so retaining a full AST for every glob-matched file (often hundreds, only a
+// handful of which anyone is actually looking at) is the dominant memory cost of any glob-backed
+// feature. None of the FileAnalysis fields other than `.ast` hold node references (they're all
+// plain offsets/strings — see types.ts), so dropping `.ast` after extraction is safe: nothing
+// downstream keeps the tree reachable. Populated lazily per config dir; never invalidated.
+const globFileSummariesByConfigDir = new Map();
+function buildGlobFileSummaries(config, configDir) {
+    const records = new Map();
+    for (const filePath of expandGlobs(config.globs, configDir)) {
+        const fileUri = pathToFileURL(filePath).toString();
+        try {
+            const text = fs.readFileSync(filePath, "utf-8");
+            const { analysis } = analyzeWithAst(text, fileUri);
+            records.set(fileUri, { uri: fileUri, text, analysis: { ...analysis, ast: undefined } });
+        }
+        catch {
+            /* unreadable file, skip */
+        }
+    }
+    return records;
+}
+function getGlobFileSummaries(configDir, config) {
+    if (!globFileSummariesByConfigDir.has(configDir)) {
+        globFileSummariesByConfigDir.set(configDir, buildGlobFileSummaries(config, configDir));
+    }
+    return globFileSummariesByConfigDir.get(configDir);
+}
 function getGlobAnalyses(currentUri) {
     const found = findConfig(currentUri);
     if (!found)
@@ -117,43 +149,39 @@ function getGlobAnalyses(currentUri) {
         return { byNamespace: globAnalysesByConfigDir.get(configDir), lib };
     }
     const byNamespace = new Map();
-    for (const filePath of expandGlobs(config.globs, configDir)) {
-        const fileUri = pathToFileURL(filePath).toString();
-        const imported = getImportedAnalysis(fileUri);
-        if (!imported?.moduleNamespaceUri)
+    for (const { analysis } of getGlobFileSummaries(configDir, config).values()) {
+        if (!analysis.moduleNamespaceUri)
             continue;
-        const existing = byNamespace.get(imported.moduleNamespaceUri);
-        byNamespace.set(imported.moduleNamespaceUri, existing ? mergeAnalyses(existing, imported) : imported);
+        const existing = byNamespace.get(analysis.moduleNamespaceUri);
+        byNamespace.set(analysis.moduleNamespaceUri, existing ? mergeAnalyses(existing, analysis) : analysis);
     }
     globAnalysesByConfigDir.set(configDir, byNamespace);
     return { byNamespace, lib };
 }
-// Per-file (not merged-by-namespace) glob analyses, for cross-file reference search.
-// Keyed by config directory; populated lazily and never invalidated, mirroring globAnalysesByConfigDir.
-const globFileRecordsByConfigDir = new Map();
-function getGlobFileRecords(currentUri) {
+/**
+ * Cross-file access for find-references / rename / call-hierarchy: `getOtherFiles` returns the
+ * cached, ast-free summaries above for cheap candidate filtering (see references.ts's text
+ * pre-filter); `loadAst` parses one specific candidate's full AST on demand, once it survives
+ * that filter, reusing `analysisCache` when the file is already resident (open document, or
+ * explicitly imported elsewhere) instead of re-parsing. The parsed result is intentionally NOT
+ * cached here — a cross-file search should never retain more than the handful of files it's
+ * actually walking.
+ */
+function getGlobFileAccess(currentUri) {
     const found = findConfig(currentUri);
     if (!found)
-        return () => [];
+        return { getOtherFiles: () => [], loadAst: () => null };
     const { config, configDir } = found;
-    return () => {
-        if (!globFileRecordsByConfigDir.has(configDir)) {
-            const predeclaredNs = getRuntimePredeclaredNamespaces(config.lib);
-            const records = new Map();
-            for (const filePath of expandGlobs(config.globs, configDir)) {
-                const fileUri = pathToFileURL(filePath).toString();
-                try {
-                    const text = fs.readFileSync(filePath, "utf-8");
-                    const { analysis } = analyzeWithAst(text, fileUri);
-                    records.set(fileUri, { uri: fileUri, text, analysis: withPredeclaredNs(analysis, predeclaredNs) });
-                }
-                catch {
-                    /* unreadable file, skip */
-                }
-            }
-            globFileRecordsByConfigDir.set(configDir, records);
-        }
-        return [...globFileRecordsByConfigDir.get(configDir).values()];
+    const predeclaredNs = getRuntimePredeclaredNamespaces(config.lib);
+    return {
+        getOtherFiles: () => [...getGlobFileSummaries(configDir, config).values()].map((r) => ({ ...r, analysis: withPredeclaredNs(r.analysis, predeclaredNs) })),
+        loadAst: (uri, text) => {
+            const cached = analysisCache.get(uri);
+            if (cached?.ast)
+                return withPredeclaredNs(cached, predeclaredNs);
+            const { analysis } = analyzeWithAst(text, uri);
+            return withPredeclaredNs(analysis, predeclaredNs);
+        },
     };
 }
 function resolveContext(currentUri, rawAnalysis) {
@@ -324,7 +352,7 @@ connection.onWorkspaceSymbol((params) => {
     // No single document anchors a workspace-wide request, so gather config dirs from every open document.
     const filesByUri = new Map();
     for (const doc of documents.all()) {
-        for (const file of getGlobFileRecords(doc.uri)())
+        for (const file of getGlobFileAccess(doc.uri).getOtherFiles())
             filesByUri.set(file.uri, file);
     }
     return getWorkspaceSymbols([...filesByUri.values()], params.query);
@@ -343,7 +371,8 @@ connection.onReferences((params) => {
         return [];
     const rawAnalysis = analysisCache.get(doc.uri) ?? analyzeDocument(doc);
     const { analysis } = resolveContext(doc.uri, rawAnalysis);
-    return getReferences(doc.uri, doc.getText(), doc.offsetAt(params.position), analysis, params.context.includeDeclaration, getGlobFileRecords(doc.uri));
+    const { getOtherFiles, loadAst } = getGlobFileAccess(doc.uri);
+    return getReferences(doc.uri, doc.getText(), doc.offsetAt(params.position), analysis, params.context.includeDeclaration, getOtherFiles, loadAst);
 });
 const NCNAME_RE = /^[A-Za-z_][\w.-]*$/;
 connection.onPrepareRename((params) => {
@@ -366,7 +395,8 @@ connection.onRenameRequest((params) => {
     }
     const rawAnalysis = analysisCache.get(doc.uri) ?? analyzeDocument(doc);
     const { analysis } = resolveContext(doc.uri, rawAnalysis);
-    const locations = getRenameLocations(doc.uri, doc.getText(), doc.offsetAt(params.position), analysis, getGlobFileRecords(doc.uri));
+    const { getOtherFiles, loadAst } = getGlobFileAccess(doc.uri);
+    const locations = getRenameLocations(doc.uri, doc.getText(), doc.offsetAt(params.position), analysis, getOtherFiles, loadAst);
     if (!locations)
         return null;
     const changes = {};
@@ -408,7 +438,8 @@ connection.onCodeLensResolve((lens) => {
         return { ...lens, command: { title: "0 references", command: "" } };
     const rawAnalysis = analysisCache.get(doc.uri) ?? analyzeDocument(doc);
     const { analysis } = resolveContext(doc.uri, rawAnalysis);
-    return resolveCodeLens(lens, doc.getText(), analysis, getGlobFileRecords(doc.uri));
+    const { getOtherFiles, loadAst } = getGlobFileAccess(doc.uri);
+    return resolveCodeLens(lens, doc.getText(), analysis, getOtherFiles, loadAst);
 });
 connection.onDocumentLinks((params) => {
     const doc = documents.get(params.textDocument.uri);
@@ -431,7 +462,8 @@ connection.languages.callHierarchy.onIncomingCalls((params) => {
     if (!loaded)
         return null;
     const { analysis } = resolveContext(params.item.uri, loaded.analysis);
-    return getIncomingCalls(params.item, loaded.text, analysis, getGlobFileRecords(params.item.uri));
+    const { getOtherFiles, loadAst } = getGlobFileAccess(params.item.uri);
+    return getIncomingCalls(params.item, loaded.text, analysis, getOtherFiles, loadAst);
 });
 connection.languages.callHierarchy.onOutgoingCalls((params) => {
     const loaded = loadAnalysisForUri(params.item.uri);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xq-lsp",
-	"version": "1.8.0",
+	"version": "1.8.1",
 	"description": "XQuery Language Server Protocol implementation",
 	"license": "MIT",
 	"author": "Martin Middel",

package/src/call-hierarchy.ts

@@ -10,7 +10,7 @@ import { findAll, directChildOf, nodeStackAtOffset } from "./analyzer.ts";
 import { asFunctionDecl, asFunctionCall } from "./ast-nodes.ts";
 import { resolveFunctionAtOffset, allFunctions } from "./hover-core.ts";
 import { getReferences } from "./references.ts";
-import type { FileRecord } from "./references.ts";
+import type { FileRecord, LoadAst } from "./references.ts";
 
 /** Identifies the function a CallHierarchyItem refers to, round-tripped via `item.data`. */
 interface CallHierarchyFunctionData {
@@ -180,34 +180,47 @@ export function getIncomingCalls(
 	itemText: string,
 	itemAnalysis: FileAnalysis,
 	getOtherFiles: () => FileRecord[],
+	loadAst: LoadAst,
 ): CallHierarchyIncomingCall[] {
 	const offset = toOffset(itemText, item.selectionRange.start);
 	// includeDeclaration:false — we only want actual call sites, not the declaration itself.
-	const callSites = getReferences(item.uri, itemText, offset, itemAnalysis, false, getOtherFiles);
+	const callSites = getReferences(item.uri, itemText, offset, itemAnalysis, false, getOtherFiles, loadAst);
 	if (callSites.length === 0) return [];
 
-	const fileByUri = new Map<string, FileRecord>(getOtherFiles().map((f) => [f.uri, f]));
-	if (!fileByUri.has(item.uri)) fileByUri.set(item.uri, { uri: item.uri, text: itemText, analysis: itemAnalysis });
+	// getOtherFiles() returns cached, ast-free records — cheap to re-iterate for a uri->text
+	// lookup. The full (ast-bearing) analysis for each call site's file is fetched below, once
+	// per distinct uri, via loadAst.
+	const textByUri = new Map<string, string>([[item.uri, itemText]]);
+	for (const file of getOtherFiles()) if (!textByUri.has(file.uri)) textByUri.set(file.uri, file.text);
 
+	const analysisByUri = new Map<string, FileAnalysis>([[item.uri, itemAnalysis]]);
 	const groups = new Map<string, { from: CallHierarchyItem; ranges: Range[] }>();
 
 	for (const loc of callSites) {
-		const record = fileByUri.get(loc.uri);
-		if (!record?.analysis.ast) continue;
+		const text = textByUri.get(loc.uri);
+		if (text === undefined) continue;
+		let fileAnalysis = analysisByUri.get(loc.uri);
+		if (!fileAnalysis) {
+			const loaded = loadAst(loc.uri, text);
+			if (!loaded) continue;
+			fileAnalysis = loaded;
+			analysisByUri.set(loc.uri, fileAnalysis);
+		}
+		if (!fileAnalysis.ast) continue;
 
-		const callOffset = toOffset(record.text, loc.range.start);
-		const stack = nodeStackAtOffset(record.analysis.ast, callOffset);
+		const callOffset = toOffset(text, loc.range.start);
+		const stack = nodeStackAtOffset(fileAnalysis.ast, callOffset);
 		// Function declarations can't nest in XQuery, so at most one AnnotatedDecl/FunctionDecl
 		// pair appears in the stack; a call at module level (no enclosing function) has none.
 		const enclosingDecl = stack.find((n) => n.type === "AnnotatedDecl" && directChildOf(n, "FunctionDecl"));
 		if (!enclosingDecl) continue;
-		const enclosingFn = record.analysis.functions.find((f) => f.sourceOffset === enclosingDecl.start);
+		const enclosingFn = fileAnalysis.functions.find((f) => f.sourceOffset === enclosingDecl.start);
 		if (!enclosingFn) continue;
 
 		const key = `${qnameKey(enclosingFn.qname)}#${enclosingFn.arity}@${loc.uri}`;
 		let group = groups.get(key);
 		if (!group) {
-			const from = buildItemForFunction(enclosingFn, record.analysis, loc.uri, record.text);
+			const from = buildItemForFunction(enclosingFn, fileAnalysis, loc.uri, text);
 			if (!from) continue;
 			group = { from, ranges: [] };
 			groups.set(key, group);

package/src/code-lens.ts

@@ -5,7 +5,7 @@ import type { FileAnalysis } from "./types.ts";
 import { findAll } from "./analyzer.ts";
 import { asFunctionDeclaration, asVarDecl } from "./ast-nodes.ts";
 import { getReferences } from "./references.ts";
-import type { FileRecord } from "./references.ts";
+import type { FileRecord, LoadAst } from "./references.ts";
 
 /** Carried on each unresolved lens so `resolveCodeLens` can find the declaration again later. */
 export interface CodeLensData {
@@ -74,11 +74,17 @@ function findNameOffset(ast: Node, analysis: FileAnalysis, data: CodeLensData):
  * reference search `textDocument/references` uses. Declarations aren't counted as
  * references. 0 references is reported as-is — it's a useful signal, not hidden.
  */
-export function resolveCodeLens(lens: CodeLens, text: string, analysis: FileAnalysis, getOtherFiles: () => FileRecord[]): CodeLens {
+export function resolveCodeLens(
+	lens: CodeLens,
+	text: string,
+	analysis: FileAnalysis,
+	getOtherFiles: () => FileRecord[],
+	loadAst: LoadAst,
+): CodeLens {
 	const data = lens.data as CodeLensData | undefined;
 	const ast = analysis.ast;
 	const offset = data && ast ? findNameOffset(ast, analysis, data) : null;
-	const count = data && offset !== null ? getReferences(data.uri, text, offset, analysis, false, getOtherFiles).length : 0;
+	const count = data && offset !== null ? getReferences(data.uri, text, offset, analysis, false, getOtherFiles, loadAst).length : 0;
 
 	return { ...lens, command: { title: `${count} references`, command: "" } };
 }

package/src/references.ts

@@ -320,6 +320,15 @@ function getPrefixReferences(
 
 // ── Cross-file orchestration ──────────────────────────────────────────────────
 
+/**
+ * Parses one glob-matched file's full AST on demand for a cross-file occurrence walk.
+ * Reuses `analysisCache` (open documents, explicit imports) when the file is already
+ * resident; otherwise parses fresh and returns without caching the result, so a
+ * cross-file search never retains more than the file currently being walked. See
+ * `getGlobFileAccess` in server.ts.
+ */
+export type LoadAst = (uri: string, text: string) => FileAnalysis | null;
+
 function getVariableReferences(
 	currentUri: string,
 	currentText: string,
@@ -328,6 +337,7 @@ function getVariableReferences(
 	offset: number,
 	includeDeclaration: boolean,
 	getOtherFiles: () => FileRecord[],
+	loadAst: LoadAst,
 	trimToLocalName = false,
 ): Location[] {
 	const occurrences: VarOccurrence[] = [];
@@ -359,9 +369,14 @@ function getVariableReferences(
 	}));
 
 	for (const file of getOtherFiles()) {
-		if (file.uri === currentUri || !file.analysis.ast) continue;
+		// Cheap pre-filter: localName always appears verbatim in source regardless of EQName
+		// syntax (prefixed, URIQualified, or unprefixed), so its absence rules out a match
+		// without needing to parse the file at all.
+		if (file.uri === currentUri || !file.text.includes(localName)) continue;
+		const fileAnalysis = loadAst(file.uri, file.text);
+		if (!fileAnalysis?.ast) continue;
 		const fileOccs: VarOccurrence[] = [];
-		walkVariables(file.analysis.ast, file.analysis, new ScopeStack(), fileOccs);
+		walkVariables(fileAnalysis.ast, fileAnalysis, new ScopeStack(), fileOccs);
 		for (const o of matches(fileOccs)) all.push({ uri: file.uri, text: file.text, o });
 	}
 
@@ -379,6 +394,7 @@ function getFunctionReferences(
 	offset: number,
 	includeDeclaration: boolean,
 	getOtherFiles: () => FileRecord[],
+	loadAst: LoadAst,
 	trimToLocalName = false,
 ): Location[] {
 	const occurrences: FnOccurrence[] = [];
@@ -399,9 +415,11 @@ function getFunctionReferences(
 	}));
 
 	for (const file of getOtherFiles()) {
-		if (file.uri === currentUri || !file.analysis.ast) continue;
+		if (file.uri === currentUri || !file.text.includes(localName)) continue;
+		const fileAnalysis = loadAst(file.uri, file.text);
+		if (!fileAnalysis?.ast) continue;
 		const fileOccs: FnOccurrence[] = [];
-		walkFunctions(file.analysis.ast, file.analysis, fileOccs);
+		walkFunctions(fileAnalysis.ast, fileAnalysis, fileOccs);
 		for (const o of matches(fileOccs)) all.push({ uri: file.uri, text: file.text, o });
 	}
 
@@ -466,7 +484,9 @@ function prefixHasDeclaration(analysis: FileAnalysis, prefix: string): boolean {
  * Requires a valid AST (returns `[]` on the regex-fallback path, since parse
  * failures don't produce reliable node positions).
  * `getOtherFiles` is only invoked for symbol kinds that need a cross-file
- * search, so callers can make it lazy.
+ * search, so callers can make it lazy. `getOtherFiles` returns lightweight,
+ * ast-free records for cheap candidate filtering; `loadAst` parses a specific
+ * candidate's full AST on demand once it survives that filter (see `LoadAst`).
  */
 export function getReferences(
 	currentUri: string,
@@ -475,6 +495,7 @@ export function getReferences(
 	analysis: FileAnalysis,
 	includeDeclaration: boolean,
 	getOtherFiles: () => FileRecord[],
+	loadAst: LoadAst,
 ): Location[] {
 	const ast = analysis.ast;
 	if (!ast) return [];
@@ -483,8 +504,9 @@ export function getReferences(
 	if (!target) return [];
 
 	if (target.kind === "prefix") return getPrefixReferences(currentUri, currentText, ast, analysis, target.prefix, includeDeclaration);
-	if (target.kind === "variable") return getVariableReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles);
-	return getFunctionReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles);
+	if (target.kind === "variable")
+		return getVariableReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles, loadAst);
+	return getFunctionReferences(currentUri, currentText, ast, analysis, offset, includeDeclaration, getOtherFiles, loadAst);
 }
 
 /**
@@ -523,6 +545,7 @@ export function getRenameLocations(
 	offset: number,
 	analysis: FileAnalysis,
 	getOtherFiles: () => FileRecord[],
+	loadAst: LoadAst,
 ): Location[] | null {
 	const ast = analysis.ast;
 	if (!ast) return null;
@@ -537,8 +560,8 @@ export function getRenameLocations(
 
 	const locs =
 		target.kind === "variable"
-			? getVariableReferences(currentUri, currentText, ast, analysis, offset, true, getOtherFiles, true)
-			: getFunctionReferences(currentUri, currentText, ast, analysis, offset, true, getOtherFiles, true);
+			? getVariableReferences(currentUri, currentText, ast, analysis, offset, true, getOtherFiles, loadAst, true)
+			: getFunctionReferences(currentUri, currentText, ast, analysis, offset, true, getOtherFiles, loadAst, true);
 
 	return locs.length > 0 ? locs : null;
 }

package/src/server.ts

@@ -23,12 +23,13 @@ import { getDefinition } from "./definition.ts";
 import { getDocumentLinks } from "./document-links.ts";
 import { getInlayHints } from "./inlay-hints.ts";
 import { getReferences, getRenameRangeAtOffset, getRenameLocations, getDocumentHighlights } from "./references.ts";
-import type { FileRecord } from "./references.ts";
+import type { FileRecord, LoadAst } from "./references.ts";
 import { buildCodeLenses, resolveCodeLens } from "./code-lens.ts";
 import type { CodeLensData } from "./code-lens.ts";
 import { prepareCallHierarchy, getIncomingCalls, getOutgoingCalls } from "./call-hierarchy.ts";
 import type { FileAnalysis, TypeDiagnostic } from "./types.ts";
 import { findConfig, expandGlobs } from "./config.ts";
+import type { LspConfig } from "./config.ts";
 import { findImportInsertPosition, findDeclareNsInsertPosition, computeRelativePath } from "./namespace-diagnostics.ts";
 import type { NamespaceUsageKind } from "./namespace-diagnostics.ts";
 import { findUndeclaredPrefixUsages } from "./namespace-diagnostics.ts";
@@ -138,6 +139,40 @@ function mergeAnalyses(a: FileAnalysis, b: FileAnalysis): FileAnalysis {
 	};
 }
 
+// Lightweight (ast-free) per-file records for every glob-matched file: source text plus the
+// *extracted* FileAnalysis (functions, module variables, imports, namespace decls, ...), with
+// the AST itself dropped once those fields are pulled out. xq-parser's AST runs roughly two
+// orders of magnitude larger than the source text — XQuery's operator-precedence grammar wraps
+// even a bare `$x` variable reference in ~30 levels of single-child wrapper nodes, none of them
+// collapsed — so retaining a full AST for every glob-matched file (often hundreds, only a
+// handful of which anyone is actually looking at) is the dominant memory cost of any glob-backed
+// feature. None of the FileAnalysis fields other than `.ast` hold node references (they're all
+// plain offsets/strings — see types.ts), so dropping `.ast` after extraction is safe: nothing
+// downstream keeps the tree reachable. Populated lazily per config dir; never invalidated.
+const globFileSummariesByConfigDir = new Map<string, Map<string, FileRecord>>();
+
+function buildGlobFileSummaries(config: LspConfig, configDir: string): Map<string, FileRecord> {
+	const records = new Map<string, FileRecord>();
+	for (const filePath of expandGlobs(config.globs, configDir)) {
+		const fileUri = pathToFileURL(filePath).toString();
+		try {
+			const text = fs.readFileSync(filePath, "utf-8");
+			const { analysis } = analyzeWithAst(text, fileUri);
+			records.set(fileUri, { uri: fileUri, text, analysis: { ...analysis, ast: undefined } });
+		} catch {
+			/* unreadable file, skip */
+		}
+	}
+	return records;
+}
+
+function getGlobFileSummaries(configDir: string, config: LspConfig): Map<string, FileRecord> {
+	if (!globFileSummariesByConfigDir.has(configDir)) {
+		globFileSummariesByConfigDir.set(configDir, buildGlobFileSummaries(config, configDir));
+	}
+	return globFileSummariesByConfigDir.get(configDir)!;
+}
+
 function getGlobAnalyses(currentUri: string): { byNamespace: Map<string, FileAnalysis>; lib: string[] } {
 	const found = findConfig(currentUri);
 	if (!found) return { byNamespace: new Map(), lib: [] };
@@ -150,43 +185,38 @@ function getGlobAnalyses(currentUri: string): { byNamespace: Map<string, FileAna
 	}
 
 	const byNamespace = new Map<string, FileAnalysis>();
-	for (const filePath of expandGlobs(config.globs, configDir)) {
-		const fileUri = pathToFileURL(filePath).toString();
-		const imported = getImportedAnalysis(fileUri);
-		if (!imported?.moduleNamespaceUri) continue;
-		const existing = byNamespace.get(imported.moduleNamespaceUri);
-		byNamespace.set(imported.moduleNamespaceUri, existing ? mergeAnalyses(existing, imported) : imported);
+	for (const { analysis } of getGlobFileSummaries(configDir, config).values()) {
+		if (!analysis.moduleNamespaceUri) continue;
+		const existing = byNamespace.get(analysis.moduleNamespaceUri);
+		byNamespace.set(analysis.moduleNamespaceUri, existing ? mergeAnalyses(existing, analysis) : analysis);
 	}
 	globAnalysesByConfigDir.set(configDir, byNamespace);
 	return { byNamespace, lib };
 }
 
-// Per-file (not merged-by-namespace) glob analyses, for cross-file reference search.
-// Keyed by config directory; populated lazily and never invalidated, mirroring globAnalysesByConfigDir.
-const globFileRecordsByConfigDir = new Map<string, Map<string, FileRecord>>();
-
-function getGlobFileRecords(currentUri: string): () => FileRecord[] {
+/**
+ * Cross-file access for find-references / rename / call-hierarchy: `getOtherFiles` returns the
+ * cached, ast-free summaries above for cheap candidate filtering (see references.ts's text
+ * pre-filter); `loadAst` parses one specific candidate's full AST on demand, once it survives
+ * that filter, reusing `analysisCache` when the file is already resident (open document, or
+ * explicitly imported elsewhere) instead of re-parsing. The parsed result is intentionally NOT
+ * cached here — a cross-file search should never retain more than the handful of files it's
+ * actually walking.
+ */
+function getGlobFileAccess(currentUri: string): { getOtherFiles: () => FileRecord[]; loadAst: LoadAst } {
 	const found = findConfig(currentUri);
-	if (!found) return () => [];
+	if (!found) return { getOtherFiles: () => [], loadAst: () => null };
 	const { config, configDir } = found;
+	const predeclaredNs = getRuntimePredeclaredNamespaces(config.lib);
 
-	return () => {
-		if (!globFileRecordsByConfigDir.has(configDir)) {
-			const predeclaredNs = getRuntimePredeclaredNamespaces(config.lib);
-			const records = new Map<string, FileRecord>();
-			for (const filePath of expandGlobs(config.globs, configDir)) {
-				const fileUri = pathToFileURL(filePath).toString();
-				try {
-					const text = fs.readFileSync(filePath, "utf-8");
-					const { analysis } = analyzeWithAst(text, fileUri);
-					records.set(fileUri, { uri: fileUri, text, analysis: withPredeclaredNs(analysis, predeclaredNs) });
-				} catch {
-					/* unreadable file, skip */
-				}
-			}
-			globFileRecordsByConfigDir.set(configDir, records);
-		}
-		return [...globFileRecordsByConfigDir.get(configDir)!.values()];
+	return {
+		getOtherFiles: () => [...getGlobFileSummaries(configDir, config).values()].map((r) => ({ ...r, analysis: withPredeclaredNs(r.analysis, predeclaredNs) })),
+		loadAst: (uri: string, text: string) => {
+			const cached = analysisCache.get(uri);
+			if (cached?.ast) return withPredeclaredNs(cached, predeclaredNs);
+			const { analysis } = analyzeWithAst(text, uri);
+			return withPredeclaredNs(analysis, predeclaredNs);
+		},
 	};
 }
 
@@ -383,7 +413,7 @@ connection.onWorkspaceSymbol((params) => {
 	// No single document anchors a workspace-wide request, so gather config dirs from every open document.
 	const filesByUri = new Map<string, FileRecord>();
 	for (const doc of documents.all()) {
-		for (const file of getGlobFileRecords(doc.uri)()) filesByUri.set(file.uri, file);
+		for (const file of getGlobFileAccess(doc.uri).getOtherFiles()) filesByUri.set(file.uri, file);
 	}
 	return getWorkspaceSymbols([...filesByUri.values()], params.query);
 });
@@ -401,14 +431,8 @@ connection.onReferences((params) => {
 	if (!doc) return [];
 	const rawAnalysis = analysisCache.get(doc.uri) ?? analyzeDocument(doc);
 	const { analysis } = resolveContext(doc.uri, rawAnalysis);
-	return getReferences(
-		doc.uri,
-		doc.getText(),
-		doc.offsetAt(params.position),
-		analysis,
-		params.context.includeDeclaration,
-		getGlobFileRecords(doc.uri),
-	);
+	const { getOtherFiles, loadAst } = getGlobFileAccess(doc.uri);
+	return getReferences(doc.uri, doc.getText(), doc.offsetAt(params.position), analysis, params.context.includeDeclaration, getOtherFiles, loadAst);
 });
 
 const NCNAME_RE = /^[A-Za-z_][\w.-]*$/;
@@ -431,13 +455,8 @@ connection.onRenameRequest((params) => {
 	}
 	const rawAnalysis = analysisCache.get(doc.uri) ?? analyzeDocument(doc);
 	const { analysis } = resolveContext(doc.uri, rawAnalysis);
-	const locations = getRenameLocations(
-		doc.uri,
-		doc.getText(),
-		doc.offsetAt(params.position),
-		analysis,
-		getGlobFileRecords(doc.uri),
-	);
+	const { getOtherFiles, loadAst } = getGlobFileAccess(doc.uri);
+	const locations = getRenameLocations(doc.uri, doc.getText(), doc.offsetAt(params.position), analysis, getOtherFiles, loadAst);
 	if (!locations) return null;
 
 	const changes: Record<string, TextEdit[]> = {};
@@ -478,7 +497,8 @@ connection.onCodeLensResolve((lens) => {
 	if (!doc) return { ...lens, command: { title: "0 references", command: "" } };
 	const rawAnalysis = analysisCache.get(doc.uri) ?? analyzeDocument(doc);
 	const { analysis } = resolveContext(doc.uri, rawAnalysis);
-	return resolveCodeLens(lens, doc.getText(), analysis, getGlobFileRecords(doc.uri));
+	const { getOtherFiles, loadAst } = getGlobFileAccess(doc.uri);
+	return resolveCodeLens(lens, doc.getText(), analysis, getOtherFiles, loadAst);
 });
 
 connection.onDocumentLinks((params) => {
@@ -501,7 +521,8 @@ connection.languages.callHierarchy.onIncomingCalls((params) => {
 	const loaded = loadAnalysisForUri(params.item.uri);
 	if (!loaded) return null;
 	const { analysis } = resolveContext(params.item.uri, loaded.analysis);
-	return getIncomingCalls(params.item, loaded.text, analysis, getGlobFileRecords(params.item.uri));
+	const { getOtherFiles, loadAst } = getGlobFileAccess(params.item.uri);
+	return getIncomingCalls(params.item, loaded.text, analysis, getOtherFiles, loadAst);
 });
 
 connection.languages.callHierarchy.onOutgoingCalls((params) => {