@hydranium/glsp-server 1.0.0-next.10

package/lib/state/hydranium-glsp-index.d.ts

@@ -0,0 +1,220 @@
+/********************************************************************************
+ * Copyright (c) 2023-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 GModelElement, GModelIndex } from '@eclipse-glsp/server';
+import { type AstNode, type URI } from '@hydranium/langium';
+import { type ElementKeyProvider, type ServerLanguageServices, type ServerSharedServices } from '@hydranium/core';
+/**
+ * GLSP model index extended with an AST-node ↔ id map so adopters can
+ * resolve diagram elements back to their source-language nodes during
+ * action handling, layout, validation, and submission.
+ *
+ * Indexing strategy is hookable via {@link doFindId}: the framework default
+ * uses {@link ElementKeyProvider.getElementKey} — a document-scoped lookup
+ * token built from the node's named ancestors, falling back to positional
+ * segments for unnamed nodes. Under the bound default that key is name-based,
+ * so a GModel id survives an edit that does not rename the node or an ancestor
+ * and changes when one does; the positional strategy is the rename-stable
+ * alternative. Adopters with a different stability boundary override
+ * {@link doFindId}.
+ *
+ * **Duplicate-id degrade.** A GModel tree must have unique element ids. Two
+ * AST nodes that collide on their stable id — exactly the state the diagram is
+ * meant to *mark* — project to two GModel elements with the same id. The GLSP
+ * client's sprotty `SGraphIndex.add` throws on such a duplicate inside
+ * `SModelFactory.initializeRoot`, aborting the build and blanking the WHOLE
+ * diagram. {@link indexRoot} prunes the colliding element(s) from the tree —
+ * the same object `ModelSubmissionHandler`
+ * submits — so the wire payload stays well-formed for every client and the
+ * surviving (first, document-order) element still carries the diagnostic
+ * marker. {@link doIndex} keeps a log-and-skip guard for any path that
+ * re-indexes a subtree without going through {@link indexRoot}.
+ */
+export declare class HydraniumGlspIndex extends GModelIndex {
+    protected readonly sharedServices: ServerSharedServices;
+    protected idToSemanticNode: Map<string, AstNode>;
+    /**
+     * The language services of the diagram's OWN document, captured from the
+     * source root in {@link indexSourceRoot}. Used only as the fallback for a
+     * node that routes nowhere — a synthetic or freshly-built node with no
+     * `$document` yet, which a GModel factory legitimately hands us mid-edit.
+     *
+     * Captured rather than injected because it is the language the loaded
+     * document ACTUALLY routes to, which is not necessarily the one the diagram
+     * module declared — precisely the drift
+     * `AbstractHydraniumGlspState.checkDeclaredLanguage` warns about. (Not
+     * a cost argument: {@link HydraniumTypes}.DiagramLanguage is bound
+     * `inSingletonScope`, so injecting it would resolve once per session too.)
+     */
+    protected diagramLanguage?: ServerLanguageServices;
+    /**
+     * The grammar the diagram module declared, as the last resort behind
+     * {@link diagramLanguage}.
+     *
+     * Order-independent where the captured one is not: GLSP builds every
+     * operation handler at `InitializeClientSession`, so a document-less node
+     * can reach {@link createId} before the first {@link indexSourceRoot} — and
+     * with no language at all that mints an unstable `fallback_<uuid>` where a
+     * stable positional key was available. `@optional()` so a harness that binds
+     * no diagram module still resolves.
+     */
+    protected readonly declaredLanguage?: ServerLanguageServices;
+    /**
+     * Reverse map: the *stable id* of the AST element a GModel element
+     * represents → the GModel id(s) that render it. Multi-valued because one
+     * element can be drawn as several GModel nodes — placed twice on the same
+     * canvas, or projected by several referencing nodes.
+     * Populated explicitly by adopters via {@link registerElementId} (the forward
+     * {@link idToSemanticNode} keys by GModel id and can't express the same
+     * element rendering more than once). Consumed by diagnostic→marker mapping to
+     * find every node to mark for a given element.
+     *
+     * Keyed by the element's stable id (a string), NOT the `AstNode` itself, so
+     * it never retains AST node references across rebuilds. Cleared with the
+     * forward index in {@link indexSourceRoot}; re-registration each GModel
+     * rebuild is idempotent (a Set), and any id no longer drawn is filtered by
+     * the consumer's rendered-check, so stale entries are harmless.
+     */
+    protected elementToIds: Map<string, Set<string>>;
+    /**
+     * The uris of the documents whose elements can map to a marker on this
+     * diagram: the diagram's own document (seeded in {@link indexSourceRoot})
+     * plus every document reached through a reference projection (added in
+     * {@link registerElementId}). Lets the diagnostic→marker validator resolve
+     * only the documents that actually contribute rendered elements rather than
+     * every loaded document. Self-maintaining: every {@link registerElementId}
+     * caller auto-includes its document.
+     */
+    protected renderedDocUris: Set<string>;
+    /**
+     * Return the GModel id assigned to `node`, or — when no id is found and
+     * a `fallback` is supplied — the value of `fallback()`. The two-overload
+     * shape preserves the caller's narrowing: with a `() => string` fallback
+     * the return is `string`; with a `() => string | undefined` (or no
+     * fallback) the return is `string | undefined`.
+     *
+     * A convenience over {@link doFindId}, NOT the id-strategy hook. Framework
+     * internals call `doFindId` directly (see {@link indexSourceRoot}), so an
+     * override here changes only what external callers of this method see —
+     * override `doFindId` to change how nodes are keyed.
+     */
+    findId(node: AstNode | undefined, fallback: () => string): string;
+    findId(node: AstNode | undefined, fallback?: () => string | undefined): string | undefined;
+    /**
+     * Hook for the adopter id-assignment strategy. Framework default reads
+     * {@link ElementKeyProvider.getElementKey} from the language owning `node`,
+     * which under the bound default is name-based and falls back to positional
+     * segments for unnamed nodes.
+     *
+     * `keyProvider` is an optional hint: the provider for THIS node, already
+     * resolved by the caller. {@link indexSourceRoot} passes it because every
+     * node in a containment walk belongs to the root's document by
+     * construction, so the per-node lookup would re-derive one known answer N
+     * times. An override that ignores the parameter stays correct, at the cost
+     * of that lookup.
+     */
+    protected doFindId(node?: AstNode, keyProvider?: ElementKeyProvider): string | undefined;
+    /**
+     * The {@link ElementKeyProvider} of the language owning `node`'s document,
+     * falling back to the language the diagram document routes to and then to
+     * the one its module declared, for a node that routes nowhere.
+     *
+     * **Resolved per node on the cross-document entry points.** This index is
+     * deliberately cross-document — {@link registerElementId} and
+     * {@link findElementIds} key elements reached through a reference, and
+     * {@link renderedDocUris} exists precisely because those live in other
+     * documents. A single captured provider therefore keys foreign nodes under
+     * the wrong grammar as soon as two registered languages differ in their key
+     * strategy: a plausible-looking id that matches nothing, so selection,
+     * marker mapping and element lookup silently miss. Those entry points are a
+     * bounded set the adopter calls explicitly; the full-document walk in
+     * {@link indexSourceRoot} needs no per-node lookup and does not pay for one.
+     */
+    protected elementKeyProviderFor(node?: AstNode): ElementKeyProvider | undefined;
+    /** Return the GModel id assigned to `node`, falling back to a fresh `fallback_<uuid>`. */
+    createId(node?: AstNode): string;
+    /**
+     * Return the GModel id assigned to `node` or throw if none is available.
+     *
+     * The failure names the node's type and position rather than its source
+     * text. Interpolating `$cstNode.text` would put the user's own model content
+     * into a string that reaches a log, a client toast and an adopter's
+     * telemetry alike, so the exposure does not depend on which surface
+     * receives it. Type and position identify the node for whoever is debugging
+     * without carrying any of it, and positions are 1-based so they match what
+     * an editor shows.
+     */
+    assertId(node?: AstNode): string;
+    /**
+     * Walk the source root and index every reachable AST node with a resolvable
+     * id.
+     *
+     * `uri` is the diagram document's URI, supplied by
+     * `AbstractHydraniumGlspState.setSourceRoot`, and is used only to
+     * resolve the diagram's language when `root` carries no `$document` —
+     * always the case for a synthesised root, and the more authoritative signal
+     * either way since it is what the caller declared it was loading.
+     *
+     * The walk resolves the key provider ONCE and threads it: `streamAllContents`
+     * is containment-only, so every node it yields has `root` as its root node
+     * and therefore the language just resolved. Looking it up per node would
+     * walk the container chain and Langium's whole lookup ladder — declared
+     * languageId, file name, extension — for an answer already in hand, on every
+     * diagram open and every source-root refresh.
+     */
+    indexSourceRoot(root: AstNode, uri?: URI | string): void;
+    /**
+     * Register that the GModel element `id` renders `element` — the reverse of
+     * the GModel-id keying. Adopters call this when a GModel element represents
+     * an AST element that is *not* keyed by its own id — most importantly a
+     * diagram node keyed by its own id while visually standing for the element
+     * it references. Additive: registering the same `element` under several ids
+     * records every occurrence.
+     */
+    registerElementId(element: AstNode, id: string): void;
+    /** The uris of the documents that contribute elements rendered on this diagram. */
+    renderedDocumentUris(): readonly string[];
+    /** Record `node`'s document uri (if it has one) as contributing rendered elements. */
+    protected addRenderedDocUri(node: AstNode): void;
+    /** The GModel ids registered (via {@link registerElementId}) as rendering `element`; empty if none. */
+    findElementIds(element?: AstNode): readonly string[];
+    /** `keyProvider` is {@link doFindId}'s already-resolved hint; see {@link indexSourceRoot}. */
+    protected indexAstNode(node: AstNode, keyProvider?: ElementKeyProvider): void;
+    /** Insert an AST node under `id` directly — for adopters that need to seed entries outside the standard walk. */
+    indexSemanticElement<T extends AstNode>(id: string, element: T): void;
+    /** Look up the AST node previously indexed under `id`. */
+    findSemanticElement(id: string): AstNode | undefined;
+    findSemanticElement<T extends AstNode>(id: string, guard: (item: unknown) => item is T): T | undefined;
+    /**
+     * Prune duplicate-id elements from the GModel tree, then index it.
+     *
+     * {@link GModelIndex.indexRoot} runs on the exact object the submission
+     * handler later serializes (`DefaultModelState.updateRoot` assigns
+     * `this.root = newRoot` immediately before `this.index.indexRoot(newRoot)`),
+     * so removing duplicates here also removes them from the submitted payload —
+     * the only place the fix protects every client rather than one tolerant one.
+     */
+    indexRoot(root: GModelElement): void;
+    /**
+     * Remove every element whose id was already seen earlier in a depth-first
+     * walk; the first occurrence (document order) wins and a dropped element
+     * takes its whole subtree with it. Splices in place so the parent's
+     * `children` array identity is preserved; logs each drop via the bound
+     * logger. The root itself is the first id seen and can never be a duplicate.
+     */
+    protected pruneDuplicateIds(root: GModelElement): void;
+    /**
+     * Log-and-skip guard for duplicate GModel ids. {@link indexRoot}'s prune
+     * already removes duplicates from the tree before this runs, so in the
+     * normal flow this never fires; it stays as a last line of defence for any
+     * path that re-indexes a subtree directly (where {@link GModelIndex.doIndex}
+     * would otherwise throw).
+     */
+    protected doIndex(element: GModelElement): void;
+}
+//# sourceMappingURL=hydranium-glsp-index.d.ts.map

package/lib/state/hydranium-glsp-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydranium-glsp-index.d.ts","sourceRoot":"","sources":["../../src/state/hydranium-glsp-index.ts"],"names":[],"mappings":"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"}

package/lib/state/hydranium-glsp-index.js

@@ -0,0 +1,320 @@
+/********************************************************************************
+ * Copyright (c) 2023-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
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { GModelIndex } from '@eclipse-glsp/server';
+import { inject, injectable, optional } from 'inversify';
+import { AstUtils } from '@hydranium/langium';
+import * as uuid from 'uuid';
+import { HydraniumTypes } from './hydranium-shared-core-services.js';
+/**
+ * GLSP model index extended with an AST-node ↔ id map so adopters can
+ * resolve diagram elements back to their source-language nodes during
+ * action handling, layout, validation, and submission.
+ *
+ * Indexing strategy is hookable via {@link doFindId}: the framework default
+ * uses {@link ElementKeyProvider.getElementKey} — a document-scoped lookup
+ * token built from the node's named ancestors, falling back to positional
+ * segments for unnamed nodes. Under the bound default that key is name-based,
+ * so a GModel id survives an edit that does not rename the node or an ancestor
+ * and changes when one does; the positional strategy is the rename-stable
+ * alternative. Adopters with a different stability boundary override
+ * {@link doFindId}.
+ *
+ * **Duplicate-id degrade.** A GModel tree must have unique element ids. Two
+ * AST nodes that collide on their stable id — exactly the state the diagram is
+ * meant to *mark* — project to two GModel elements with the same id. The GLSP
+ * client's sprotty `SGraphIndex.add` throws on such a duplicate inside
+ * `SModelFactory.initializeRoot`, aborting the build and blanking the WHOLE
+ * diagram. {@link indexRoot} prunes the colliding element(s) from the tree —
+ * the same object `ModelSubmissionHandler`
+ * submits — so the wire payload stays well-formed for every client and the
+ * surviving (first, document-order) element still carries the diagnostic
+ * marker. {@link doIndex} keeps a log-and-skip guard for any path that
+ * re-indexes a subtree without going through {@link indexRoot}.
+ */
+let HydraniumGlspIndex = class HydraniumGlspIndex extends GModelIndex {
+    sharedServices;
+    idToSemanticNode = new Map();
+    /**
+     * The language services of the diagram's OWN document, captured from the
+     * source root in {@link indexSourceRoot}. Used only as the fallback for a
+     * node that routes nowhere — a synthetic or freshly-built node with no
+     * `$document` yet, which a GModel factory legitimately hands us mid-edit.
+     *
+     * Captured rather than injected because it is the language the loaded
+     * document ACTUALLY routes to, which is not necessarily the one the diagram
+     * module declared — precisely the drift
+     * `AbstractHydraniumGlspState.checkDeclaredLanguage` warns about. (Not
+     * a cost argument: {@link HydraniumTypes}.DiagramLanguage is bound
+     * `inSingletonScope`, so injecting it would resolve once per session too.)
+     */
+    diagramLanguage;
+    /**
+     * The grammar the diagram module declared, as the last resort behind
+     * {@link diagramLanguage}.
+     *
+     * Order-independent where the captured one is not: GLSP builds every
+     * operation handler at `InitializeClientSession`, so a document-less node
+     * can reach {@link createId} before the first {@link indexSourceRoot} — and
+     * with no language at all that mints an unstable `fallback_<uuid>` where a
+     * stable positional key was available. `@optional()` so a harness that binds
+     * no diagram module still resolves.
+     */
+    declaredLanguage;
+    /**
+     * Reverse map: the *stable id* of the AST element a GModel element
+     * represents → the GModel id(s) that render it. Multi-valued because one
+     * element can be drawn as several GModel nodes — placed twice on the same
+     * canvas, or projected by several referencing nodes.
+     * Populated explicitly by adopters via {@link registerElementId} (the forward
+     * {@link idToSemanticNode} keys by GModel id and can't express the same
+     * element rendering more than once). Consumed by diagnostic→marker mapping to
+     * find every node to mark for a given element.
+     *
+     * Keyed by the element's stable id (a string), NOT the `AstNode` itself, so
+     * it never retains AST node references across rebuilds. Cleared with the
+     * forward index in {@link indexSourceRoot}; re-registration each GModel
+     * rebuild is idempotent (a Set), and any id no longer drawn is filtered by
+     * the consumer's rendered-check, so stale entries are harmless.
+     */
+    elementToIds = new Map();
+    /**
+     * The uris of the documents whose elements can map to a marker on this
+     * diagram: the diagram's own document (seeded in {@link indexSourceRoot})
+     * plus every document reached through a reference projection (added in
+     * {@link registerElementId}). Lets the diagnostic→marker validator resolve
+     * only the documents that actually contribute rendered elements rather than
+     * every loaded document. Self-maintaining: every {@link registerElementId}
+     * caller auto-includes its document.
+     */
+    renderedDocUris = new Set();
+    findId(node, fallback = () => undefined) {
+        return this.doFindId(node) ?? fallback();
+    }
+    /**
+     * Hook for the adopter id-assignment strategy. Framework default reads
+     * {@link ElementKeyProvider.getElementKey} from the language owning `node`,
+     * which under the bound default is name-based and falls back to positional
+     * segments for unnamed nodes.
+     *
+     * `keyProvider` is an optional hint: the provider for THIS node, already
+     * resolved by the caller. {@link indexSourceRoot} passes it because every
+     * node in a containment walk belongs to the root's document by
+     * construction, so the per-node lookup would re-derive one known answer N
+     * times. An override that ignores the parameter stays correct, at the cost
+     * of that lookup.
+     */
+    doFindId(node, keyProvider) {
+        return (keyProvider ?? this.elementKeyProviderFor(node))?.getElementKey(node);
+    }
+    /**
+     * The {@link ElementKeyProvider} of the language owning `node`'s document,
+     * falling back to the language the diagram document routes to and then to
+     * the one its module declared, for a node that routes nowhere.
+     *
+     * **Resolved per node on the cross-document entry points.** This index is
+     * deliberately cross-document — {@link registerElementId} and
+     * {@link findElementIds} key elements reached through a reference, and
+     * {@link renderedDocUris} exists precisely because those live in other
+     * documents. A single captured provider therefore keys foreign nodes under
+     * the wrong grammar as soon as two registered languages differ in their key
+     * strategy: a plausible-looking id that matches nothing, so selection,
+     * marker mapping and element lookup silently miss. Those entry points are a
+     * bounded set the adopter calls explicitly; the full-document walk in
+     * {@link indexSourceRoot} needs no per-node lookup and does not pay for one.
+     */
+    elementKeyProviderFor(node) {
+        const language = this.sharedServices.ServiceRegistry.getServicesFor(node) ?? this.diagramLanguage ?? this.declaredLanguage;
+        return language?.references.ElementKeyProvider;
+    }
+    /** Return the GModel id assigned to `node`, falling back to a fresh `fallback_<uuid>`. */
+    createId(node) {
+        return this.findId(node, () => 'fallback_' + uuid.v4());
+    }
+    /**
+     * Return the GModel id assigned to `node` or throw if none is available.
+     *
+     * The failure names the node's type and position rather than its source
+     * text. Interpolating `$cstNode.text` would put the user's own model content
+     * into a string that reaches a log, a client toast and an adopter's
+     * telemetry alike, so the exposure does not depend on which surface
+     * receives it. Type and position identify the node for whoever is debugging
+     * without carrying any of it, and positions are 1-based so they match what
+     * an editor shows.
+     */
+    assertId(node) {
+        const id = this.findId(node);
+        if (!id) {
+            const start = node?.$cstNode?.range.start;
+            const at = start === undefined ? '' : ` at ${start.line + 1}:${start.character + 1}`;
+            throw new Error(`Could not create ID for ${node?.$type ?? 'an absent node'}${at}`);
+        }
+        return id;
+    }
+    /**
+     * Walk the source root and index every reachable AST node with a resolvable
+     * id.
+     *
+     * `uri` is the diagram document's URI, supplied by
+     * `AbstractHydraniumGlspState.setSourceRoot`, and is used only to
+     * resolve the diagram's language when `root` carries no `$document` —
+     * always the case for a synthesised root, and the more authoritative signal
+     * either way since it is what the caller declared it was loading.
+     *
+     * The walk resolves the key provider ONCE and threads it: `streamAllContents`
+     * is containment-only, so every node it yields has `root` as its root node
+     * and therefore the language just resolved. Looking it up per node would
+     * walk the container chain and Langium's whole lookup ladder — declared
+     * languageId, file name, extension — for an answer already in hand, on every
+     * diagram open and every source-root refresh.
+     */
+    indexSourceRoot(root, uri) {
+        this.idToSemanticNode.clear();
+        this.elementToIds.clear();
+        this.renderedDocUris.clear();
+        const registry = this.sharedServices.ServiceRegistry;
+        this.diagramLanguage = registry.getServicesFor(root) ?? registry.getServicesFor(uri);
+        this.addRenderedDocUri(root);
+        const keyProvider = this.elementKeyProviderFor(root);
+        AstUtils.streamAllContents(root).forEach(node => this.indexAstNode(node, keyProvider));
+    }
+    /**
+     * Register that the GModel element `id` renders `element` — the reverse of
+     * the GModel-id keying. Adopters call this when a GModel element represents
+     * an AST element that is *not* keyed by its own id — most importantly a
+     * diagram node keyed by its own id while visually standing for the element
+     * it references. Additive: registering the same `element` under several ids
+     * records every occurrence.
+     */
+    registerElementId(element, id) {
+        const key = this.doFindId(element);
+        if (key === undefined) {
+            return;
+        }
+        const ids = this.elementToIds.get(key);
+        if (ids) {
+            ids.add(id);
+        }
+        else {
+            this.elementToIds.set(key, new Set([id]));
+        }
+        this.addRenderedDocUri(element);
+    }
+    /** The uris of the documents that contribute elements rendered on this diagram. */
+    renderedDocumentUris() {
+        return [...this.renderedDocUris];
+    }
+    /** Record `node`'s document uri (if it has one) as contributing rendered elements. */
+    addRenderedDocUri(node) {
+        const uri = AstUtils.findRootNode(node).$document?.uri.toString();
+        if (uri !== undefined) {
+            this.renderedDocUris.add(uri);
+        }
+    }
+    /** The GModel ids registered (via {@link registerElementId}) as rendering `element`; empty if none. */
+    findElementIds(element) {
+        const key = element ? this.doFindId(element) : undefined;
+        const ids = key !== undefined ? this.elementToIds.get(key) : undefined;
+        return ids ? [...ids] : [];
+    }
+    /** `keyProvider` is {@link doFindId}'s already-resolved hint; see {@link indexSourceRoot}. */
+    indexAstNode(node, keyProvider) {
+        const id = this.doFindId(node, keyProvider);
+        if (id) {
+            this.indexSemanticElement(id, node);
+        }
+    }
+    /** Insert an AST node under `id` directly — for adopters that need to seed entries outside the standard walk. */
+    indexSemanticElement(id, element) {
+        this.idToSemanticNode.set(id, element);
+    }
+    findSemanticElement(id, guard) {
+        const semanticNode = this.idToSemanticNode.get(id);
+        if (guard) {
+            return guard(semanticNode) ? semanticNode : undefined;
+        }
+        return semanticNode;
+    }
+    /**
+     * Prune duplicate-id elements from the GModel tree, then index it.
+     *
+     * {@link GModelIndex.indexRoot} runs on the exact object the submission
+     * handler later serializes (`DefaultModelState.updateRoot` assigns
+     * `this.root = newRoot` immediately before `this.index.indexRoot(newRoot)`),
+     * so removing duplicates here also removes them from the submitted payload —
+     * the only place the fix protects every client rather than one tolerant one.
+     */
+    indexRoot(root) {
+        this.pruneDuplicateIds(root);
+        super.indexRoot(root);
+    }
+    /**
+     * Remove every element whose id was already seen earlier in a depth-first
+     * walk; the first occurrence (document order) wins and a dropped element
+     * takes its whole subtree with it. Splices in place so the parent's
+     * `children` array identity is preserved; logs each drop via the bound
+     * logger. The root itself is the first id seen and can never be a duplicate.
+     */
+    pruneDuplicateIds(root) {
+        const seen = new Set([root.id]);
+        const visit = (element) => {
+            const children = element.children;
+            let index = 0;
+            while (index < children.length) {
+                const child = children[index];
+                if (seen.has(child.id)) {
+                    this.sharedServices.Logger.for('Index').warn('Dropping duplicate element id from submitted graph: ' + child.id);
+                    children.splice(index, 1); // drop child + subtree; do not advance — the next child shifts into `index`
+                }
+                else {
+                    seen.add(child.id);
+                    visit(child);
+                    index++;
+                }
+            }
+        };
+        visit(root);
+    }
+    /**
+     * Log-and-skip guard for duplicate GModel ids. {@link indexRoot}'s prune
+     * already removes duplicates from the tree before this runs, so in the
+     * normal flow this never fires; it stays as a last line of defence for any
+     * path that re-indexes a subtree directly (where {@link GModelIndex.doIndex}
+     * would otherwise throw).
+     */
+    doIndex(element) {
+        if (this.idToElement.has(element.id)) {
+            this.sharedServices.Logger.for('Index').error('Duplicate element id in graph: ' + element.id);
+            return;
+        }
+        super.doIndex(element);
+    }
+};
+__decorate([
+    inject(HydraniumTypes.SharedCoreServices),
+    __metadata("design:type", Object)
+], HydraniumGlspIndex.prototype, "sharedServices", void 0);
+__decorate([
+    inject(HydraniumTypes.DiagramLanguage),
+    optional(),
+    __metadata("design:type", Object)
+], HydraniumGlspIndex.prototype, "declaredLanguage", void 0);
+HydraniumGlspIndex = __decorate([
+    injectable()
+], HydraniumGlspIndex);
+export { HydraniumGlspIndex };
+//# sourceMappingURL=hydranium-glsp-index.js.map

package/lib/state/hydranium-glsp-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydranium-glsp-index.js","sourceRoot":"","sources":["../../src/state/hydranium-glsp-index.ts"],"names":[],"mappings":"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"}

package/lib/state/hydranium-shared-core-services.d.ts

@@ -0,0 +1,90 @@
+/********************************************************************************
+ * 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 { ServerLanguageServices, ServerSharedServices } from '@hydranium/core';
+import type { ConflictResolver, Tracer } from '@hydranium/protocol';
+/**
+ * Inversify service-identifier registry for the framework services the
+ * `@hydranium/glsp-server` runtime exposes to `@injectable()` GLSP
+ * components. Framework GLSP-side classes are `@injectable()` and need an
+ * Inversify token to receive the Langium-style services the rest of the
+ * framework hands around via plain constructor arguments.
+ *
+ * Every token here is a service whose value is **fixed for the container tier
+ * that binds it** — process-wide shared services, a per-session conflict
+ * policy, the grammar a diagram type edits. That is the whole membership rule,
+ * and it is why the registry is short: see below for what deliberately does
+ * NOT get a token.
+ *
+ * Grouped under one object (rather than top-level `Hydranium<Role>` consts)
+ * so the token identity is decoupled from the implementation class name.
+ * Mirrors GLSP's own `TYPES` registry idiom.
+ *
+ * Bound by the adopter from their services trees — the app-tier ones directly,
+ * the session-tier language by declaring a grammar on the diagram module.
+ * Inject with the real service type as the field type.
+ *
+ * **Split by tier, because GLSP has no language tier.** GLSP's containers are
+ * app (per process) -> server (per connection) -> session (per open diagram);
+ * Langium's are shared (per process) -> language (per grammar, routed by URI).
+ * Only the outermost pair line up. A per-language service therefore CANNOT be
+ * bound at the app tier — that container is built before any document exists,
+ * so it can only ever hold one grammar's services. The tokens below are split
+ * accordingly:
+ *
+ * - **SharedCoreServices** — the framework's Langium-style shared services
+ *   tree ({@link ServerSharedServices}); the services-tree root that state /
+ *   index classes inject. Bound once at the app tier. Carries
+ *   `ServiceRegistry`, which is how everything below reaches a language.
+ * - **DiagramLanguage** — the {@link ServerLanguageServices} of the grammar a
+ *   diagram type edits, bound at the SESSION tier by
+ *   `AbstractHydraniumGlspDiagramModule` from its declared `declareLanguage()`.
+ *   Static (a diagram type has one grammar), so it is safe for the eagerly
+ *   constructed handlers GLSP builds at `InitializeClientSession`. Read it
+ *   through `AbstractHydraniumGlspState.diagramLanguage`.
+ * - **ConflictResolver** — the policy the GLSP state consults when a write
+ *   (forward-write, undo, redo, save) races a foreign edit.
+ *   `HydraniumGlspAppModule` binds it to `options.conflictResolver`
+ *   when supplied, else a default `ReconcilingConflictResolver` (field-level
+ *   three-way merge) unless the adopter opts into `ForceConflictResolver`.
+ * - **Tracer** — the measure-and-emit observability handle (timing, memory,
+ *   profiling). Bound per-request, auto-tagged with the requesting class name
+ *   (mirroring GLSP's `LoggerFactory` caller-tagging), so an `@injectable()`
+ *   GLSP class that times just injects it and its timing lines carry its own
+ *   component — no manual `for(...)`. The non-injectable recording command,
+ *   which can't inject, borrows the state's `tracer` getter instead.
+ *
+ * **No per-language SERVICE has a token — only the language does.** There is
+ * no `ElementKeyProvider`, `NameProvider`, `ScopeProvider` or
+ * `CandidateProvider` symbol, because every one of them is keyed by a document
+ * that the container cannot know: the target node's, for naming and keying;
+ * the one a reference is WRITTEN in, for scope and candidates. A GLSP
+ * component asks about several documents over its life — the diagram's own,
+ * the element it is editing, a drop target — so an injected provider instance
+ * answers as if there were one right answer and the routing decision vanishes
+ * from the call site. `this.candidateProvider` reads as language-neutral, and
+ * nothing prompts the author to ask which document the reference lives in;
+ * that is exactly how a foreign node ends up named under the diagram's
+ * grammar, producing a plausible string that matches nothing.
+ *
+ * So callers name the language they mean: `modelState.diagramLanguage` for a
+ * reference written on the canvas, `modelState.languageServicesFor(node)` for
+ * anything reached through a reference. `ServiceRegistry.getServicesFor(target)`
+ * serves the same purpose where no model state is at hand.
+ *
+ * The app-tier tokens are bound by `HydraniumGlspAppModule`, the
+ * session-tier one by `AbstractHydraniumGlspDiagramModule`. A multi-grammar
+ * adopter declares a language per diagram module and needs nothing else.
+ */
+export declare const HydraniumTypes: {
+    readonly SharedCoreServices: import("inversify").interfaces.ServiceIdentifier<ServerSharedServices>;
+    readonly DiagramLanguage: import("inversify").interfaces.ServiceIdentifier<ServerLanguageServices>;
+    readonly ConflictResolver: import("inversify").interfaces.ServiceIdentifier<ConflictResolver>;
+    readonly Tracer: import("inversify").interfaces.ServiceIdentifier<Tracer>;
+};
+//# sourceMappingURL=hydranium-shared-core-services.d.ts.map

package/lib/state/hydranium-shared-core-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydranium-shared-core-services.d.ts","sourceRoot":"","sources":["../../src/state/hydranium-shared-core-services.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC"}