xq-lsp 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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)
 
 

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
@@ -234,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/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;

package/dist/runtimes/existdb/compression.xq

@@ -0,0 +1,198 @@
+module namespace compression = "http://exist-db.org/xquery/compression";
+
+(:~
+ : Stores an entry to the database. Attempts to guard against exit attacks; If
+ : an exit attack is detected then the error `compression:archive-exit-attack
+ : is raised`.
+ : @param $destination A path to a Collection in the database where the entry should be extracted. If the Collection does not exist it will be created.
+ : @return A function suitable for passing as the $entry-data#3
+ :)
+declare function compression:db-store-entry3($destination as xs:string?) as function(*) external;
+
+(:~
+ : Stores an entry to the database. Attempts to guard against exit attacks; If
+ : an exit attack is detected then the error `compression:archive-exit-attack
+ : is raised`.
+ : @param $destination A path to a Collection in the database where the entry should be extracted. If the Collection does not exist it will be created.
+ : @return A function suitable for passing as the $entry-data#4
+ :)
+declare function compression:db-store-entry4($destination as xs:string?) as function(*) external;
+
+(:~
+ : Deflate data (RFC 1950)
+ : @param $data The data to Deflate
+ :)
+declare function compression:deflate($data as xs:base64Binary) as xs:base64Binary? external;
+
+(:~
+ : Deflate data (RFC 1951)
+ : @param $data The data to Deflate
+ : @param $raw If true, create raw deflate data that is not wrapped inside zlib header and checksum.
+ :)
+declare function compression:deflate($data as xs:base64Binary, $raw as xs:boolean) as xs:base64Binary? external;
+
+(:~
+ : Stores an entry to the filesystem. This method is only available to the DBA
+ : role. Attempts to guard against exit attacks; If an exit attack is detected
+ : then the error `compression:archive-exit-attack is raised`.
+ : @param $destination A path to a directory on the filesystem where the entry should be extracted. If the path does not exist it will be created.
+ : @return A function suitable for passing as the $entry-data#3
+ :)
+declare function compression:fs-store-entry3($destination as xs:string?) as function(*) external;
+
+(:~
+ : Stores an entry to the filesystem. This method is only available to the DBA
+ : role. Attempts to guard against exit attacks; If an exit attack is detected
+ : then the error `compression:archive-exit-attack is raised`.
+ : @param $destination A path to a directory on the filesystem where the entry should be extracted. If the path does not exist it will be created.
+ : @return A function suitable for passing as the $entry-data#4
+ :)
+declare function compression:fs-store-entry4($destination as xs:string?) as function(*) external;
+
+(:~
+ : GZip's data
+ : @param $data The data to GZip
+ :)
+declare function compression:gzip($data as xs:base64Binary) as xs:base64Binary? external;
+
+(:~
+ : Inflate data (RFC 1950)
+ : @param $inflate-data The inflate data to uncompress.
+ :)
+declare function compression:inflate($inflate-data as xs:base64Binary) as xs:base64Binary? external;
+
+(:~
+ : Inflate data (RFC 1951)
+ : @param $inflate-data The inflate data to uncompress.
+ : @param $raw If true, expect raw deflate data that is not wrapped inside zlib header and checksum.
+ :)
+declare function compression:inflate($inflate-data as xs:base64Binary, $raw as xs:boolean) as xs:base64Binary? external;
+
+(:~
+ : Does not filter any entries.
+ : @param $path The path of the entry
+ : @param $data-type The type of the entry, either 'directory' or 'resource'.
+ : @return Always true, so that no entries are filtered. Parameters are ignored.
+ :)
+declare function compression:no-filter($path as xs:string, $data-type as xs:string) as xs:boolean external;
+
+(:~
+ : Does not filter any entries.
+ : @param $path The path of the entry
+ : @param $data-type The type of the entry, either 'directory' or 'resource'.
+ : @param $param One or more parameters.
+ : @return Always true, so that no entries are filtered. Parameters are ignored.
+ :)
+declare function compression:no-filter(
+	$path as xs:string,
+	$data-type as xs:string,
+	$param as item()*
+) as xs:boolean external;
+
+declare function compression:tar() as xs:base64Binary* external;
+
+(:~
+ : UnGZip's data
+ : @param $gzip-data The gzip data to uncompress.
+ :)
+declare function compression:ungzip($gzip-data as xs:base64Binary) as xs:base64Binary? external;
+
+(:~
+ : UnTar all the resources/folders from the provided data by calling user
+ : defined functions to determine what and how to store the resources/folders
+ : @param $tar-data The tar file data
+ : @param $entry-filter A user defined function for filtering resources from the tar file. The function takes 2 parameters e.g. user:untar-entry-filter($path as xs:string, $data-type as xs:string) as xs:boolean. $data-type may be 'resource' or 'folder'. If the return type is true() it indicates the entry should be processed and passed to the entry-data function, else the resource is skipped. If you wish to extract all resources you can use the provided compression:no-filter#2 function.
+ : @param $entry-data A user defined function for storing an extracted resource from the tar file. The function takes 3 parameters e.g. user:untar-entry-data($path as xs:string, $data-type as xs:string, $data as item()?). Or a user defined function which returns a db path for storing an extracted resource from the tar file. The function takes 3 parameters e.g. user:entry-path($path as xs:string, $data-type as xs:string, $param as item()*) as xs:anyURI. $data-type may be 'resource' or 'folder'. Functions for storing the entries to a folder on the filesystem or a collection in the database provided by compression:fs-store-entry3($dest) and compression:db-store-entry3($dest).
+ :)
+declare function compression:untar(
+	$tar-data as xs:base64Binary,
+	$entry-filter as function(*),
+	$entry-data as function(*)
+) as item()* external;
+
+(:~
+ : UnTar all the resources/folders from the provided data by calling user
+ : defined functions to determine what and how to store the resources/folders
+ : @param $tar-data The tar file data
+ : @param $entry-filter A user defined function for filtering resources from the tar file. The function takes 3 parameters e.g. user:untar-entry-filter($path as xs:string, $data-type as xs:string, $param as item()*) as xs:boolean. $data-type may be 'resource' or 'folder'. $param is a sequence with any additional parameters, for example a list of extracted files. If the return type is true() it indicates the entry should be processed and passed to the entry-data function, else the resource is skipped. If you wish to extract all resources you can use the provided compression:no-filter#3 function.
+ : @param $entry-filter-param A sequence with an additional parameters for filtering function.
+ : @param $entry-data A user defined function for storing an extracted resource from the tar file. The function takes 4 parameters e.g. user:untar-entry-data($path as xs:string, $data-type as xs:string, $data as item()?, $param as item()*). Or a user defined function which returns a db path for storing an extracted resource from the tar file. The function takes 3 parameters e.g. user:entry-path($path as xs:string, $data-type as xs:string, $param as item()*) as xs:anyURI. $data-type may be 'resource' or 'folder'. $param is a sequence with any additional parameters Functions for storing the entries to a folder on the filesystem or a collection in the database provided by compression:fs-store-entry4($dest) and compression:db-store-entry4($dest).
+ : @param $entry-data-param A sequence with an additional parameters for storing function.
+ :)
+declare function compression:untar(
+	$tar-data as xs:base64Binary,
+	$entry-filter as function(*),
+	$entry-filter-param as xs:anyType*,
+	$entry-data as function(*),
+	$entry-data-param as xs:anyType*
+) as item()* external;
+
+(:~
+ : UnTar all the resources/folders from the provided data by calling user
+ : defined functions to determine what and how to store the resources/folders
+ : @param $tar-data The tar file data
+ : @param $entry-filter A user defined function for filtering resources from the tar file. The function takes 3 parameters e.g. user:untar-entry-filter($path as xs:string, $data-type as xs:string, $param as item()*) as xs:boolean. $data-type may be 'resource' or 'folder'. $param is a sequence with any additional parameters, for example a list of extracted files. If the return type is true() it indicates the entry should be processed and passed to the entry-data function, else the resource is skipped. If you wish to extract all resources you can use the provided compression:no-filter#3 function.
+ : @param $entry-filter-param A sequence with an additional parameters for filtering function.
+ : @param $entry-data A user defined function for storing an extracted resource from the tar file. The function takes 4 parameters e.g. user:untar-entry-data($path as xs:string, $data-type as xs:string, $data as item()?, $param as item()*). Or a user defined function which returns a db path for storing an extracted resource from the tar file. The function takes 3 parameters e.g. user:entry-path($path as xs:string, $data-type as xs:string, $param as item()*) as xs:anyURI. $data-type may be 'resource' or 'folder'. $param is a sequence with any additional parameters Functions for storing the entries to a folder on the filesystem or a collection in the database provided by compression:fs-store-entry4($dest) and compression:db-store-entry4($dest).
+ : @param $entry-data-param A sequence with an additional parameters for storing function.
+ : @param $encoding The encoding to be used during uncompressing eg: UTF8 or Cp437 from https://docs.oracle.com/javase/8/docs/technotes/guides/intl/encoding.doc.html
+ :)
+declare function compression:untar(
+	$tar-data as xs:base64Binary,
+	$entry-filter as function(*),
+	$entry-filter-param as xs:anyType*,
+	$entry-data as function(*),
+	$entry-data-param as xs:anyType*,
+	$encoding as xs:string
+) as item()* external;
+
+(:~
+ : UnZip all the resources/folders from the provided data by calling user
+ : defined functions to determine what and how to store the resources/folders
+ : @param $zip-data The zip file data
+ : @param $entry-filter A user defined function for filtering resources from the zip file. The function takes 2 parameters e.g. user:unzip-entry-filter($path as xs:string, $data-type as xs:string) as xs:boolean. $data-type may be 'resource' or 'folder'. If the return type is true() it indicates the entry should be processed and passed to the $entry-data function, else the resource is skipped. If you wish to extract all resources you can use the provided compression:no-filter#2 function.
+ : @param $entry-data A user defined function for storing an extracted resource from the zip file. The function takes 3 parameters e.g. user:unzip-entry-data($path as xs:string, $data-type as xs:string, $data as item()?). Or a user defined function which returns a db path for storing an extracted resource from the zip file. The function takes 3 parameters e.g. user:entry-path($path as xs:string, $data-type as xs:string, $param as item()*) as xs:anyURI. $data-type may be 'resource' or 'folder'. Functions for storing the entries to a folder on the filesystem or a collection in the database provided by compression:fs-store-entry3($dest) and compression:db-store-entry3($dest).
+ :)
+declare function compression:unzip(
+	$zip-data as xs:base64Binary,
+	$entry-filter as function(*),
+	$entry-data as function(*)
+) as item()* external;
+
+(:~
+ : UnZip all the resources/folders from the provided data by calling user
+ : defined functions to determine what and how to store the resources/folders
+ : @param $zip-data The zip file data
+ : @param $entry-filter A user defined function for filtering resources from the zip file. The function takes 3 parameters e.g. user:unzip-entry-filter($path as xs:string, $data-type as xs:string, $param as item()*) as xs:boolean. $data-type may be 'resource' or 'folder'. $param is a sequence with any additional parameters, for example a list of extracted files. If the return type is true() it indicates the entry should be processed and passed to the $entry-data function, else the resource is skipped. If you wish to extract all resources you can use the provided compression:no-filter#3 function.
+ : @param $entry-filter-param A sequence with an additional parameters for filtering function.
+ : @param $entry-data A user defined function for storing an extracted resource from the zip file. The function takes 4 parameters e.g. user:unzip-entry-data($path as xs:string, $data-type as xs:string, $data as item()?, $param as item()*). Or a user defined function which returns a db path for storing an extracted resource from the zip file. The function takes 3 parameters e.g. user:entry-path($path as xs:string, $data-type as xs:string, $param as item()*) as xs:anyURI. $data-type may be 'resource' or 'folder'. $param is a sequence with any additional parameters. Functions for storing the entries to a folder on the filesystem or a collection in the database provided by compression:fs-store-entry4($dest) and compression:db-store-entry4($dest).
+ : @param $entry-data-param A sequence with an additional parameters for storing function.
+ :)
+declare function compression:unzip(
+	$zip-data as xs:base64Binary,
+	$entry-filter as function(*),
+	$entry-filter-param as xs:anyType*,
+	$entry-data as function(*),
+	$entry-data-param as xs:anyType*
+) as item()* external;
+
+(:~
+ : UnZip all the resources/folders from the provided data by calling user
+ : defined functions to determine what and how to store the resources/folders
+ : @param $zip-data The zip file data
+ : @param $entry-filter A user defined function for filtering resources from the zip file. The function takes 3 parameters e.g. user:unzip-entry-filter($path as xs:string, $data-type as xs:string, $param as item()*) as xs:boolean. $data-type may be 'resource' or 'folder'. $param is a sequence with any additional parameters, for example a list of extracted files. If the return type is true() it indicates the entry should be processed and passed to the $entry-data function, else the resource is skipped. If you wish to extract all resources you can use the provided compression:no-filter#3 function.
+ : @param $entry-filter-param A sequence with an additional parameters for filtering function.
+ : @param $entry-data A user defined function for storing an extracted resource from the zip file. The function takes 4 parameters e.g. user:unzip-entry-data($path as xs:string, $data-type as xs:string, $data as item()?, $param as item()*). Or a user defined function which returns a db path for storing an extracted resource from the zip file. The function takes 3 parameters e.g. user:entry-path($path as xs:string, $data-type as xs:string, $param as item()*) as xs:anyURI. $data-type may be 'resource' or 'folder'. $param is a sequence with any additional parameters. Functions for storing the entries to a folder on the filesystem or a collection in the database provided by compression:fs-store-entry4($dest) and compression:db-store-entry4($dest).
+ : @param $entry-data-param A sequence with an additional parameters for storing function.
+ : @param $encoding The encoding to be used during uncompressing eg: UTF8 or Cp437 from https://docs.oracle.com/javase/8/docs/technotes/guides/intl/encoding.doc.html
+ :)
+declare function compression:unzip(
+	$zip-data as xs:base64Binary,
+	$entry-filter as function(*),
+	$entry-filter-param as xs:anyType*,
+	$entry-data as function(*),
+	$entry-data-param as xs:anyType*,
+	$encoding as xs:string
+) as item()* external;
+
+declare function compression:zip() as xs:base64Binary* external;

package/dist/runtimes/existdb/console.xq

@@ -0,0 +1,24 @@
+module namespace console = "http://exist-db.org/xquery/console";
+
+(:~
+ : Log items to the 'default' console channel.
+ : @param $items Values to log.
+ : @return Empty
+ :)
+declare function console:log($items as item()*) as empty-sequence() external;
+
+(:~
+ : Log items to a specific console channel.
+ : @param $channel The channel to log to.
+ : @param $items Values to log.
+ : @return Empty
+ :)
+declare function console:log($channel as xs:string, $items as item()*) as empty-sequence() external;
+
+(:~
+ : Send a JSON message to a console channel.
+ : @param $channel The channel to send to.
+ : @param $items Value to send as JSON.
+ : @return Empty
+ :)
+declare function console:send($channel as xs:string, $items as item()?) as empty-sequence() external;

package/dist/runtimes/existdb/contentextraction.xq

@@ -0,0 +1,31 @@
+module namespace contentextraction = "http://exist-db.org/xquery/contentextraction";
+
+(:~
+ : extracts the metadata
+ : @param $binary The binary data to extract from
+ : @return Extracted metadata
+ :)
+declare function contentextraction:get-metadata($binary as xs:base64Binary) as document-node() external;
+
+(:~
+ : extracts the metadata and contents
+ : @param $binary The binary data to extract from
+ : @return Extracted content and metadata
+ :)
+declare function contentextraction:get-metadata-and-content($binary as xs:base64Binary) as document-node() external;
+
+(:~
+ : extracts the metadata
+ : @param $binary The binary data to extract from
+ : @param $callback The callback function. Expected signature:
+ : @param $namespaces Prefix/namespace mappings to be used for matching the paths. Pass an XML fragment with the following structure: <namespaces><namespace prefix="prefix" uri="uri"/></namespaces>.
+ : @param $userData Additional data which will be passed to the callback function.
+ : @return Returns empty sequence
+ :)
+declare function contentextraction:stream-content(
+	$binary as xs:base64Binary,
+	$paths as xs:string*,
+	$callback as function(*),
+	$namespaces as element()?,
+	$userData as item()*
+) as empty-sequence() external;

package/dist/runtimes/existdb/counter.xq

@@ -0,0 +1,30 @@
+module namespace counter = "http://exist-db.org/xquery/counter";
+
+(:~
+ : Create a unique counter named $counter-name.
+ : @param $counter-name Name of the counter.
+ : @return the value of the newly created counter.
+ :)
+declare function counter:create($counter-name as item()) as xs:long? external;
+
+(:~
+ : Create a unique counter named $counter-name and initialize it with value
+ : $init-value.
+ : @param $counter-name Name of the counter.
+ : @param $init-value The initial value of the counter.
+ : @return the value of the newly created counter.
+ :)
+declare function counter:create($counter-name as item(), $init-value as xs:long) as xs:long? external;
+
+(:~
+ : Destroy the counter named $counter-name.
+ : @param $counter-name Name of the counter.
+ :)
+declare function counter:destroy($counter-name as item()) as xs:boolean? external;
+
+(:~
+ : Increment the counter $counter-name and return its new value.
+ : @param $counter-name Name of the counter.
+ : @return the new value of the specified counter, or -1 if the counter does not exist.
+ :)
+declare function counter:next-value($counter-name as item()) as xs:long? external;