xq-lsp 1.4.1 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [1.6.0](https://github.com/DrRataplan/xq-lsp/compare/lsp-v1.5.0...lsp-v1.6.0) (2026-07-09)
+
+
+### Features
+
+* add diagnostics for unused imports and namespace declarations ([0ded7ba](https://github.com/DrRataplan/xq-lsp/commit/0ded7ba26b98bc308ca59cf7061f8ade197a4d13))
+* **claude-code:** add xq-lsp plugin for Claude Code ([aa96a4d](https://github.com/DrRataplan/xq-lsp/commit/aa96a4d5fdd9192e33be862608674d71e020017f))
+* **vscode:** add XQuery 4.0 syntax highlighting grammar ([f2ee489](https://github.com/DrRataplan/xq-lsp/commit/f2ee489ff1ec3ab67f9142d6c039c559d28d5e67))
+
+
+### Bug Fixes
+
+* add the $exist:* variables to the exist runtime ([4798582](https://github.com/DrRataplan/xq-lsp/commit/4798582c28f036c959432dbcca56edc81f7cca93))
+* copy runtime files to dist and inline existdb predeclared namespaces ([e98b6d6](https://github.com/DrRataplan/xq-lsp/commit/e98b6d672ba504bba5dda30980b7a58cbdfcf847))
+* **vscode:** recognize .xquery file extension ([7afc049](https://github.com/DrRataplan/xq-lsp/commit/7afc04913c1b02419c1965c489c32d09df1834b6))
+
+## [1.5.0](https://github.com/DrRataplan/xq-lsp/compare/lsp-v1.4.1...lsp-v1.5.0) (2026-06-18)
+
+
+### Features
+
+* **completion:** add function param completions with proper scope isolation ([dab41a3](https://github.com/DrRataplan/xq-lsp/commit/dab41a349ae1d387f1b32b530e476b1d30da8f07))
+* **diagnostics:** report undeclared variable references as XPST0008 ([6ff1fa9](https://github.com/DrRataplan/xq-lsp/commit/6ff1fa9d5a9ecfb4d440119f3efa9e3f96204e05))
+* eXist-db pre-declared namespaces suppress false XQST0081 diagnostics ([cd94650](https://github.com/DrRataplan/xq-lsp/commit/cd94650db968d727717de62e6a60411481a7fb16))
+
+
+### Bug Fixes
+
+* inject W3C predeclared namespaces in qt4-worker ([4c93ad6](https://github.com/DrRataplan/xq-lsp/commit/4c93ad677db0eb266e04f080ee1a1ad986dfc03a))
+* **variable-diagnostics:** add explicit type annotation to fix TS build ([5867d7e](https://github.com/DrRataplan/xq-lsp/commit/5867d7ea549026cda98559b8d980f3bdf561f32f))
+* **vscode:** make extension work by shimming import.meta.url ([fca848a](https://github.com/DrRataplan/xq-lsp/commit/fca848af51ee17a0dba8e7b95f4767c4d1ce974f))
+
 ## [1.4.1](https://github.com/DrRataplan/xq-lsp/compare/lsp-v1.4.0...lsp-v1.4.1) (2026-06-10)
 
 

package/README.md

@@ -1,9 +1,12 @@
+<img src="./logo.svg" alt="xq-lsp" width="48" height="48">
+
 # xq-lsp
 
 Language Server Protocol implementation for XQuery, providing autocompletion, hover documentation, signature help, go-to-definition, and diagnostics.
 
 ## Features
 
+- **Syntax highlighting** — keywords, types, variables, operators, comments, and XQuery 4.0 tokens (VS Code extension)
 - **Completion** — functions declared in the current file, imported modules, and variables in scope
 - **Hover** — function signatures on hover
 - **Signature help** — active parameter hints inside function calls
@@ -59,24 +62,70 @@ For files with syntax errors (common while editing), the server falls back to re
 
 Use the `lib` key to load built-in definitions for a specific runtime:
 
-| Value     | Runtime                                                             |
-| --------- | ------------------------------------------------------------------- |
-| `"fonto"` | [Fonto XML editor](https://www.fontoxml.com/) — `fonto:*` functions |
+| Value       | Runtime                                                                   |
+| ----------- | ------------------------------------------------------------------------- |
+| `"fonto"`   | [Fonto XML editor](https://www.fontoxml.com/) — `fonto:*` functions       |
+| `"existdb"` | [eXist-db](https://exist-db.org/) — all extension module functions        |
 
 ```xquery
-map {"glob": "src/**/*.xq", "lib": "fonto"}
+map {"glob": "src/**/*.xq", "lib": "existdb"}
 ```
 
-Then import the namespace in your XQuery files as usual — the server resolves completions, hover, and go-to-definition against the bundled definitions:
+Multiple libs use an XPath sequence:
 
 ```xquery
-import module namespace fonto="http://www.fontoxml.com/functions";
+map {"glob": "src/**/*.xq", "lib": ("fonto", "other")}
 ```
 
-Multiple libs use an XPath sequence:
+#### eXist-db runtime
+
+The `"existdb"` runtime bundles stub definitions for every eXist-db extension
+module (`util`, `xmldb`, `request`, `sm`, `ft`, `compression`, …).
+
+eXist-db automatically pre-declares a large set of namespace prefixes — you can
+call `util:log(…)`, `xmldb:store(…)`, `process:execute(…)`, etc. without any
+`import module namespace` statement. When the `existdb` runtime is active the
+server knows about these pre-declared prefixes and:
+
+- **suppresses** false `XQST0081` ("namespace prefix not declared") diagnostics
+  for all pre-declared namespaces
+- **provides completions, hover, and go-to-definition** for those modules
+  without requiring an explicit `import module namespace` in your source
+
+If you do choose to write explicit imports (e.g. for editor portability), the
+server handles those correctly too:
 
 ```xquery
-map {"glob": "src/**/*.xq", "lib": ("fonto", "other")}
+(: explicit import — also fine :)
+import module namespace util = "http://exist-db.org/xquery/util";
+util:uuid()
+```
+
+Modules that require explicit import even in eXist-db (e.g. `datetime`,
+`httpclient`, `console`, `crypto`, `kwic`) still need a `import module
+namespace` declaration; the server offers quick-fix code actions to insert it.
+
+```xquery
+(: lsp-config.xq in your project root :)
+map {
+    "glob": "src/**/*.xq",
+    "lib": "existdb",
+    "import": map {
+        "generateLocationHints": false()
+    }
+}
+```
+
+The `generateLocationHints: false()` setting prevents the server from appending
+`at "…"` paths to generated imports, which eXist-db does not need (it resolves
+modules by namespace URI).
+
+#### Fonto runtime
+
+Then import the namespace in your XQuery files as usual — the server resolves completions, hover, and go-to-definition against the bundled definitions:
+
+```xquery
+import module namespace fonto="http://www.fontoxml.com/functions";
 ```
 
 ### Location hints
@@ -188,4 +237,23 @@ npx vsce package
 code --install-extension xquery-lsp-vscode-*.vsix
 ```
 
-The extension registers `.xq`, `.xql`, `.xqm`, and `.xqy` files as XQuery and starts `xq-lsp` automatically when you open one.
+The extension registers `.xq`, `.xql`, `.xqm`, `.xqy`, and `.xquery` files as XQuery, provides syntax highlighting via a bundled TextMate grammar, and starts `xq-lsp` automatically when you open one.
+
+## Claude Code
+
+A plugin lives in [`editors/claude-code/`](./editors/claude-code/) that registers `xq-lsp` as a native LSP server for Claude Code, giving diagnostics, go-to-definition, find-references, and hover for XQuery files.
+
+Make sure the `xq-lsp` binary is on `PATH`:
+
+```sh
+npm install -g xq-lsp
+```
+
+Then, from within Claude Code:
+
+```
+/plugin marketplace add DrRataplan/xq-lsp
+/plugin install xquery-lsp@xq-lsp
+```
+
+See [`editors/claude-code/README.md`](./editors/claude-code/README.md) for local-development setup and details on what the plugin configures.

package/demo/favicon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" rx="7" fill="#1e1b4b"/>
+  <path d="M5 9 L11 16 L5 23" stroke="#a78bfa" stroke-width="3" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M27 9 L21 16 L27 23" stroke="#a78bfa" stroke-width="3" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
+  <circle cx="16" cy="16" r="2.5" fill="#a78bfa"/>
+</svg>

package/demo/index.html

@@ -4,6 +4,7 @@
 		<meta charset="utf-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
 		<title>xq-lsp playground</title>
+		<link rel="icon" type="image/svg+xml" href="./favicon.svg" />
 		<style>
 			* {
 				box-sizing: border-box;
@@ -132,6 +133,7 @@
 	</head>
 	<body>
 		<header>
+			<img src="./favicon.svg" alt="" width="20" height="20" />
 			<h1>xq-lsp playground</h1>
 			<button id="share-btn">Copy link</button>
 		</header>

package/demo/main.ts

@@ -11,10 +11,7 @@ import builtinsMath from "../builtins/builtins-math.xq?raw";
 import builtinsMap from "../builtins/builtins-map.xq?raw";
 import builtinsArray from "../builtins/builtins-array.xq?raw";
 import { findUndeclaredPrefixUsages } from "../src/namespace-diagnostics.ts";
-import { checkTypes } from "../src/typechecker.ts";
-import { checkFunctionCalls } from "../src/functioncall-diagnostics.ts";
-import { checkUnused } from "../src/unused-diagnostics.ts";
-import { checkContextItemUsage } from "../src/context-item-diagnostics.ts";
+import { runDiagnostics, runHints } from "../src/diagnostics.ts";
 import { type FileAnalysis } from "../src/types.ts";
 import { resolveFunctionAtOffset, resolveSignatureAtOffset, functionSignature } from "../src/hover-core.ts";
 import { getCompletions } from "../src/completion-core.ts";
@@ -238,18 +235,12 @@ const xqueryLinter = linter((view): Diagnostic[] => {
 
 	if (ast) {
 		const imported = getImported(analysis);
-		for (const d of checkTypes(ast, code, analysis, new Map())) {
-			diagnostics.push({ from: d.offset, to: d.offset + d.length, severity: "warning", message: d.message });
-		}
-		for (const d of checkFunctionCalls(ast, analysis, imported)) {
+		for (const d of runDiagnostics(ast, code, analysis, imported)) {
 			diagnostics.push({ from: d.offset, to: d.offset + d.length, severity: "error", message: d.message });
 		}
-		for (const d of checkUnused(ast, analysis)) {
+		for (const d of runHints(ast, analysis)) {
 			diagnostics.push({ from: d.offset, to: d.offset + d.length, severity: "hint", message: d.message });
 		}
-		for (const d of checkContextItemUsage(ast)) {
-			diagnostics.push({ from: d.offset, to: d.offset + d.length, severity: "error", message: d.message });
-		}
 	}
 
 	return diagnostics;

package/dist/analyzer.js

@@ -291,7 +291,7 @@ function extractNamespaceDecls(ast) {
         const namespaceUri = uriNode ? stripQuotes(firstTerminalValue(uriNode) ?? "") : null;
         if (!namespaceUri)
             continue;
-        results.push({ prefix, namespaceUri });
+        results.push({ prefix, namespaceUri, offset: ncname.start ?? nd.start ?? 0 });
     }
     return results;
 }
@@ -307,7 +307,7 @@ function extractImports(ast) {
             continue;
         const namespaceUri = stripQuotes(firstTerminalValue(uris[0]) ?? "");
         const atPath = uris.length >= 2 ? stripQuotes(firstTerminalValue(uris[1]) ?? "") : undefined;
-        results.push({ prefix, namespaceUri, atPath });
+        results.push({ prefix, namespaceUri, atPath, offset: ncname.start ?? mi.start ?? 0 });
     }
     return results;
 }
@@ -338,8 +338,8 @@ const RE_FUNC = /declare\s+(?:%[\w:\-]+(?:\([^)]*\))?\s+)*function\s+([\w:\-]+)\
 const RE_VAR_DECL = /declare\s+(?:%[\w:\-]+(?:\([^)]*\))?\s+)*variable\s+\$([\w:\-]+)/g;
 const RE_LET = /\blet\s+\$([\w:\-]+)\s*:=/g;
 const RE_FOR = /\bfor\s+\$([\w:\-]+)\s+in\b/g;
-const RE_IMPORT = /import\s+module\s+namespace\s+([\w\-]+)\s*=\s*["']([^"']*)["'](?:\s+at\s+["']([^"']*)["'])?/g;
-const RE_NS_DECL = /declare\s+namespace\s+([\w\-]+)\s*=\s*["']([^"']*)["']/g;
+const RE_IMPORT = /import\s+module\s+namespace\s+([\w\-]+)\s*=\s*["']([^"']*)["'](?:\s+at\s+["']([^"']*)["'])?/gd;
+const RE_NS_DECL = /declare\s+namespace\s+([\w\-]+)\s*=\s*["']([^"']*)["']/gd;
 function analyzeRegex(text, sourceUri) {
     const moduleVariables = [];
     const localBindings = [];
@@ -350,7 +350,8 @@ function analyzeRegex(text, sourceUri) {
     const imports = [];
     RE_IMPORT.lastIndex = 0;
     while ((m = RE_IMPORT.exec(text)) !== null) {
-        const imp = { prefix: m[1], namespaceUri: m[2] };
+        const indices = m.indices;
+        const imp = { prefix: m[1], namespaceUri: m[2], offset: indices[1][0] };
         if (m[3])
             imp.atPath = m[3];
         imports.push(imp);
@@ -358,7 +359,8 @@ function analyzeRegex(text, sourceUri) {
     const namespaceDecls = [];
     RE_NS_DECL.lastIndex = 0;
     while ((m = RE_NS_DECL.exec(text)) !== null) {
-        namespaceDecls.push({ prefix: m[1], namespaceUri: m[2] });
+        const indices = m.indices;
+        namespaceDecls.push({ prefix: m[1], namespaceUri: m[2], offset: indices[1][0] });
     }
     const prefixMap = buildPrefixMap(moduleNs, imports, namespaceDecls);
     const functions = [];

package/dist/completion-core.d.ts

@@ -14,4 +14,4 @@ export interface CompletionEntry {
     isSnippet: boolean;
 }
 export declare function functionDoc(fn: FunctionSymbol): string;
-export declare function getCompletions(ctx: CompletionContext, currentAnalysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>, snippets?: boolean): CompletionEntry[];
+export declare function getCompletions(ctx: CompletionContext, currentAnalysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>, snippets?: boolean, lastValidAnalysis?: FileAnalysis): CompletionEntry[];

package/dist/completion-core.js

@@ -1,5 +1,5 @@
 import { formatQName } from "./types.js";
-import { resolvePrefix } from "./analyzer.js";
+import { resolvePrefix, nodeStackAtOffset, findAll } from "./analyzer.js";
 function parseToken(textBefore) {
     const match = textBefore.match(/\$([\w:\-]*)$|(?:([\w\-]+):)([\w\-]*)$|([\w\-]+)$/);
     if (!match)
@@ -41,6 +41,31 @@ function buildVariableEntry(v, filter) {
         return null;
     return { label, kind: "variable", insertText: label, isSnippet: false };
 }
+function buildParamEntry(p, filter) {
+    if (filter && !p.name.toLowerCase().startsWith(filter.toLowerCase()))
+        return null;
+    return {
+        label: `$${p.name}`,
+        kind: "variable",
+        detail: p.type ? `as ${p.type}` : undefined,
+        insertText: `$${p.name}`,
+        isSnippet: false,
+    };
+}
+/** Find the function symbol enclosing the cursor using the AST. */
+function findEnclosingFunction(ast, cursorOffset, functions) {
+    const stack = nodeStackAtOffset(ast, cursorOffset);
+    const bodyNode = stack.slice().reverse().find((n) => n.type === "FunctionBody");
+    if (!bodyNode || bodyNode.start === undefined || bodyNode.end == null)
+        return null;
+    const annotatedNode = stack.find((n) => n.type === "AnnotatedDecl");
+    if (!annotatedNode || annotatedNode.start === undefined)
+        return null;
+    const fn = functions.find((f) => f.sourceOffset === annotatedNode.start);
+    if (!fn)
+        return null;
+    return { fn, bodyStart: bodyNode.start, bodyEnd: bodyNode.end };
+}
 function buildFunctionEntry(fn, label, snippets) {
     return {
         label,
@@ -51,23 +76,63 @@ function buildFunctionEntry(fn, label, snippets) {
         isSnippet: snippets && fn.params.length > 0,
     };
 }
-export function getCompletions(ctx, currentAnalysis, importedAnalyses, snippets = false) {
+export function getCompletions(ctx, currentAnalysis, importedAnalyses, snippets = false, lastValidAnalysis) {
     const token = parseToken(ctx.textBeforeCursor);
     const items = [];
     if (token.kind === "variable") {
         const filter = token.prefix;
+        // Module-level variables are always visible
         for (const v of currentAnalysis.moduleVariables) {
             const e = buildVariableEntry(v, filter);
             if (e)
                 items.push(e);
         }
-        for (const v of currentAnalysis.localBindings) {
-            if (v.offset < ctx.cursorOffset) {
-                const e = buildVariableEntry(v, filter);
-                if (e)
-                    items.push(e);
+        // Prefer the current AST; fall back to the last successfully-parsed one for scope analysis
+        const scopeAst = currentAnalysis.ast ?? lastValidAnalysis?.ast;
+        if (scopeAst) {
+            const enclosing = findEnclosingFunction(scopeAst, ctx.cursorOffset, currentAnalysis.functions);
+            if (enclosing) {
+                // Inside a function body: params + local bindings within this body before cursor
+                for (const p of enclosing.fn.params) {
+                    const e = buildParamEntry(p, filter);
+                    if (e)
+                        items.push(e);
+                }
+                for (const v of currentAnalysis.localBindings) {
+                    if (v.offset > enclosing.bodyStart && v.offset < ctx.cursorOffset && v.offset < enclosing.bodyEnd) {
+                        const e = buildVariableEntry(v, filter);
+                        if (e)
+                            items.push(e);
+                    }
+                }
+            }
+            else {
+                // In query body: exclude local bindings that live inside function bodies
+                const functionBodyRanges = findAll(scopeAst, "FunctionBody")
+                    .filter((b) => b.start !== undefined && b.end != null)
+                    .map((b) => ({ start: b.start, end: b.end }));
+                for (const v of currentAnalysis.localBindings) {
+                    if (v.offset >= ctx.cursorOffset)
+                        continue;
+                    if (functionBodyRanges.some((r) => v.offset >= r.start && v.offset <= r.end))
+                        continue;
+                    const e = buildVariableEntry(v, filter);
+                    if (e)
+                        items.push(e);
+                }
+            }
+        }
+        else {
+            // No AST ever available: simple offset-based filter, no function-param completions
+            for (const v of currentAnalysis.localBindings) {
+                if (v.offset < ctx.cursorOffset) {
+                    const e = buildVariableEntry(v, filter);
+                    if (e)
+                        items.push(e);
+                }
             }
         }
+        // Imported module-level variables are always visible
         for (const analysis of importedAnalyses.values()) {
             for (const v of analysis.moduleVariables) {
                 const e = buildVariableEntry(v, filter);

package/dist/diagnostics.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Central registry of all diagnostic checkers.
+ *
+ * Add every new checker here so qt4-worker, server, and the playground
+ * all stay in sync automatically.
+ */
+import type { Node } from "xq-parser";
+import type { TypeDiagnostic, FileAnalysis } from "./types.ts";
+/**
+ * Run all error-level diagnostics (XQuery static/dynamic error codes).
+ * Safe to use in QT4 test coverage checks.
+ *
+ * @param imports  Merged map of imported module analyses and built-in function libraries.
+ */
+export declare function runDiagnostics(ast: Node, text: string, analysis: FileAnalysis, imports: Map<string, FileAnalysis>): TypeDiagnostic[];
+/**
+ * Run hint-level diagnostics (unused functions/variables).
+ * Produces xq-lsp:* codes — kept separate to avoid false-positives in QT4 tests.
+ */
+export declare function runHints(ast: Node, analysis: FileAnalysis): TypeDiagnostic[];

package/dist/diagnostics.js

@@ -0,0 +1,28 @@
+import { checkTypes } from "./typechecker.js";
+import { checkFunctionCalls } from "./functioncall-diagnostics.js";
+import { findUndeclaredPrefixUsages } from "./namespace-diagnostics.js";
+import { checkContextItemUsage } from "./context-item-diagnostics.js";
+import { checkUndeclaredVariables } from "./variable-diagnostics.js";
+import { checkUnused } from "./unused-diagnostics.js";
+/**
+ * Run all error-level diagnostics (XQuery static/dynamic error codes).
+ * Safe to use in QT4 test coverage checks.
+ *
+ * @param imports  Merged map of imported module analyses and built-in function libraries.
+ */
+export function runDiagnostics(ast, text, analysis, imports) {
+    return [
+        ...checkTypes(ast, text, analysis, imports),
+        ...checkFunctionCalls(ast, analysis, imports),
+        ...findUndeclaredPrefixUsages(ast, analysis),
+        ...checkContextItemUsage(ast),
+        ...checkUndeclaredVariables(ast, analysis, imports),
+    ];
+}
+/**
+ * Run hint-level diagnostics (unused functions/variables).
+ * Produces xq-lsp:* codes — kept separate to avoid false-positives in QT4 tests.
+ */
+export function runHints(ast, analysis) {
+    return checkUnused(ast, analysis);
+}

package/dist/qt4-worker.js

@@ -1,27 +1,21 @@
 import { workerData, parentPort } from "node:worker_threads";
 import { analyzeWithAst } from "./analyzer.js";
-import { checkTypes } from "./typechecker.js";
-import { checkFunctionCalls } from "./functioncall-diagnostics.js";
-import { findUndeclaredPrefixUsages } from "./namespace-diagnostics.js";
+import { runDiagnostics } from "./diagnostics.js";
 import { getBuiltins } from "./builtins.js";
 const BUILTINS = new Map([["builtin:fn", getBuiltins()]]);
-function runDiagnostics(query, envNamespaces) {
+function collectCodes(query, envNamespaces) {
     try {
         const { analysis, ast, parseError } = analyzeWithAst(query, "file:///test.xq");
         for (const ns of envNamespaces) {
             if (ns.prefix && !analysis.namespaceDecls.some((d) => d.prefix === ns.prefix)) {
-                analysis.namespaceDecls.push({ prefix: ns.prefix, namespaceUri: ns.uri });
+                analysis.namespaceDecls.push({ prefix: ns.prefix, namespaceUri: ns.uri, offset: -1 });
             }
         }
         const codes = [];
         if (parseError)
             codes.push("XPST0003");
         if (ast) {
-            for (const d of checkTypes(ast, query, analysis, BUILTINS))
-                codes.push(d.code);
-            for (const d of checkFunctionCalls(ast, analysis, BUILTINS))
-                codes.push(d.code);
-            for (const d of findUndeclaredPrefixUsages(ast, analysis))
+            for (const d of runDiagnostics(ast, query, analysis, BUILTINS))
                 codes.push(d.code);
         }
         return [...new Set(codes)];
@@ -32,7 +26,7 @@ function runDiagnostics(query, envNamespaces) {
 }
 const batch = workerData;
 const results = batch.map((tc) => {
-    const got = runDiagnostics(tc.query, tc.envNamespaces);
+    const got = collectCodes(tc.query, tc.envNamespaces);
     const hasError = got.length > 0;
     const outcome = tc.expected === "static-error"
         ? hasError

package/dist/runtimes/existdb/cache.xq

@@ -0,0 +1,83 @@
+module namespace cache = "http://exist-db.org/xquery/cache";
+
+(:~
+ : Eviction policy work of the cache is performed asynchronously. Performs any
+ : pending maintenance operations needed by the cache, on the current thread.
+ : Typically not needed by users, and only used for testing scenarios. Requires
+ : 'clear' permissions.
+ : @param $cache-name The name of the cache
+ :)
+declare function cache:cleanup($cache-name as xs:string) as empty-sequence() external;
+
+(:~
+ : Clears all key/values from either all caches or the named cache
+ :)
+declare function cache:clear() as empty-sequence() external;
+
+(:~
+ : Clears all key/values from either all caches or the named cache
+ : @param $cache-name The name of the cache
+ :)
+declare function cache:clear($cache-name as xs:string) as empty-sequence() external;
+
+(:~
+ : Explicitly create a cache with a specific configuration
+ : @param $cache-name The name of the cache
+ : @param $config A map with configuration for the cache. At present cache LRU and permission groups may be specified, for operations on the cache. `maximumSize` is optional and specifies the maximum number of entries. `expireAfterAccess` is optional and specifies the expiry period for infrequently accessed entries (in milliseconds). `expireAfterWrite` is optional and specifies the expiry period after the entry's creation, or the most recent replacement of its value (in milliseconds). If a permission group is not specified for an operation, then permissions are not checked for that operation. Should have the format: map { "maximumSize": 1000, "expireAfterAccess": 120000, "expireAfterWrite": 240000, "permissions": map { "put-group": "group1", "get-group": "group2", "remove-group": "group3", "clear-group": "group4"} }
+ : @return true if the cache was created, false if the cache already exists
+ :)
+declare function cache:create($cache-name as xs:string, $config as map(*)) as xs:boolean external;
+
+(:~
+ : Destroys a cache entirely
+ : @param $cache-name The name of the cache
+ :)
+declare function cache:destroy($cache-name as xs:string) as empty-sequence() external;
+
+(:~
+ : Get data from identified global cache by key
+ : @param $cache-name The name of the cache
+ : @param $key The key
+ : @return The value associated with the key
+ :)
+declare function cache:get($cache-name as xs:string, $key as xs:anyType+) as item()* external;
+
+(:~
+ : List all keys stored in a cache. Note this operation is expensive.
+ : @param $cache-name The name of the cache
+ : @return The keys in the cache. Note these will be returned in serialized string form, as that is used internally.
+ :)
+declare function cache:keys($cache-name as xs:string) as xs:string* external;
+
+(:~
+ : List all values (for the associated keys) stored in a cache.
+ : @param $cache-name The name of the cache
+ : @param $keys The keys, if none are specified, all values are returned
+ : @return The values associated with the keys
+ :)
+declare function cache:list($cache-name as xs:string, $keys as xs:anyType*) as item()* external;
+
+(:~
+ : Get the names of all current caches
+ : @return The names of all caches currently in use.
+ :)
+declare function cache:names() as xs:string* external;
+
+(:~
+ : Put data with a key into the identified cache. Returns the previous value
+ : associated with the key
+ : @param $cache-name The name of the cache
+ : @param $key The key
+ : @param $value The value
+ : @return The previous value associated with the key
+ :)
+declare function cache:put($cache-name as xs:string, $key as xs:anyType+, $value as item()*) as item()* external;
+
+(:~
+ : Remove data from the identified cache by the key. Returns the value that was
+ : previously associated with key
+ : @param $cache-name The name of the cache
+ : @param $key The key
+ : @return The value that was previously associated with the key
+ :)
+declare function cache:remove($cache-name as xs:string, $key as xs:anyType+) as item()* external;