xq-lsp 1.8.2 → 1.8.3-next.430

package/dist/module-siblings.js

@@ -0,0 +1,16 @@
+/**
+ * The declarations that *other* files contribute to a module namespace. XQuery lets one module be
+ * implemented by several module files sharing a target namespace, and some runtimes (e.g. Fonto)
+ * merge them, so a file can call a function declared in a sibling without importing it.
+ *
+ * `merged` is the glob index entry for the namespace, which may include the current file's own
+ * on-disk declarations. Those are dropped so they aren't reported as duplicates of the (possibly
+ * edited) in-memory versions, nor resolved to stale positions. Returns null when nothing is left.
+ */
+export function siblingModuleAnalysis(merged, currentUri) {
+    const functions = merged.functions.filter((f) => f.sourceUri !== currentUri);
+    const moduleVariables = merged.moduleVariables.filter((v) => v.sourceUri !== currentUri);
+    if (functions.length === 0 && moduleVariables.length === 0)
+        return null;
+    return { ...merged, functions, moduleVariables };
+}

package/dist/predeclared-namespaces.js

@@ -125,6 +125,7 @@ export function getRuntimePredeclaredVariables(runtimes, sourceUri) {
         isModuleLevel: true,
         sourceUri,
         doc,
+        type: "xs:string", // all three are file system / collection paths
     }));
 }
 /**

package/dist/prolog-diagnostics.d.ts

@@ -0,0 +1,10 @@
+import type { Node } from "xq-parser";
+import type { TypeDiagnostic, FileAnalysis } from "./types.ts";
+/**
+ * Report an unsupported `xquery version` (XQST0031), serialization option
+ * misuse (XQST0108/0109/0110) and prolog components that the spec allows only once: setters such as
+ * `declare base-uri`, namespace prefixes, default element/function namespaces,
+ * decimal formats, and duplicate function parameter names.
+ * Only the second and later occurrences are flagged.
+ */
+export declare function checkDuplicatePrologDecls(ast: Node, analysis: FileAnalysis): TypeDiagnostic[];

package/dist/prolog-diagnostics.js

@@ -0,0 +1,113 @@
+import { qnameKey } from "./types.js";
+import { findAll } from "./analyzer.js";
+import { asVersionDecl, asOptionDecl, asNamespaceDecl, asDefaultNamespaceDecl, asDecimalFormatDecl, asFunctionDecl, asInlineFunctionExpr, } from "./ast-nodes.js";
+/** The second and later items sharing a key with an earlier item. */
+function repeats(items, key) {
+    const seen = new Set();
+    return items.filter((item) => {
+        const k = key(item);
+        if (seen.has(k))
+            return true;
+        seen.add(k);
+        return false;
+    });
+}
+function diagnostic(node, code, message) {
+    const start = node.start ?? 0;
+    return { message, code, offset: start, length: (node.end ?? start) - start };
+}
+/** Setter declarations that may appear at most once per prolog. */
+const SINGLE_USE_DECLS = [
+    { type: "BaseURIDecl", code: "XQST0032", what: "base URI" },
+    { type: "DefaultCollationDecl", code: "XQST0038", what: "default collation" },
+    { type: "OrderingModeDecl", code: "XQST0065", what: "ordering mode" },
+    { type: "ConstructionDecl", code: "XQST0067", what: "construction mode" },
+    { type: "BoundarySpaceDecl", code: "XQST0068", what: "boundary-space policy" },
+    { type: "EmptyOrderDecl", code: "XQST0069", what: "default empty order" },
+];
+const XMLNS_OUTPUT = "http://www.w3.org/2010/xslt-xquery-serialization";
+/** Serialization parameters that may be set with `declare option output:*` (use-character-maps may not). */
+const PROLOG_SERIALIZATION_PARAMS = new Set([
+    "allow-duplicate-names",
+    "byte-order-mark",
+    "cdata-section-elements",
+    "doctype-public",
+    "doctype-system",
+    "encoding",
+    "escape-uri-attributes",
+    "html-version",
+    "include-content-type",
+    "indent",
+    "item-separator",
+    "json-node-output-method",
+    "media-type",
+    "method",
+    "normalization-form",
+    "omit-xml-declaration",
+    "parameter-document",
+    "standalone",
+    "suppress-indentation",
+    "undeclare-prefixes",
+    "version",
+]);
+const SUPPORTED_XQUERY_VERSIONS = new Set(["1.0", "3.0", "3.1", "4.0"]);
+/**
+ * Report an unsupported `xquery version` (XQST0031), serialization option
+ * misuse (XQST0108/0109/0110) and prolog components that the spec allows only once: setters such as
+ * `declare base-uri`, namespace prefixes, default element/function namespaces,
+ * decimal formats, and duplicate function parameter names.
+ * Only the second and later occurrences are flagged.
+ */
+export function checkDuplicatePrologDecls(ast, analysis) {
+    const out = [];
+    for (const node of findAll(ast, "VersionDecl")) {
+        const decl = asVersionDecl(node);
+        if (decl && !SUPPORTED_XQUERY_VERSIONS.has(decl.version))
+            out.push(diagnostic(decl.versionNode, "XQST0031", `XQuery version '${decl.version}' is not supported`));
+    }
+    const isLibraryModule = findAll(ast, "LibraryModule").length > 0;
+    const outputOptions = findAll(ast, "OptionDecl").flatMap((node) => {
+        const decl = asOptionDecl(node, analysis);
+        return decl?.qname.namespaceUri === XMLNS_OUTPUT ? [{ node, name: decl.qname.localName }] : [];
+    });
+    for (const { node, name } of outputOptions) {
+        if (isLibraryModule)
+            out.push(diagnostic(node, "XQST0108", "Serialization parameters may only be declared in a main module"));
+        else if (!PROLOG_SERIALIZATION_PARAMS.has(name))
+            out.push(diagnostic(node, "XQST0109", `'${name}' is not a serialization parameter that can be declared in the prolog`));
+    }
+    for (const { node, name } of repeats(outputOptions, (o) => o.name))
+        out.push(diagnostic(node, "XQST0110", `Serialization parameter '${name}' is declared more than once`));
+    for (const { type, code, what } of SINGLE_USE_DECLS)
+        for (const node of repeats(findAll(ast, type), () => type))
+            out.push(diagnostic(node, code, `The ${what} is declared more than once`));
+    const namespaceDecls = findAll(ast, "NamespaceDecl").flatMap((node) => {
+        const decl = asNamespaceDecl(node);
+        return decl ? [{ node, ...decl }] : [];
+    });
+    for (const { node, prefix } of repeats(namespaceDecls, (d) => d.prefix))
+        out.push(diagnostic(node, "XQST0033", `Namespace prefix '${prefix}' is declared more than once`));
+    const defaultNsDecls = findAll(ast, "DefaultNamespaceDecl").flatMap((node) => {
+        const decl = asDefaultNamespaceDecl(node);
+        return decl ? [{ node, ...decl }] : [];
+    });
+    for (const { node, kind } of repeats(defaultNsDecls, (d) => d.kind))
+        out.push(diagnostic(node, "XQST0066", `The default ${kind} namespace is declared more than once`));
+    const decimalFormats = findAll(ast, "DecimalFormatDecl").flatMap((node) => {
+        const decl = asDecimalFormatDecl(node, analysis);
+        return decl ? [{ node, ...decl }] : [];
+    });
+    for (const { node } of repeats(decimalFormats, (d) => d.key))
+        out.push(diagnostic(node, "XQST0111", "This decimal format is declared more than once"));
+    for (const { properties } of decimalFormats)
+        for (const { nameNode, name } of repeats(properties, (p) => p.name))
+            out.push(diagnostic(nameNode, "XQST0114", `Decimal-format property '${name}' is specified more than once`));
+    const paramLists = [
+        ...findAll(ast, "FunctionDecl").map((n) => asFunctionDecl(n, analysis)?.params),
+        ...findAll(ast, "InlineFunctionExpr").map((n) => asInlineFunctionExpr(n, analysis)?.params),
+    ];
+    for (const params of paramLists)
+        for (const { nameNode, qname } of repeats(params ?? [], (p) => qnameKey(p.qname)))
+            out.push(diagnostic(nameNode, "XQST0039", `Parameter '$${qname.localName}' is declared more than once`));
+    return out;
+}

package/dist/qt4-worker.js

@@ -59,13 +59,15 @@ const batch = workerData;
 const results = batch.map((tc) => {
     const got = collectCodes(tc.query, tc.envNamespaces, tc.envVariables, tc.moduleCatalog);
     const hasError = got.length > 0;
+    // A static analyzer may detect a dynamic error early: when the test expects a
+    // dynamic error (e.g. XPTY0004) and that is exactly what we reported, it's a pass.
     const outcome = tc.expected === "static-error"
         ? hasError
             ? "pass"
             : "false-negative"
-        : hasError
-            ? "false-positive"
-            : "pass";
+        : !hasError || got.every((c) => c === tc.expectedCode)
+            ? "pass"
+            : "false-positive";
     return { testSetSlug: tc.testSetSlug, testCase: tc.testCase, outcome, expectedCode: tc.expectedCode, got };
 });
 parentPort.postMessage(results);

package/dist/runtimes/fonto/fonto.xq

@@ -162,3 +162,98 @@ declare function fonto:document($remoteDocumentId as xs:string?) as node()? exte
  : @see https://documentation.fontoxml.com/latest/fonto-remote-document-state-03df124b223a
  :)
 declare function fonto:remote-document-state($remoteDocumentId as xs:string) as map(*)? external;
+
+(:~
+ : Returns the remoteDocumentId of the document that contains the given node.
+ : Throws an error when the node is not related to a document that has a remote document id.
+ : @param $node The node of which the remote document id should be looked up.
+ : @see https://documentation.fontoxml.com/latest/fonto-remote-document-id-c4f2b7d3ca21
+ :)
+declare function fonto:remote-document-id($node as node()) as xs:string external;
+
+(:~
+ : Returns the Fonto NodeId of the given node. Do not use this in operations.
+ : @param $node The node.
+ : @see https://documentation.fontoxml.com/latest/fonto-node-id-7b60a9382817
+ :)
+declare function fonto:node-id($node as node()) as xs:string external;
+
+(:~
+ : Returns true if the given node is read-only for any reason.
+ : @param $node The node to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-node-read-only-72ca327d3704
+ :)
+declare function fonto:is-node-read-only($node as node()) as xs:boolean external;
+
+(:~
+ : Returns the hierarchy source node for the given hierarchy node id.
+ : @param $hierarchyNodeId The hierarchy node id.
+ : @see https://documentation.fontoxml.com/latest/fonto-hierarchy-source-node-346968934801
+ :)
+declare function fonto:hierarchy-source-node($hierarchyNodeId as xs:string?) as node()? external;
+
+(:~
+ : Evaluates the configured hierarchyChildNodesQuery for the given node.
+ : Returns the empty sequence if no node is given or no query is configured.
+ : @param $node The node for which to retrieve the hierarchy child nodes.
+ : @see https://documentation.fontoxml.com/latest/fonto-hierarchy-child-nodes-e46c9fb8f2c0
+ :)
+declare function fonto:hierarchy-child-nodes($node as node()?) as node()* external;
+
+(:~
+ : Returns the contents of the "title" of the given node, as configured with titleQuery.
+ : @param $node The node to resolve the contents of the title of.
+ : @see https://documentation.fontoxml.com/latest/fonto-title-content-1acac0f6c610
+ :)
+declare function fonto:title-content($node as node()) as xs:string? external;
+
+(:~
+ : Returns the direction of the "title" of the given node, as configured with titleDirectionQuery.
+ : @param $node The node to resolve the direction of the title of.
+ : @see https://documentation.fontoxml.com/latest/fonto-title-content-direction-975b104b0a82
+ :)
+declare function fonto:title-content-direction($node as node()) as xs:string external;
+
+(:~
+ : Returns the effective text direction ('ltr' or 'rtl') for the given node.
+ : Returns 'ltr' when no direction is configured or no node is passed.
+ : @param $node The node for which to get the effective direction.
+ : @see https://documentation.fontoxml.com/latest/fonto-direction-193c5dccadfc
+ :)
+declare function fonto:direction($node as node()?) as xs:string external;
+
+(:~
+ : Returns true if the given node is a table according to any table definition.
+ : @param $node The node to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-table-a4faf751893d
+ :)
+declare function fonto:is-table($node as node()) as xs:boolean external;
+
+(:~
+ : Returns true if the given node is a table cell according to any table definition.
+ : @param $node The node to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-table-cell-7d82e5b1f409
+ :)
+declare function fonto:is-table-cell($node as node()) as xs:boolean external;
+
+(:~
+ : Returns true for any CALS table element (tgroup) or CALS table figure element (table).
+ : @param $node The node to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-cals-table-fd98acb9a49f
+ :)
+declare function fonto:is-cals-table($node as node()?) as xs:boolean external;
+
+(:~
+ : Returns true for any XHTML table element.
+ : @param $node The node to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-xhtml-table-5e4d4e55a9df
+ :)
+declare function fonto:is-xhtml-table($node as node()?) as xs:boolean external;
+
+(:~
+ : Returns the column specification.
+ : @param $columnSpecifications The column specifications node.
+ : @param $columnIdentifier The column identifier.
+ : @see https://documentation.fontoxml.com/latest/fonto-column-spec-0d3684963eb6
+ :)
+declare function fonto:column-spec($columnSpecifications as node(), $columnIdentifier as xs:string) as item()? external;

package/dist/semantic-tokens.d.ts

@@ -0,0 +1,29 @@
+import type { Node } from "xq-parser";
+import type { FileAnalysis } from "./types.ts";
+export declare const TOKEN_TYPES: readonly ["namespace", "function", "parameter", "variable"];
+export declare const TOKEN_MODIFIERS: readonly ["defaultLibrary", "unused"];
+export type SemanticTokenType = (typeof TOKEN_TYPES)[number];
+export type SemanticTokenModifier = (typeof TOKEN_MODIFIERS)[number];
+export declare const SEMANTIC_TOKENS_LEGEND: {
+    tokenTypes: ("function" | "variable" | "namespace" | "parameter")[];
+    tokenModifiers: ("defaultLibrary" | "unused")[];
+};
+export interface EncodedToken {
+    line: number;
+    character: number;
+    length: number;
+    tokenType: number;
+    tokenModifiers: number;
+}
+/**
+ * Delta-encode already-positioned tokens into the flat array required by
+ * `SemanticTokens.data` (see the LSP spec's `textDocument/semanticTokens/full`).
+ * Tokens are sorted by (line, character) first since the format is cumulative.
+ */
+export declare function encodeSemanticTokens(tokens: EncodedToken[]): number[];
+/**
+ * Walk the AST once and produce the delta-encoded `data` array for
+ * `textDocument/semanticTokens/full`. Returns `[]` when `ast` is null
+ * (the file failed to parse — the regex-fallback analysis has no AST to walk).
+ */
+export declare function getSemanticTokensData(ast: Node | null, text: string, analysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>): number[];

package/dist/semantic-tokens.js

@@ -0,0 +1,254 @@
+import { isTerminal, directChildOf, directChildrenOf, firstTerminalValue, BUILTIN_PREFIXES } from "./analyzer.js";
+import { asFunctionCall, asNamedFunctionRef, asFunctionDecl, asVarDecl } from "./ast-nodes.js";
+import { checkUnused } from "./unused-diagnostics.js";
+// ── Legend ────────────────────────────────────────────────────────────────────
+export const TOKEN_TYPES = ["namespace", "function", "parameter", "variable"];
+export const TOKEN_MODIFIERS = ["defaultLibrary", "unused"];
+export const SEMANTIC_TOKENS_LEGEND = {
+    tokenTypes: [...TOKEN_TYPES],
+    tokenModifiers: [...TOKEN_MODIFIERS],
+};
+const TOKEN_TYPE_INDEX = Object.fromEntries(TOKEN_TYPES.map((t, i) => [t, i]));
+const TOKEN_MODIFIER_BIT = Object.fromEntries(TOKEN_MODIFIERS.map((m, i) => [m, 1 << i]));
+function modifierBitmask(mods) {
+    return mods.reduce((acc, m) => acc | TOKEN_MODIFIER_BIT[m], 0);
+}
+/**
+ * Delta-encode already-positioned tokens into the flat array required by
+ * `SemanticTokens.data` (see the LSP spec's `textDocument/semanticTokens/full`).
+ * Tokens are sorted by (line, character) first since the format is cumulative.
+ */
+export function encodeSemanticTokens(tokens) {
+    const sorted = [...tokens].sort((a, b) => a.line - b.line || a.character - b.character);
+    const data = [];
+    let prevLine = 0;
+    let prevChar = 0;
+    for (const t of sorted) {
+        const deltaLine = t.line - prevLine;
+        const deltaChar = deltaLine === 0 ? t.character - prevChar : t.character;
+        data.push(deltaLine, deltaChar, t.length, t.tokenType, t.tokenModifiers);
+        prevLine = t.line;
+        prevChar = t.character;
+    }
+    return data;
+}
+// ── Offset → line/character ──────────────────────────────────────────────────
+function computeLineStarts(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++)
+        if (text[i] === "\n")
+            starts.push(i + 1);
+    return starts;
+}
+function offsetToPosition(lineStarts, offset) {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineStarts[mid] <= offset)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return { line: lo, character: offset - lineStarts[lo] };
+}
+/** Mirrors resolvePrefix's precedence order (analyzer.ts) without re-resolving the URI. */
+function isDefaultLibraryPrefix(prefix, analysis) {
+    if (analysis.imports.some((i) => i.prefix === prefix))
+        return false;
+    if (prefix === analysis.modulePrefix && analysis.moduleNamespaceUri)
+        return false;
+    const nd = analysis.namespaceDecls.find((n) => n.prefix === prefix);
+    if (nd)
+        return nd.offset === -1; // runtime-injected predeclared namespace, e.g. eXist-db
+    return prefix in BUILTIN_PREFIXES;
+}
+const builtinKey = (q) => `${q.namespaceUri}|${q.localName}`;
+function buildBuiltinKeys(analysis, importedAnalyses) {
+    const keys = new Set();
+    for (const a of [analysis, ...importedAnalyses.values()])
+        for (const f of a.functions)
+            if (f.sourceUri.startsWith("builtin:"))
+                keys.add(builtinKey(f.qname));
+    return keys;
+}
+/** Splits a raw EQName/VarName/FunctionEQName node's text into its prefix and local-name spans. */
+function splitPrefixedName(node) {
+    const raw = firstTerminalValue(node);
+    if (!raw)
+        return null;
+    if (raw.startsWith("Q{")) {
+        const close = raw.indexOf("}");
+        if (close < 0)
+            return null;
+        return { local: { offset: node.start + close + 1, length: raw.length - close - 1 } };
+    }
+    const colon = raw.indexOf(":");
+    if (colon <= 0)
+        return { local: { offset: node.start, length: raw.length } };
+    return {
+        prefix: { offset: node.start, length: colon },
+        local: { offset: node.start + colon + 1, length: raw.length - colon - 1 },
+    };
+}
+function pushNameTokens(node, kind, analysis, modifiers, out) {
+    const split = splitPrefixedName(node);
+    if (!split)
+        return;
+    if (split.prefix) {
+        const raw = firstTerminalValue(node) ?? "";
+        const prefixText = raw.slice(0, split.prefix.length);
+        const nsModifiers = isDefaultLibraryPrefix(prefixText, analysis) ? ["defaultLibrary"] : [];
+        out.push({ offset: split.prefix.offset, length: split.prefix.length, type: "namespace", modifiers: nsModifiers });
+    }
+    out.push({ offset: split.local.offset, length: split.local.length, type: kind, modifiers });
+}
+/** Element/attribute constructors: only the namespace-prefix part is classifiable (no "element" token type). */
+function pushNamespaceOnly(node, analysis, out) {
+    if (!node)
+        return;
+    const raw = firstTerminalValue(node);
+    if (!raw || raw.startsWith("Q{") || raw.startsWith("xmlns"))
+        return;
+    const colon = raw.indexOf(":");
+    if (colon <= 0)
+        return;
+    const modifiers = isDefaultLibraryPrefix(raw.slice(0, colon), analysis) ? ["defaultLibrary"] : [];
+    out.push({ offset: node.start, length: colon, type: "namespace", modifiers });
+}
+function buildUnusedOffsets(ast, analysis) {
+    const offsets = new Set();
+    for (const d of checkUnused(ast, analysis))
+        if (d.code === "xq-lsp:unused-function" || d.code === "xq-lsp:unused-variable")
+            offsets.add(d.offset);
+    return offsets;
+}
+// ── AST walk ──────────────────────────────────────────────────────────────────
+function walk(node, analysis, builtinKeys, unusedOffsets, out) {
+    if (isTerminal(node))
+        return;
+    const { children } = node;
+    switch (node.type) {
+        case "FunctionCall": {
+            const call = asFunctionCall(node, analysis);
+            const eqname = directChildOf(node, "FunctionEQName");
+            if (call && eqname) {
+                const mods = builtinKeys.has(builtinKey(call.qname)) ? ["defaultLibrary"] : [];
+                pushNameTokens(eqname, "function", analysis, mods, out);
+            }
+            for (const c of children)
+                walk(c, analysis, builtinKeys, unusedOffsets, out);
+            return;
+        }
+        case "NamedFunctionRef": {
+            const ref = asNamedFunctionRef(node, analysis);
+            const eqname = directChildOf(node, "EQName");
+            if (ref && eqname) {
+                const mods = builtinKeys.has(builtinKey(ref.qname)) ? ["defaultLibrary"] : [];
+                pushNameTokens(eqname, "function", analysis, mods, out);
+            }
+            return;
+        }
+        case "VarRef": {
+            const varNameNode = directChildOf(node, "VarName");
+            if (varNameNode)
+                pushNameTokens(varNameNode, "variable", analysis, [], out);
+            return;
+        }
+        case "AnnotatedDecl": {
+            const fnDeclNode = directChildOf(node, "FunctionDecl");
+            if (fnDeclNode) {
+                const fn = asFunctionDecl(fnDeclNode, analysis);
+                if (fn) {
+                    const mods = unusedOffsets.has(fn.nameNode.start) ? ["unused"] : [];
+                    pushNameTokens(fn.nameNode, "function", analysis, mods, out);
+                    const paramList = directChildOf(fnDeclNode, "ParamList");
+                    for (const p of paramList ? directChildrenOf(paramList, "Param") : []) {
+                        const peq = directChildOf(p, "EQName");
+                        if (peq)
+                            pushNameTokens(peq, "parameter", analysis, [], out);
+                    }
+                    if (fn.body)
+                        walk(fn.body, analysis, builtinKeys, unusedOffsets, out);
+                }
+                return;
+            }
+            const varDeclNode = directChildOf(node, "VarDecl");
+            if (varDeclNode) {
+                const v = asVarDecl(varDeclNode, analysis);
+                if (v) {
+                    const mods = unusedOffsets.has(v.nameNode.start) ? ["unused"] : [];
+                    pushNameTokens(v.nameNode, "variable", analysis, mods, out);
+                }
+                for (const c of varDeclNode.children)
+                    walk(c, analysis, builtinKeys, unusedOffsets, out);
+                return;
+            }
+            for (const c of children)
+                walk(c, analysis, builtinKeys, unusedOffsets, out);
+            return;
+        }
+        case "LetBinding":
+        case "ForBinding": {
+            const varNameNode = directChildOf(node, "VarName");
+            if (varNameNode)
+                pushNameTokens(varNameNode, "variable", analysis, [], out);
+            for (const c of children)
+                if (c !== varNameNode)
+                    walk(c, analysis, builtinKeys, unusedOffsets, out);
+            return;
+        }
+        case "InlineFunctionExpr": {
+            const paramList = directChildOf(node, "ParamList");
+            for (const p of paramList ? directChildrenOf(paramList, "Param") : []) {
+                const peq = directChildOf(p, "EQName");
+                if (peq)
+                    pushNameTokens(peq, "parameter", analysis, [], out);
+            }
+            const body = directChildOf(node, "FunctionBody");
+            if (body)
+                walk(body, analysis, builtinKeys, unusedOffsets, out);
+            return;
+        }
+        case "DirElemConstructor":
+            pushNamespaceOnly(directChildOf(node, "QName"), analysis, out);
+            for (const c of children)
+                walk(c, analysis, builtinKeys, unusedOffsets, out);
+            return;
+        case "CompElemConstructor":
+        case "CompAttrConstructor":
+            pushNamespaceOnly(directChildOf(node, "EQName"), analysis, out);
+            for (const c of children)
+                walk(c, analysis, builtinKeys, unusedOffsets, out);
+            return;
+        default:
+            for (const c of children)
+                walk(c, analysis, builtinKeys, unusedOffsets, out);
+    }
+}
+// ── Public entry point ────────────────────────────────────────────────────────
+/**
+ * Walk the AST once and produce the delta-encoded `data` array for
+ * `textDocument/semanticTokens/full`. Returns `[]` when `ast` is null
+ * (the file failed to parse — the regex-fallback analysis has no AST to walk).
+ */
+export function getSemanticTokensData(ast, text, analysis, importedAnalyses) {
+    if (!ast)
+        return [];
+    const builtinKeys = buildBuiltinKeys(analysis, importedAnalyses);
+    const unusedOffsets = buildUnusedOffsets(ast, analysis);
+    const rawTokens = [];
+    walk(ast, analysis, builtinKeys, unusedOffsets, rawTokens);
+    const lineStarts = computeLineStarts(text);
+    const encoded = rawTokens.map((t) => {
+        const pos = offsetToPosition(lineStarts, t.offset);
+        return {
+            line: pos.line,
+            character: pos.character,
+            length: t.length,
+            tokenType: TOKEN_TYPE_INDEX[t.type],
+            tokenModifiers: modifierBitmask(t.modifiers),
+        };
+    });
+    return encodeSemanticTokens(encoded);
+}

package/dist/server.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createConnection, TextDocuments, ProposedFeatures, TextDocumentSyncKind, DiagnosticSeverity, CodeAction, CodeActionKind, TextEdit, ResponseError, ErrorCodes, } from "vscode-languageserver/node.js";
+import { createConnection, TextDocuments, ProposedFeatures, TextDocumentSyncKind, DiagnosticSeverity, DocumentDiagnosticReportKind, CodeAction, CodeActionKind, TextEdit, ResponseError, ErrorCodes, } from "vscode-languageserver/node.js";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import * as path from "path";
 import * as fs from "fs";
@@ -21,6 +21,8 @@ import { runDiagnostics, runHints } from "./diagnostics.js";
 import { getRuntimeAnalyses, getRuntimePredeclaredNamespaces, withPredeclaredNs, getRuntimePredeclaredVariables, withPredeclaredVariables, } from "./runtimes.js";
 import { buildOrganizeImportsEdit, buildExtractVariableEdit, buildExtractFunctionEdit } from "./refactor-actions.js";
 import { getWorkspaceSymbols } from "./workspace-symbol.js";
+import { siblingModuleAnalysis } from "./module-siblings.js";
+import { getSemanticTokensData, SEMANTIC_TOKENS_LEGEND } from "./semantic-tokens.js";
 const connection = createConnection(ProposedFeatures.all);
 const documents = new TextDocuments(TextDocument);
 const analysisCache = new Map();
@@ -215,6 +217,13 @@ function resolveContext(currentUri, rawAnalysis) {
             result.set(imp.namespaceUri, imported);
         }
     }
+    // Other files implementing the same module namespace are in scope without an import.
+    if (rawAnalysis.moduleNamespaceUri) {
+        const merged = globAnalyses.get(rawAnalysis.moduleNamespaceUri);
+        const siblings = merged && siblingModuleAnalysis(merged, currentUri);
+        if (siblings)
+            result.set(rawAnalysis.moduleNamespaceUri, siblings);
+    }
     // Add pre-declared runtime analyses directly — available without explicit import
     for (const nd of predeclaredNs) {
         if (!result.has(nd.namespaceUri)) {
@@ -257,11 +266,12 @@ connection.onInitialize((params) => {
             documentLinkProvider: { resolveProvider: false },
             callHierarchyProvider: true,
             inlayHintProvider: true,
+            diagnosticProvider: { interFileDependencies: true, workspaceDiagnostics: false },
+            semanticTokensProvider: { legend: SEMANTIC_TOKENS_LEGEND, full: true },
         },
     };
 });
-documents.onDidChangeContent((change) => {
-    const doc = change.document;
+function computeDiagnostics(doc) {
     const { analysis: rawAnalysis, parseDiagnostics: parseDiags, hasAst, ast } = analyzeDocumentFull(doc);
     const { analysis, imported: resolvedImported } = resolveContext(doc.uri, rawAnalysis);
     // Run all error-level diagnostics and hints via the central registry.
@@ -285,10 +295,25 @@ documents.onDidChangeContent((change) => {
     // nsDiags already covers XQST0081 (with the code-action data field), so exclude those here.
     const errorDiags = errorDiagRaw.filter((d) => d.code !== "XQST0081").map((d) => toLsp(d, DiagnosticSeverity.Error));
     const hintDiags = hintDiagRaw.map((d) => toLsp(d, DiagnosticSeverity.Hint));
-    connection.sendDiagnostics({
-        uri: doc.uri,
-        diagnostics: [...parseDiags, ...nsDiags, ...errorDiags, ...hintDiags],
-    });
+    return [...parseDiags, ...nsDiags, ...errorDiags, ...hintDiags];
+}
+documents.onDidChangeContent((change) => {
+    connection.sendDiagnostics({ uri: change.document.uri, diagnostics: computeDiagnostics(change.document) });
+});
+// LSP 3.17 pull diagnostics. Falls back to reading the file from disk so clients that edit
+// files outside an editor session (no didOpen) can still ask "does this file have errors?".
+connection.languages.diagnostics.on((params) => {
+    let doc = documents.get(params.textDocument.uri);
+    if (!doc) {
+        try {
+            const text = fs.readFileSync(uriToPath(params.textDocument.uri), "utf-8");
+            doc = TextDocument.create(params.textDocument.uri, "xquery", 0, text);
+        }
+        catch {
+            return { kind: DocumentDiagnosticReportKind.Full, items: [] };
+        }
+    }
+    return { kind: DocumentDiagnosticReportKind.Full, items: computeDiagnostics(doc) };
 });
 connection.onCompletion((params) => {
     const doc = documents.get(params.textDocument.uri);
@@ -479,6 +504,14 @@ function matchesOnly(kind, only) {
 function toEditRange(doc, edit) {
     return { range: { start: doc.positionAt(edit.start), end: doc.positionAt(edit.end) }, newText: edit.newText };
 }
+connection.languages.semanticTokens.on((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc)
+        return { data: [] };
+    const { analysis: rawAnalysis, ast } = analyzeDocumentFull(doc);
+    const { analysis, imported } = resolveContext(doc.uri, rawAnalysis);
+    return { data: getSemanticTokensData(ast, doc.getText(), analysis, imported) };
+});
 connection.onCodeAction((params) => {
     const doc = documents.get(params.textDocument.uri);
     if (!doc)