@hydranium/core 1.0.0-next.10

package/lib/lsp/instrument-connection.js

@@ -0,0 +1,62 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+/**
+ * Wrap an LSP `Connection` so every request handler registered through
+ * `onRequest` is timed into `latency` under its method name — the LSP analog of
+ * the data-server RPC chokepoint. Langium's `startLanguageServer` registers
+ * `onCompletion`/`onHover`/… one handler at a time, so there is no single
+ * dispatch point; but every registration funnels through the ONE `onRequest`
+ * on the shared `Connection`, so decorating it catches every method with no
+ * Langium fork and no per-handler code.
+ *
+ * Opt in where the head creates the connection, before it hands it to the
+ * services factory — wrapping it afterwards is too late, because Langium has
+ * already registered its handlers against the raw connection.
+ *
+ * `onRequest` has several overloads: most register a handler for a specific
+ * method (a string, or a typed request whose `.method` names it) and one is the
+ * `StarRequestHandler` catch-all `onRequest(handler)`. The star form fires only
+ * for methods with no registered handler, so timing it would be misleading — it
+ * is passed through untouched. Every other member of the connection is
+ * forwarded unchanged.
+ *
+ * When `latency` is `undefined` the seam is off: the connection is returned
+ * unchanged (no Proxy, no per-request timing), so a head can pass the result of
+ * an env-gated factory (`latencyFromEnv()`) straight through and pay nothing
+ * when latency is not enabled.
+ */
+export function instrumentLspConnection(connection, latency) {
+    if (!latency) {
+        return connection;
+    }
+    return new Proxy(connection, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (property !== 'onRequest' || typeof value !== 'function') {
+                return value;
+            }
+            const onRequest = value;
+            return (...args) => {
+                const [first, handler] = args;
+                // Star form `onRequest(handler)` — pass through; it is not a timer.
+                if (typeof first === 'function' || typeof handler !== 'function') {
+                    return onRequest.apply(target, args);
+                }
+                const method = typeof first === 'string' ? first : first.method;
+                if (typeof method !== 'string') {
+                    return onRequest.apply(target, args);
+                }
+                const original = handler;
+                const timed = (...handlerArgs) => latency.time(method, () => original(...handlerArgs));
+                return onRequest.apply(target, [first, timed, ...args.slice(2)]);
+            };
+        }
+    });
+}
+//# sourceMappingURL=instrument-connection.js.map

package/lib/lsp/instrument-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument-connection.js","sourceRoot":"","sources":["../../src/lsp/instrument-connection.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAMlF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,uBAAuB,CAAmB,UAAa,EAAE,OAAqC;IAC3G,IAAI,CAAC,OAAO,EAAE,CAAC;QACZ,OAAO,UAAU,CAAC;IACrB,CAAC;IACD,OAAO,IAAI,KAAK,CAAC,UAAU,EAAE;QAC1B,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ;YAC3B,MAAM,KAAK,GAAY,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC/D,IAAI,QAAQ,KAAK,WAAW,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;gBAC3D,OAAO,KAAK,CAAC;YAChB,CAAC;YACD,MAAM,SAAS,GAAG,KAAwC,CAAC;YAC3D,OAAO,CAAC,GAAG,IAAe,EAAW,EAAE;gBACpC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;gBAC9B,oEAAoE;gBACpE,IAAI,OAAO,KAAK,KAAK,UAAU,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;oBAChE,OAAO,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBACxC,CAAC;gBACD,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,KAA8B,CAAC,MAAM,CAAC;gBAC1F,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;oBAC9B,OAAO,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBACxC,CAAC;gBACD,MAAM,QAAQ,GAAG,OAAyB,CAAC;gBAC3C,MAAM,KAAK,GAAmB,CAAC,GAAG,WAAW,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;gBACvG,OAAO,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACpE,CAAC,CAAC;QACL,CAAC;KACH,CAAC,CAAC;AACN,CAAC"}

package/lib/lsp/language-module.d.ts

@@ -0,0 +1,53 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type Module } from '@hydranium/langium';
+import { type ServerLanguageServices } from '../langium/language-module.js';
+import { type ServerModuleContext } from '../langium/module.js';
+import { type PartialLangiumServices } from '@hydranium/langium/lsp';
+import { HydraniumCompletionProvider } from './completion/hydranium-completion-provider.js';
+/**
+ * Language-level slots contributed by the LSP-textual protocol head.
+ * Bound by {@link createLspServerLanguageModule}; consumer modules
+ * layered after it can override any slot.
+ *
+ * - {@link HydraniumCompletionProvider} upgrades Langium's default
+ *   `TextEdit` to an `InsertReplaceEdit` so the user's
+ *   `editor.suggest.insertMode` preference is honoured.
+ *
+ * The head's SHARED-tier slots are bound by
+ * `createLspServerSharedModule` instead: `lsp.DocumentUpdateHandler`
+ * exists once per server rather than once per grammar, so binding it here is
+ * inert — nothing reads a per-language one.
+ */
+export interface LspServerAddedServices {
+    lsp: {
+        CompletionProvider: HydraniumCompletionProvider;
+    };
+}
+/**
+ * Full language-service surface visible to consumers that compose this
+ * head: `@hydranium/core`'s bindings plus the LSP-textual additions. Use as
+ * the `T` type parameter for the consumer's own
+ * `Module<LspServerLanguageServices, ...>` if its overrides depend on
+ * any LSP-only slot.
+ */
+export type LspServerLanguageServices = ServerLanguageServices & LspServerAddedServices;
+/**
+ * The LSP-textual protocol head's default language module. Composes on
+ * top of `createServerLanguageModule` — as a later `inject(...)`
+ * argument, or as `languageModules.extra` when composing through
+ * `createIntegrationServices`; the adopter's own language module goes after
+ * it either way.
+ *
+ * `createServerLanguageModule` MUST be merged before this one — the
+ * lsp-server head only contributes LSP-textual-specific slots and
+ * relies on `@hydranium/core`'s references / naming bindings being present.
+ */
+export declare function createLspServerLanguageModule(_context: ServerModuleContext): Module<LspServerLanguageServices, PartialLangiumServices & LspServerAddedServices>;
+//# sourceMappingURL=language-module.d.ts.map

package/lib/lsp/language-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-module.d.ts","sourceRoot":"","sources":["../../src/lsp/language-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AAE5F;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,sBAAsB;IACpC,GAAG,EAAE;QACa,kBAAkB,EAAE,2BAA2B,CAAC;KACjE,CAAC;CACJ;AAED;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,GAAG,sBAAsB,CAAC;AAExF;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC1C,QAAQ,EAAE,mBAAmB,GAC7B,MAAM,CAAC,yBAAyB,EAAE,sBAAsB,GAAG,sBAAsB,CAAC,CAMpF"}

package/lib/lsp/language-module.js

@@ -0,0 +1,28 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { HydraniumCompletionProvider } from './completion/hydranium-completion-provider.js';
+/**
+ * The LSP-textual protocol head's default language module. Composes on
+ * top of `createServerLanguageModule` — as a later `inject(...)`
+ * argument, or as `languageModules.extra` when composing through
+ * `createIntegrationServices`; the adopter's own language module goes after
+ * it either way.
+ *
+ * `createServerLanguageModule` MUST be merged before this one — the
+ * lsp-server head only contributes LSP-textual-specific slots and
+ * relies on `@hydranium/core`'s references / naming bindings being present.
+ */
+export function createLspServerLanguageModule(_context) {
+    return {
+        lsp: {
+            CompletionProvider: services => new HydraniumCompletionProvider(services)
+        }
+    };
+}
+//# sourceMappingURL=language-module.js.map

package/lib/lsp/language-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-module.js","sourceRoot":"","sources":["../../src/lsp/language-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAMlF,OAAO,EAAE,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AA+B5F;;;;;;;;;;GAUG;AACH,MAAM,UAAU,6BAA6B,CAC1C,QAA6B;IAE7B,OAAO;QACJ,GAAG,EAAE;YACF,kBAAkB,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,2BAA2B,CAAC,QAAQ,CAAC;SAC3E;KACH,CAAC;AACL,CAAC"}

package/lib/lsp/semantic-token-provider.d.ts

@@ -0,0 +1,131 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type AstNode, type AstReflection, type LangiumDocument, type ReferenceInfo } from '@hydranium/langium';
+import { AbstractSemanticTokenProvider, type SemanticTokenAcceptor } from '@hydranium/langium/lsp';
+import { type CancellationToken } from 'vscode-languageserver';
+import { type NameProvider } from '../langium/naming/name-provider.js';
+import { type ServerLanguageServices } from '../langium/language-module.js';
+/**
+ * What a node or reference should be coloured as. The bare string form is the
+ * common case (`SemanticTokenTypes.class`); the object form is for the
+ * minority that also need modifiers, or that need to suppress the
+ * declaration modifier this provider adds by default (pass `modifier: []`).
+ */
+export type SemanticTokenKind = string | {
+    readonly type: string;
+    readonly modifier?: string | string[];
+};
+/** Behaviour switches for {@link AbstractHydraniumSemanticTokenProvider}. */
+export interface HydraniumSemanticTokenProviderOptions {
+    /**
+     * Also emit a `keyword` token for every keyword leaf of the CST.
+     *
+     * OFF by default, and the default is not timidity: semantic tokens OVERRIDE
+     * a client-side TextMate grammar, and such a grammar classifies keywords
+     * with far finer scopes (`keyword.control`, `storage.type`,
+     * `keyword.operator`) than the one flat `keyword` a legend can carry — so
+     * turning this on in a host that ships a grammar makes its editor *less*
+     * coloured, not more. It exists for the host that ships NO client-side
+     * grammar at all (a plain-Monaco page, a minimal web client), where the
+     * server's tokens are the only source of colour and keywords otherwise
+     * render in the editor's default foreground.
+     */
+    readonly highlightKeywords?: boolean;
+}
+/**
+ * Semantic-token provider that derives highlighting from ONE adopter-supplied
+ * map of AST type → token kind, instead of a hand-written walk.
+ *
+ * **What it replaces.** Langium's {@link AbstractSemanticTokenProvider} hands
+ * you every node and asks you to emit tokens for it, so a grammar-specific
+ * provider becomes a chain of typeguards, each repeating two mechanical
+ * steps: emit the declaration name with `property: 'name'`, then emit one
+ * acceptor call per cross-reference property, remembering `index` for the
+ * multi-valued ones. Both steps are derivable, and getting the second one
+ * wrong is silent — a forgotten reference property simply renders uncoloured.
+ *
+ * **How the derivation works.**
+ * - The declaration name's PROPERTY comes from {@link NameProvider.getNameProperty},
+ *   so an `id`-keyed grammar works without the provider hardcoding `'name'`.
+ * - Cross-references are discovered with Langium's `streamReferences`, which
+ *   yields every reference on the node with its property and index already
+ *   filled in — so multi-valued references cannot be missed or mis-indexed.
+ * - A reference's kind is resolved from the reference's DECLARED target type
+ *   (`AstReflection.getReferenceType`), NOT from `ref.ref.$type`. That is
+ *   deliberate: the declared type is available whether or not the reference
+ *   resolves, so a broken or half-typed document keeps its colouring instead
+ *   of flickering as links come and go.
+ *
+ * The net effect is that {@link getTokenKind} — a `$type` string in, a token
+ * kind out — is usually the only member an adopter writes.
+ *
+ * Anything the map cannot express stays overridable: {@link getDeclarationKind}
+ * and {@link getReferenceKind} for per-node or per-property decisions,
+ * {@link highlightElement} for tokens that are neither a declaration nor a
+ * cross-reference (a sub-range, a single keyword of one rule). Returning
+ * `'prune'` from an override still skips the subtree, as upstream. Colouring
+ * EVERY keyword is not one of those cases — that is
+ * {@link HydraniumSemanticTokenProviderOptions.highlightKeywords}, which walks
+ * the CST once instead.
+ */
+export declare abstract class AbstractHydraniumSemanticTokenProvider extends AbstractSemanticTokenProvider {
+    protected readonly nameProvider: NameProvider;
+    protected readonly reflection: AstReflection;
+    protected readonly options: HydraniumSemanticTokenProviderOptions;
+    /**
+     * Modifier added to every declaration token. `declaration` is what themes
+     * key on to render a definition differently from a use; override to
+     * `undefined` to add none.
+     */
+    protected readonly declarationModifier: string | undefined;
+    constructor(services: ServerLanguageServices, options?: HydraniumSemanticTokenProviderOptions);
+    /**
+     * The AST pass, then — when asked for — one CST pass over the keywords.
+     *
+     * **The keyword pass belongs here and not in {@link highlightElement}**,
+     * which is called once per AST node: a node reaching its own keyword leaves
+     * has to descend its CST subtree, and every node repeating that visits each
+     * leaf once per ancestor, so the AST-hosted version is O(leaves × depth)
+     * against this one's O(leaves). It also cannot be written correctly with a
+     * `prune`, because a keyword leaf's nearest AST node is not always the one
+     * whose rule contributed it.
+     *
+     * Emitting out of positional order is safe: `SemanticTokensBuilder` sorts
+     * before it encodes the deltas, so the two passes need not interleave. The
+     * range form of the request needs no accommodation either — the acceptor
+     * drops anything outside `currentRange` on its own.
+     */
+    protected computeHighlighting(document: LangiumDocument, acceptor: SemanticTokenAcceptor, cancelToken: CancellationToken): Promise<void>;
+    protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
+    /** Colour the node's own name, at whichever property the NameProvider reads it from. */
+    protected highlightDeclaration(node: AstNode, acceptor: SemanticTokenAcceptor): void;
+    /** Colour every cross-reference the node carries, including multi-valued ones. */
+    protected highlightReferences(node: AstNode, acceptor: SemanticTokenAcceptor): void;
+    /**
+     * The adopter's map: an AST `$type` in, the token kind its declarations and
+     * the references pointing at it should render as. `undefined` leaves the
+     * type uncoloured.
+     *
+     * What uncoloured means depends on the host, and this map cannot see which:
+     * a host shipping a TextMate grammar keeps that grammar's colour, a host
+     * shipping none renders the default foreground. So `undefined` says only
+     * "not a name worth a kind of its own" — never "someone else will colour
+     * it". Keywords in particular are not left to this map at all; they are
+     * {@link HydraniumSemanticTokenProviderOptions.highlightKeywords}, because
+     * they have no AST type to key on.
+     */
+    protected abstract getTokenKind(type: string): SemanticTokenKind | undefined;
+    /** Kind for `node`'s own declaration. Defaults to {@link getTokenKind} on its `$type`. */
+    protected getDeclarationKind(node: AstNode): SemanticTokenKind | undefined;
+    /** Kind for a cross-reference. Defaults to {@link getTokenKind} on the reference's DECLARED target type. */
+    protected getReferenceKind(info: ReferenceInfo): SemanticTokenKind | undefined;
+    /** Property holding `node`'s name. Defaults to the language's {@link NameProvider}. */
+    protected getNameProperty(node: AstNode): string | undefined;
+}
+//# sourceMappingURL=semantic-token-provider.d.ts.map

package/lib/lsp/semantic-token-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-token-provider.d.ts","sourceRoot":"","sources":["../../src/lsp/semantic-token-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,OAAO,EACZ,KAAK,aAAa,EAKlB,KAAK,eAAe,EACpB,KAAK,aAAa,EACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,6BAA6B,EAAE,KAAK,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AACnG,OAAO,EAAE,KAAK,iBAAiB,EAA8C,MAAM,uBAAuB,CAAC;AAC3G,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAC;AAU1G,6EAA6E;AAC7E,MAAM,WAAW,qCAAqC;IACnD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8BAAsB,sCAAuC,SAAQ,6BAA6B;IAC/F,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IAC9C,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;IAC7C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,qCAAqC,CAAC;IAElE;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAsC;gBAEpF,QAAQ,EAAE,sBAAsB,EAAE,OAAO,GAAE,qCAA0C;IAOjG;;;;;;;;;;;;;;;OAeG;cACsB,mBAAmB,CACzC,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,qBAAqB,EAC/B,WAAW,EAAE,iBAAiB,GAC9B,OAAO,CAAC,IAAI,CAAC;cAsBG,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;IAM/G,wFAAwF;IACxF,SAAS,CAAC,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,qBAAqB,GAAG,IAAI;IAYpF,kFAAkF;IAClF,SAAS,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,qBAAqB,GAAG,IAAI;IAUnF;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAE5E,0FAA0F;IAC1F,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS;IAI1E,4GAA4G;IAC5G,SAAS,CAAC,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,iBAAiB,GAAG,SAAS;IAI9E,uFAAuF;IACvF,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;CAG9D"}

package/lib/lsp/semantic-token-provider.js

@@ -0,0 +1,148 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { AstUtils, CstUtils, GrammarAST, interruptAndCheck } from '@hydranium/langium';
+import { AbstractSemanticTokenProvider } from '@hydranium/langium/lsp';
+import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver';
+/** Normalise both {@link SemanticTokenKind} forms to the acceptor's shape. */
+function toAcceptorFields(kind, fallbackModifier) {
+    if (typeof kind === 'string') {
+        return fallbackModifier === undefined ? { type: kind } : { type: kind, modifier: fallbackModifier };
+    }
+    return kind.modifier === undefined && fallbackModifier !== undefined ? { type: kind.type, modifier: fallbackModifier } : { ...kind };
+}
+/**
+ * Semantic-token provider that derives highlighting from ONE adopter-supplied
+ * map of AST type → token kind, instead of a hand-written walk.
+ *
+ * **What it replaces.** Langium's {@link AbstractSemanticTokenProvider} hands
+ * you every node and asks you to emit tokens for it, so a grammar-specific
+ * provider becomes a chain of typeguards, each repeating two mechanical
+ * steps: emit the declaration name with `property: 'name'`, then emit one
+ * acceptor call per cross-reference property, remembering `index` for the
+ * multi-valued ones. Both steps are derivable, and getting the second one
+ * wrong is silent — a forgotten reference property simply renders uncoloured.
+ *
+ * **How the derivation works.**
+ * - The declaration name's PROPERTY comes from {@link NameProvider.getNameProperty},
+ *   so an `id`-keyed grammar works without the provider hardcoding `'name'`.
+ * - Cross-references are discovered with Langium's `streamReferences`, which
+ *   yields every reference on the node with its property and index already
+ *   filled in — so multi-valued references cannot be missed or mis-indexed.
+ * - A reference's kind is resolved from the reference's DECLARED target type
+ *   (`AstReflection.getReferenceType`), NOT from `ref.ref.$type`. That is
+ *   deliberate: the declared type is available whether or not the reference
+ *   resolves, so a broken or half-typed document keeps its colouring instead
+ *   of flickering as links come and go.
+ *
+ * The net effect is that {@link getTokenKind} — a `$type` string in, a token
+ * kind out — is usually the only member an adopter writes.
+ *
+ * Anything the map cannot express stays overridable: {@link getDeclarationKind}
+ * and {@link getReferenceKind} for per-node or per-property decisions,
+ * {@link highlightElement} for tokens that are neither a declaration nor a
+ * cross-reference (a sub-range, a single keyword of one rule). Returning
+ * `'prune'` from an override still skips the subtree, as upstream. Colouring
+ * EVERY keyword is not one of those cases — that is
+ * {@link HydraniumSemanticTokenProviderOptions.highlightKeywords}, which walks
+ * the CST once instead.
+ */
+export class AbstractHydraniumSemanticTokenProvider extends AbstractSemanticTokenProvider {
+    nameProvider;
+    reflection;
+    options;
+    /**
+     * Modifier added to every declaration token. `declaration` is what themes
+     * key on to render a definition differently from a use; override to
+     * `undefined` to add none.
+     */
+    declarationModifier = SemanticTokenModifiers.declaration;
+    constructor(services, options = {}) {
+        super(services);
+        this.nameProvider = services.references.NameProvider;
+        this.reflection = services.shared.AstReflection;
+        this.options = options;
+    }
+    /**
+     * The AST pass, then — when asked for — one CST pass over the keywords.
+     *
+     * **The keyword pass belongs here and not in {@link highlightElement}**,
+     * which is called once per AST node: a node reaching its own keyword leaves
+     * has to descend its CST subtree, and every node repeating that visits each
+     * leaf once per ancestor, so the AST-hosted version is O(leaves × depth)
+     * against this one's O(leaves). It also cannot be written correctly with a
+     * `prune`, because a keyword leaf's nearest AST node is not always the one
+     * whose rule contributed it.
+     *
+     * Emitting out of positional order is safe: `SemanticTokensBuilder` sorts
+     * before it encodes the deltas, so the two passes need not interleave. The
+     * range form of the request needs no accommodation either — the acceptor
+     * drops anything outside `currentRange` on its own.
+     */
+    async computeHighlighting(document, acceptor, cancelToken) {
+        await super.computeHighlighting(document, acceptor, cancelToken);
+        if (this.options.highlightKeywords !== true) {
+            return;
+        }
+        const root = document.parseResult.value.$cstNode;
+        if (root === undefined) {
+            return;
+        }
+        for (const cst of CstUtils.streamCst(root)) {
+            await interruptAndCheck(cancelToken);
+            // The grammar source is the whole filter. A keyword is always a leaf,
+            // and the hidden leaves a comment or a run of whitespace contributes
+            // are sourced from a terminal rule rather than a `Keyword` — so
+            // neither a composite-node check nor a hidden-token check adds
+            // anything here.
+            if (GrammarAST.isKeyword(cst.grammarSource)) {
+                acceptor({ cst, type: SemanticTokenTypes.keyword });
+            }
+        }
+    }
+    highlightElement(node, acceptor) {
+        this.highlightDeclaration(node, acceptor);
+        this.highlightReferences(node, acceptor);
+        return undefined;
+    }
+    /** Colour the node's own name, at whichever property the NameProvider reads it from. */
+    highlightDeclaration(node, acceptor) {
+        const kind = this.getDeclarationKind(node);
+        if (kind === undefined) {
+            return;
+        }
+        const property = this.getNameProperty(node);
+        if (property === undefined) {
+            return;
+        }
+        acceptor({ node, property, ...toAcceptorFields(kind, this.declarationModifier) });
+    }
+    /** Colour every cross-reference the node carries, including multi-valued ones. */
+    highlightReferences(node, acceptor) {
+        for (const info of AstUtils.streamReferences(node)) {
+            const kind = this.getReferenceKind(info);
+            if (kind === undefined) {
+                continue;
+            }
+            acceptor({ node: info.container, property: info.property, index: info.index, ...toAcceptorFields(kind) });
+        }
+    }
+    /** Kind for `node`'s own declaration. Defaults to {@link getTokenKind} on its `$type`. */
+    getDeclarationKind(node) {
+        return this.getTokenKind(node.$type);
+    }
+    /** Kind for a cross-reference. Defaults to {@link getTokenKind} on the reference's DECLARED target type. */
+    getReferenceKind(info) {
+        return this.getTokenKind(this.reflection.getReferenceType(info));
+    }
+    /** Property holding `node`'s name. Defaults to the language's {@link NameProvider}. */
+    getNameProperty(node) {
+        return this.nameProvider.getNameProperty(node);
+    }
+}
+//# sourceMappingURL=semantic-token-provider.js.map

package/lib/lsp/semantic-token-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-token-provider.js","sourceRoot":"","sources":["../../src/lsp/semantic-token-provider.ts"],"names":[],"mappings":"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"}

package/lib/lsp/shared-module.d.ts

@@ -0,0 +1,76 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type Module } from '@hydranium/langium';
+import { type PartialLangiumSharedServices } from '@hydranium/langium/lsp';
+import { LspLogger } from '../langium/diagnostics/lsp-logger.js';
+import { type ServerModuleContext, type ServerSharedServices } from '../langium/module.js';
+import { HydraniumDocumentUpdateHandler } from './hydranium-document-update-handler.js';
+/**
+ * Shared-tier slots contributed by the LSP-textual protocol head. Bound by
+ * {@link createLspServerSharedModule}; consumer modules layered after it can
+ * override any slot.
+ *
+ * - {@link LspLogger} replaces the shared tier's `NoopLogger` on the `Logger` slot,
+ *   so a head composing this module actually emits. It routes through the LSP
+ *   `window/logMessage` channel once a `Connection` is bound and to `stderr`
+ *   before that (or in a headless head that never binds one), and its
+ *   constructor is what applies the `HYDRANIUM_LOG_LEVEL` / `HYDRANIUM_LOG_FILE`
+ *   env baselines — so binding it here is also what makes `hydranium-cli
+ *   --log-level` reach the spawned server. Adopters wanting a different sink
+ *   (an output channel, a structured logger) override the slot after this
+ *   module.
+ *
+ * - {@link HydraniumDocumentUpdateHandler} wraps `didChangeWatchedFiles` to
+ *   suppress echo events for the server's own writes via the shared
+ *   `SelfSaveRegistry` slot, debounces `didChangeContent`, stamps build
+ *   reasons through `markNextReason`, and dispatches a rebuild when the last
+ *   client closes a document.
+ *   Adopters with their own update-handler subclass should extend
+ *   `HydraniumDocumentUpdateHandler` (not Langium's
+ *   `DefaultDocumentUpdateHandler`) to preserve those behaviours.
+ *
+ * **Why this is a shared slot and not a per-language one.** Langium declares
+ * `DocumentUpdateHandler` in `LangiumSharedLSPServices` — there is exactly one
+ * per server, and `startLanguageServer` reads it off the shared tree. It is
+ * parameterised by the CLIENT PROTOCOL (which LSP notifications arrive), not
+ * by the grammar — the rule for which DI scope a service belongs to. Binding
+ * it per language is inert: nothing reads a per-language
+ * `lsp.DocumentUpdateHandler`, and under a multi-grammar composition a
+ * per-language binding would attach N listener sets to the one document store.
+ */
+export interface LspServerAddedSharedServices {
+    Logger: LspLogger;
+    lsp: {
+        DocumentUpdateHandler: HydraniumDocumentUpdateHandler;
+    };
+}
+/**
+ * Full shared-service surface visible to consumers that compose this head:
+ * `@hydranium/core`'s shared bindings plus the LSP-textual additions. Use as
+ * the `T` type parameter for the consumer's own
+ * `Module<LspServerSharedServices, ...>` if its overrides depend on any
+ * LSP-only shared slot.
+ */
+export type LspServerSharedServices = ServerSharedServices & LspServerAddedSharedServices;
+/**
+ * The LSP-textual protocol head's default shared module. Composes on top of
+ * `createServerSharedModule` — as a later `inject(...)` argument, or as
+ * `sharedModules.extra` when composing through `createIntegrationServices`;
+ * the adopter's own shared module goes after it either way.
+ *
+ * `createServerSharedModule` MUST be merged before this one — the lsp-server
+ * head only contributes LSP-textual-specific slots and relies on
+ * `@hydranium/core`'s `SelfSaveRegistry` / `TextDocuments` / `DocumentBuilder`
+ * bindings being present.
+ *
+ * Returned as a function (not a constant) so head defaults can read from the
+ * construction context, mirroring `createLspServerLanguageModule`.
+ */
+export declare function createLspServerSharedModule(_context: ServerModuleContext): Module<LspServerSharedServices, PartialLangiumSharedServices & LspServerAddedSharedServices>;
+//# sourceMappingURL=shared-module.d.ts.map

package/lib/lsp/shared-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-module.d.ts","sourceRoot":"","sources":["../../src/lsp/shared-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EAAE,8BAA8B,EAAE,MAAM,wCAAwC,CAAC;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,WAAW,4BAA4B;IAC3B,MAAM,EAAE,SAAS,CAAC;IACjC,GAAG,EAAE;QACa,qBAAqB,EAAE,8BAA8B,CAAC;KACvE,CAAC;CACJ;AAED;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG,oBAAoB,GAAG,4BAA4B,CAAC;AAE1F;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACxC,QAAQ,EAAE,mBAAmB,GAC7B,MAAM,CAAC,uBAAuB,EAAE,4BAA4B,GAAG,4BAA4B,CAAC,CAO9F"}

package/lib/lsp/shared-module.js

@@ -0,0 +1,33 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { LspLogger } from '../langium/diagnostics/lsp-logger.js';
+import { HydraniumDocumentUpdateHandler } from './hydranium-document-update-handler.js';
+/**
+ * The LSP-textual protocol head's default shared module. Composes on top of
+ * `createServerSharedModule` — as a later `inject(...)` argument, or as
+ * `sharedModules.extra` when composing through `createIntegrationServices`;
+ * the adopter's own shared module goes after it either way.
+ *
+ * `createServerSharedModule` MUST be merged before this one — the lsp-server
+ * head only contributes LSP-textual-specific slots and relies on
+ * `@hydranium/core`'s `SelfSaveRegistry` / `TextDocuments` / `DocumentBuilder`
+ * bindings being present.
+ *
+ * Returned as a function (not a constant) so head defaults can read from the
+ * construction context, mirroring `createLspServerLanguageModule`.
+ */
+export function createLspServerSharedModule(_context) {
+    return {
+        Logger: services => new LspLogger(services),
+        lsp: {
+            DocumentUpdateHandler: services => new HydraniumDocumentUpdateHandler(services)
+        }
+    };
+}
+//# sourceMappingURL=shared-module.js.map

package/lib/lsp/shared-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-module.js","sourceRoot":"","sources":["../../src/lsp/shared-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAIlF,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAEjE,OAAO,EAAE,8BAA8B,EAAE,MAAM,wCAAwC,CAAC;AAmDxF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,2BAA2B,CACxC,QAA6B;IAE7B,OAAO;QACJ,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC;QAC3C,GAAG,EAAE;YACF,qBAAqB,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,8BAA8B,CAAC,QAAQ,CAAC;SACjF;KACH,CAAC;AACL,CAAC"}

package/lib/lsp/start-language-server.d.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type LangiumSharedServices, type ServiceRequirements } from '@hydranium/langium/lsp';
+/**
+ * Fail the LSP head's start when its shared module was never composed.
+ *
+ * **The composition mistake this catches.** `lsp.DocumentUpdateHandler` is a
+ * SHARED slot, so the head binds it in `createLspServerSharedModule` — a
+ * separate module from `createLspServerLanguageModule`. An adopter who adds
+ * only the language module gets a server that boots, links and serves
+ * completion, and quietly runs Langium's `DefaultDocumentUpdateHandler`: echo
+ * suppression for the server's own writes, the `didChangeContent` debounce,
+ * `markNextReason` stamping and the last-client-close rebuild are all absent,
+ * with nothing in the log to say so.
+ *
+ * The type system does not catch it. `createIntegrationServices` returns
+ * `inject(...) as unknown as TShared`, so widening `TShared` with
+ * `LspServerAddedSharedServices` while omitting the module type-checks and
+ * leaves the slot holding Langium's default.
+ *
+ * Checked with `instanceof`, so an adopter subclass of
+ * {@link HydraniumDocumentUpdateHandler} — the documented way to extend the
+ * handler — passes.
+ *
+ * Skips silently when no connection is bound: that is a more fundamental
+ * misconfiguration, and Langium reports it immediately afterwards in its own
+ * vocabulary. Reporting it here as a missing module would misname it.
+ */
+export declare function assertLspHeadComposed(services: LangiumSharedServices): void;
+/**
+ * The framework's LSP server entry point: {@link assertLspHeadComposed}, then
+ * Langium's `startLanguageServer` unchanged. Signature-compatible with
+ * Langium's, so it is a drop-in for adopters importing from
+ * `@hydranium/core/lsp`.
+ */
+export declare function startLanguageServer(services: LangiumSharedServices, serviceRequirements?: Partial<ServiceRequirements>): void;
+//# sourceMappingURL=start-language-server.d.ts.map

package/lib/lsp/start-language-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-language-server.d.ts","sourceRoot":"","sources":["../../src/lsp/start-language-server.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAEJ,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EAC1B,MAAM,wBAAwB,CAAC;AAGhC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,IAAI,CAe3E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,qBAAqB,EAAE,mBAAmB,GAAE,OAAO,CAAC,mBAAmB,CAAM,GAAG,IAAI,CAGjI"}