@hydranium/core 1.0.0-next.10

package/lib/langium/naming/name-provider.d.ts

@@ -0,0 +1,360 @@
+/********************************************************************************
+ * 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 CstNode, DocumentCache, type NameProvider as LangiumNameProvider, type URI } from '@hydranium/langium';
+import type { HydraniumLanguageServices } from '../language-module.js';
+/**
+ * Per-call options for the workspace-scoped `findNext*` name proposals
+ * ({@link NameProvider.findNextDocumentQualifiedName} /
+ * {@link NameProvider.findNextProjectQualifiedName}).
+ */
+export interface NextNameOptions {
+    /**
+     * Ignore elements indexed under this document URI when collecting taken
+     * names — the self-exclusion a rename or a provisional-id confirmation
+     * needs. The proposal is being made FOR this document, so its own
+     * already-indexed entry is not a genuine collision; counting it would
+     * append a uniqueness suffix to a name the document already legitimately
+     * owns.
+     *
+     * Compared by canonical URI string, so callers may pass either form.
+     */
+    readonly excludeDocumentUri?: URI | string;
+}
+/**
+ * Construction-time options for {@link DefaultNameProvider}.
+ *
+ * Adopters whose reference syntax uses a different separator than the
+ * framework default (`'.'`) pass `nameSeparator` here. The two-sided contract:
+ * the parser/AST treats this character as reserved (validated via
+ * `nameSeparatorCheck`), and the joiner produces qualified names with the
+ * same character so the linker's lookups against
+ * {@link NameProvider.getName} match the syntactic reference form.
+ */
+export interface NameProviderOptions {
+    /** Separator used to join name segments into a qualified name. Default `'.'`. */
+    readonly nameSeparator?: string;
+    /**
+     * Property names checked, in order, when reading a node's own name.
+     * Default `['name']` — matches Langium's upstream
+     * `DefaultNameProvider.getName(node)` which reads `node.name`. Adopters
+     * whose grammar carries the identifier on a different property (e.g.
+     * an `id` field) override explicitly; the explicit override at
+     * the adopter side documents the grammar's convention rather than
+     * burying it in a framework default.
+     */
+    readonly nameProperties?: readonly string[];
+}
+/**
+ * A node's name together with the property it was read from — the pair
+ * {@link NameProvider.getOwnName} and {@link NameProvider.getNameProperty}
+ * each project one half of.
+ *
+ * They are returned together because they must agree: with several configured
+ * {@link NameProviderOptions.nameProperties}, answering "what is the name"
+ * and "which property holds it" in two independent walks is how the two
+ * answers drift apart.
+ */
+export interface ResolvedName {
+    /** The property key the name was read from, e.g. `'name'` or `'id'`. */
+    readonly property: string;
+    /** The name value at that property. */
+    readonly value: string;
+}
+/**
+ * Naming service — **the canonical naming surface in this framework.**
+ * Extends Langium's `NameProvider` with the three **qualification levels**
+ * of qualified name the framework uses for scope construction:
+ *
+ * ("Qualification level", never "tier" — `tier` is reserved for the
+ * visibility axis (`local` / `project` / `public` / `universal`), which is a
+ * different question with confusingly similar member names.)
+ *
+ * - {@link getOwnName} — the bare segment a user typed next to the node's
+ *   declaration. Used for: label edits, UI display, search-box typing,
+ *   references within the same container — `HydraniumScopeComputation`
+ *   keys the per-document local-symbols map by this level, overriding
+ *   Langium's default of keying it by `getName`.
+ * - {@link getDocumentQualifiedName} — joins every named ancestor inside
+ *   the document. Used for the name written when referencing across
+ *   documents or containers within the same project — emitted as the
+ *   `tier: 'project'` global-index entry by `HydraniumScopeComputation`.
+ * - {@link getProjectQualifiedName} — prepends the owning project's
+ *   `Project.referenceName` to the document-qualified name. Used
+ *   for cross-project references — emitted as the `tier: 'public'`
+ *   global-index entry when the project qualifies its names. When the
+ *   owning project's `referenceName` is `UNQUALIFIED_PROJECT_REFERENCE`,
+ *   collapses to {@link getDocumentQualifiedName} (single-emit path in
+ *   `HydraniumScopeComputation`).
+ *
+ * `getName` (Langium contract) defaults to {@link getProjectQualifiedName}
+ * — the workspace-unique form by construction. Adopters whose grammar
+ * uses a different lookup scheme override `getName` to return a different
+ * qualification level; grammars with bare-name cross-references stick with
+ * the framework default and rely on the local-symbols pass for the
+ * in-document case.
+ *
+ * # Relationship to `ElementKeyProvider`
+ *
+ * `NameProvider` and `ElementKeyProvider` are two distinct services:
+ * - `NameProvider` produces user-facing names used in reference syntax,
+ *   completion, and search — non-unique and rename-sensitive.
+ * - `ElementKeyProvider` produces a string *handle* that round-trips to a
+ *   node within a document — used for GModel ids and UI selection. A key is
+ *   a lookup token, not a unique id; under the default name-based strategy
+ *   it is non-unique and flips on rename (the positional strategy is unique
+ *   and rename-stable instead).
+ *
+ * The split is deliberate: a single `Id`-suffixed surface conflated the name
+ * axis, the key axis, and the label axis. Adopters override the one they
+ * need.
+ */
+export interface NameProvider extends LangiumNameProvider {
+    /**
+     * Separator used to join name segments into a qualified name. Read
+     * polymorphically by the framework's separator-in-id validation rule
+     * (`nameSeparatorCheck`) so it works against any conforming
+     * implementation.
+     *
+     * **Two-sided contract.** Adopters that change the separator must
+     * (1) configure their grammar's reference syntax to use the same
+     * character, and (2) ensure name-typed property values do not
+     * contain that character — the framework's separator validation
+     * rule enforces (2) automatically when registered.
+     */
+    readonly nameSeparator: string;
+    /**
+     * Produce a qualified name by joining segments with
+     * {@link nameSeparator}, dropping empty segments. The dual of the
+     * qualification-level getters: it composes the form they decompose.
+     *
+     * Use at adopter callsites that have already computed segments and
+     * need to compose them into a qualified name — typically when the
+     * segments come from a mix of node walks, project lookups, and
+     * adopter-specific suffixes. Replaces manual
+     * `segment + nameProvider.nameSeparator + segment` concatenation,
+     * which silently breaks for adopters that change the separator.
+     *
+     * Drops empty segments so callers can pass a qualification-level output
+     * that may legitimately be empty (an unqualified project reference name)
+     * without producing a leading or doubled separator.
+     */
+    qualify(...segments: string[]): string;
+    /**
+     * The node's bare segment — what the user typed next to the node's
+     * declaration, with no ancestor qualification. Used for label edits,
+     * UI display, search typing, and the per-document local-symbols pass.
+     */
+    getOwnName(node?: AstNode): string | undefined;
+    /**
+     * Predicate form of {@link getOwnName} — true iff this NameProvider
+     * can read a name from `node` via the configured
+     * {@link NameProviderOptions.nameProperties}. Equivalent to
+     * `getOwnName(node) !== undefined`, exposed under a readable name for
+     * sites that only need the existence check (not the value).
+     *
+     * Distinct from Langium's `isNamed(node): node is NamedAstNode`
+     * upstream typeguard, which checks `node.name` specifically and
+     * narrows the static type. `hasName` is adopter-polymorphic
+     * (respects `nameProperties` — an `id`-based grammar
+     * passes `hasName` even though Langium's `isNamed` would return
+     * false), but cannot narrow at the type level because
+     * `nameProperties` is a runtime configuration.
+     */
+    hasName(node?: AstNode): boolean;
+    /**
+     * The property KEY {@link getOwnName} read the name from — `'name'` for
+     * a conventional grammar, `'id'` for an `id`-keyed one. Returns
+     * `undefined` when no configured name property holds a string, i.e.
+     * exactly when {@link hasName} is false.
+     *
+     * The companion of {@link getOwnName}: that returns the value, this
+     * returns where it came from. Callers that must address the name's
+     * source rather than read it need the key — an LSP semantic-token or
+     * document-symbol acceptor takes `{ node, property }` and resolves the
+     * CST range itself, so handing it the value would be useless.
+     */
+    getNameProperty(node?: AstNode): string | undefined;
+    /**
+     * Document-qualified name — joins every named ancestor's own-name
+     * within the document using {@link nameSeparator}. Used as the name
+     * written when referencing across documents or containers within the
+     * same project; emitted as the `tier: 'project'` global-index entry by
+     * `HydraniumScopeComputation`.
+     *
+     * Unnamed ancestors (containers without their own name) contribute
+     * nothing to the qualified form — the walk skips them silently. The
+     * walk traverses through the document root: if the root has its own
+     * name, that name IS part of the qualified form. Adopters who want a
+     * different boundary override this method.
+     */
+    getDocumentQualifiedName(node?: AstNode): string | undefined;
+    /**
+     * Project-qualified name — prepends the owning project's
+     * `referenceName` (via {@link getProjectReferenceName}) to the
+     * document-qualified name. Used as the name for cross-project
+     * references — emitted as the `tier: 'public'` global-index entry by
+     * `HydraniumScopeComputation` when the project qualifies its names.
+     *
+     * Collapses to {@link getDocumentQualifiedName} when the owning
+     * project's reference name is `UNQUALIFIED_PROJECT_REFERENCE` (empty
+     * string) or no project owns the URI — in those cases project-
+     * qualified equals document-qualified, and
+     * `HydraniumScopeComputation` skips the multi-tier emit.
+     */
+    getProjectQualifiedName(node?: AstNode): string | undefined;
+    /**
+     * Resolve the user-facing reference prefix for the project owning
+     * `uri`. Default: reads `Project.referenceName` from the shared
+     * `ProjectManager`. Override when project ownership comes from a
+     * service other than `ProjectManager`.
+     *
+     * Returns `undefined` if no project owns the URI; returns the empty
+     * `UNQUALIFIED_PROJECT_REFERENCE` sentinel when the project is
+     * intentionally unqualified.
+     */
+    getProjectReferenceName(uri: URI): string | undefined;
+    /**
+     * Find a unique name for a new node within `container`, using `base`
+     * as a stem. Walks the AST subtree rooted at `container` and avoids
+     * names already used by `$type === type` nodes there. Default
+     * generates `${base}1`, `${base}2`, ... until an unused value is
+     * found. Used by create-element operation handlers when the
+     * uniqueness scope is one AST subtree.
+     */
+    findNextName(type: string, base: string, container: AstNode): string;
+    /**
+     * Find a name whose document-qualified form is unique within the
+     * given project. Walks `IndexManager.allElements(type)` and filters
+     * to the project identified by `projectId`. Used by create-element
+     * operation handlers when the uniqueness scope is one project: the
+     * result becomes the new element's bare own-name, whose document-
+     * qualified form must be unique within that project.
+     *
+     * Workspace-walk-with-filter — O(N) per call where N is the total
+     * element count of `type` workspace-wide. Adopters with a project-
+     * tier element index override for O(1) lookup.
+     *
+     * Pass {@link NextNameOptions.excludeDocumentUri} when the caller is
+     * proposing a name FOR an already-indexed document — a rename, or a
+     * client confirming a provisional id it already flushed. Without it the
+     * document collides with its own index entry and the proposal takes a
+     * spurious uniqueness suffix.
+     */
+    findNextDocumentQualifiedName(type: string, base: string, projectId: string, options?: NextNameOptions): string;
+    /**
+     * Find a name whose project-qualified form is unique across the
+     * workspace. Walks `IndexManager.allElements(type)` workspace-wide.
+     * Used by create-element operation handlers when the uniqueness
+     * scope is the entire workspace — generating a name that must not
+     * collide with any element of `type` in any project.
+     *
+     * Takes the same {@link NextNameOptions.excludeDocumentUri} self-exclusion
+     * as {@link findNextDocumentQualifiedName}, for the same reason.
+     */
+    findNextProjectQualifiedName(type: string, base: string, options?: NextNameOptions): string;
+}
+/**
+ * Default {@link NameProvider}. Resolves a node's own name from the
+ * configured {@link NameProviderOptions.nameProperties}, which defaults to
+ * `['name']` (the Langium-conventional `node.name`). Adopters whose grammar
+ * carries an explicit identifier property configure it at construction.
+ *
+ * Designed for subclassing: each qualification-level method is overridable
+ * so adopters can adjust the convention without re-implementing the whole
+ * class.
+ */
+export declare class DefaultNameProvider implements NameProvider {
+    protected readonly services: HydraniumLanguageServices;
+    protected readonly nameProperties: readonly string[];
+    readonly nameSeparator: string;
+    /**
+     * Per-document memo for {@link getDocumentQualifiedName} results.
+     * Eliminates the redundant container-chain walk that arises when
+     * {@link getProjectQualifiedName} (and other consumers) repeatedly
+     * query the document-qualified name for the same node within a
+     * document's lifetime. Evicted automatically when Langium rebuilds
+     * the document.
+     *
+     * Only cached when the computed result is a defined string — `undefined`
+     * results re-evaluate on each call (cheap path: `getOwnName` returns
+     * undefined for unnamed nodes, no chain walk needed).
+     */
+    protected readonly documentQualifiedNameCache: DocumentCache<AstNode, string>;
+    /**
+     * Per-document memo for {@link getProjectQualifiedName} results.
+     * Sibling of {@link documentQualifiedNameCache}; covers the additional
+     * project-reference-name lookup the project-qualified variant performs.
+     *
+     * **Project-rename caveat.** If `Project.referenceName` mutates without
+     * a corresponding document rebuild, cached entries become stale. Adopters
+     * renaming projects at runtime should clear the cache explicitly; the
+     * default workspace lifecycle (descriptor file edits trigger
+     * `DocumentBuilder.onUpdate` → `DocumentCache` evicts) covers the
+     * common case.
+     */
+    protected readonly projectQualifiedNameCache: DocumentCache<AstNode, string>;
+    constructor(services: HydraniumLanguageServices, options?: NameProviderOptions);
+    /**
+     * Join name segments with {@link nameSeparator}, dropping empty segments.
+     * Subclasses whose joining policy depends on the segment's position or
+     * kind, rather than on a single separator, override.
+     */
+    qualify(...segments: string[]): string;
+    getOwnName(node?: AstNode): string | undefined;
+    hasName(node?: AstNode): boolean;
+    getNameProperty(node?: AstNode): string | undefined;
+    /**
+     * The single walk over {@link nameProperties} the three public name-reading
+     * members share — first configured property holding a string wins, so key
+     * and value can never disagree about which one that was.
+     */
+    protected findNameProperty(node?: AstNode): ResolvedName | undefined;
+    getDocumentQualifiedName(node?: AstNode): string | undefined;
+    protected computeDocumentQualifiedName(node: AstNode): string | undefined;
+    getProjectQualifiedName(node?: AstNode): string | undefined;
+    getProjectReferenceName(uri: URI): string | undefined;
+    /**
+     * Langium contract — the canonical name used by the linker for cross-
+     * reference resolution.
+     *
+     * **Default: {@link getProjectQualifiedName}** (workspace-unique by
+     * construction — a project's `referenceName` is unique within the
+     * workspace, and qualifying with it lifts any name into a workspace-
+     * unique key). This is the form the cross-document global-scope
+     * index uses for cross-project references; LSP UI surfaces (document
+     * symbols, completion, hover) also see this form and display
+     * qualified names.
+     *
+     * **Within-document references stay keyed by bare names** via
+     * `HydraniumScopeComputation.addLocalSymbol`, which explicitly calls
+     * {@link getOwnName} when populating the local-symbols map (bypassing
+     * Langium's default that goes through this `getName`). The
+     * separation lets `getName` carry the workspace-unique form for the
+     * linker without forcing qualified names into the per-document
+     * symbol map.
+     *
+     * Adopters whose grammar uses a different lookup level override here
+     * — bare names ({@link getOwnName}) for grammars without a
+     * qualified-name syntax, document-qualified ({@link getDocumentQualifiedName})
+     * for grammars whose linker resolves within a project.
+     */
+    getName(node: AstNode): string | undefined;
+    getNameNode(node: AstNode): CstNode | undefined;
+    findNextName(type: string, base: string, container: AstNode): string;
+    findNextDocumentQualifiedName(type: string, base: string, projectId: string, options?: NextNameOptions): string;
+    findNextProjectQualifiedName(type: string, base: string, options?: NextNameOptions): string;
+    /**
+     * Predicate matching the document a `findNext*` proposal is being made FOR,
+     * so its own indexed entries can be dropped from the taken-name set. Returns
+     * a never-matching predicate when no exclusion was requested, which keeps the
+     * default behaviour byte-identical for existing callers.
+     */
+    protected selfDocumentFilter(options?: NextNameOptions): (documentUri: URI) => boolean;
+}
+//# sourceMappingURL=name-provider.d.ts.map

package/lib/langium/naming/name-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-provider.d.ts","sourceRoot":"","sources":["../../../src/langium/naming/name-provider.ts"],"names":[],"mappings":"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"}

package/lib/langium/naming/name-provider.js

@@ -0,0 +1,240 @@
+/********************************************************************************
+ * 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 { findNextUnique, identity, UNQUALIFIED_PROJECT_REFERENCE } from '@hydranium/protocol';
+import { AstUtils, DocumentCache, GrammarUtils } from '@hydranium/langium';
+/**
+ * Default {@link NameProvider}. Resolves a node's own name from the
+ * configured {@link NameProviderOptions.nameProperties}, which defaults to
+ * `['name']` (the Langium-conventional `node.name`). Adopters whose grammar
+ * carries an explicit identifier property configure it at construction.
+ *
+ * Designed for subclassing: each qualification-level method is overridable
+ * so adopters can adjust the convention without re-implementing the whole
+ * class.
+ */
+export class DefaultNameProvider {
+    services;
+    nameProperties;
+    nameSeparator;
+    /**
+     * Per-document memo for {@link getDocumentQualifiedName} results.
+     * Eliminates the redundant container-chain walk that arises when
+     * {@link getProjectQualifiedName} (and other consumers) repeatedly
+     * query the document-qualified name for the same node within a
+     * document's lifetime. Evicted automatically when Langium rebuilds
+     * the document.
+     *
+     * Only cached when the computed result is a defined string — `undefined`
+     * results re-evaluate on each call (cheap path: `getOwnName` returns
+     * undefined for unnamed nodes, no chain walk needed).
+     */
+    documentQualifiedNameCache;
+    /**
+     * Per-document memo for {@link getProjectQualifiedName} results.
+     * Sibling of {@link documentQualifiedNameCache}; covers the additional
+     * project-reference-name lookup the project-qualified variant performs.
+     *
+     * **Project-rename caveat.** If `Project.referenceName` mutates without
+     * a corresponding document rebuild, cached entries become stale. Adopters
+     * renaming projects at runtime should clear the cache explicitly; the
+     * default workspace lifecycle (descriptor file edits trigger
+     * `DocumentBuilder.onUpdate` → `DocumentCache` evicts) covers the
+     * common case.
+     */
+    projectQualifiedNameCache;
+    constructor(services, options = {}) {
+        this.services = services;
+        this.nameSeparator = options.nameSeparator ?? '.';
+        this.nameProperties = options.nameProperties ?? ['name'];
+        this.documentQualifiedNameCache = new DocumentCache(services.shared);
+        this.projectQualifiedNameCache = new DocumentCache(services.shared);
+    }
+    /**
+     * Join name segments with {@link nameSeparator}, dropping empty segments.
+     * Subclasses whose joining policy depends on the segment's position or
+     * kind, rather than on a single separator, override.
+     */
+    qualify(...segments) {
+        return segments.filter(segment => segment.length > 0).join(this.nameSeparator);
+    }
+    getOwnName(node) {
+        return this.findNameProperty(node)?.value;
+    }
+    hasName(node) {
+        return this.findNameProperty(node) !== undefined;
+    }
+    getNameProperty(node) {
+        return this.findNameProperty(node)?.property;
+    }
+    /**
+     * The single walk over {@link nameProperties} the three public name-reading
+     * members share — first configured property holding a string wins, so key
+     * and value can never disagree about which one that was.
+     */
+    findNameProperty(node) {
+        if (!node) {
+            return undefined;
+        }
+        const indexed = node;
+        for (const property of this.nameProperties) {
+            const value = indexed[property];
+            if (typeof value === 'string') {
+                return { property, value };
+            }
+        }
+        return undefined;
+    }
+    getDocumentQualifiedName(node) {
+        if (!node) {
+            return undefined;
+        }
+        const document = AstUtils.findRootNode(node).$document;
+        if (!document) {
+            return this.computeDocumentQualifiedName(node);
+        }
+        const cached = this.documentQualifiedNameCache.get(document.uri, node);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const computed = this.computeDocumentQualifiedName(node);
+        if (computed !== undefined) {
+            this.documentQualifiedNameCache.set(document.uri, node, computed);
+        }
+        return computed;
+    }
+    computeDocumentQualifiedName(node) {
+        let name = this.getOwnName(node);
+        if (!name) {
+            return undefined;
+        }
+        let parent = node.$container;
+        while (parent) {
+            const segment = this.getOwnName(parent);
+            if (segment) {
+                name = this.qualify(segment, name);
+            }
+            parent = parent.$container;
+        }
+        return name;
+    }
+    getProjectQualifiedName(node) {
+        if (!node) {
+            return undefined;
+        }
+        const document = AstUtils.findRootNode(node).$document;
+        if (!document) {
+            return this.getDocumentQualifiedName(node);
+        }
+        const cached = this.projectQualifiedNameCache.get(document.uri, node);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const documentName = this.getDocumentQualifiedName(node);
+        if (!documentName) {
+            return undefined;
+        }
+        const referenceName = this.getProjectReferenceName(document.uri);
+        const computed = !referenceName || referenceName === UNQUALIFIED_PROJECT_REFERENCE ? documentName : this.qualify(referenceName, documentName);
+        this.projectQualifiedNameCache.set(document.uri, node, computed);
+        return computed;
+    }
+    getProjectReferenceName(uri) {
+        const project = this.services.shared.workspace.ProjectManager.getProject(uri);
+        return project?.referenceName;
+    }
+    /**
+     * Langium contract — the canonical name used by the linker for cross-
+     * reference resolution.
+     *
+     * **Default: {@link getProjectQualifiedName}** (workspace-unique by
+     * construction — a project's `referenceName` is unique within the
+     * workspace, and qualifying with it lifts any name into a workspace-
+     * unique key). This is the form the cross-document global-scope
+     * index uses for cross-project references; LSP UI surfaces (document
+     * symbols, completion, hover) also see this form and display
+     * qualified names.
+     *
+     * **Within-document references stay keyed by bare names** via
+     * `HydraniumScopeComputation.addLocalSymbol`, which explicitly calls
+     * {@link getOwnName} when populating the local-symbols map (bypassing
+     * Langium's default that goes through this `getName`). The
+     * separation lets `getName` carry the workspace-unique form for the
+     * linker without forcing qualified names into the per-document
+     * symbol map.
+     *
+     * Adopters whose grammar uses a different lookup level override here
+     * — bare names ({@link getOwnName}) for grammars without a
+     * qualified-name syntax, document-qualified ({@link getDocumentQualifiedName})
+     * for grammars whose linker resolves within a project.
+     */
+    getName(node) {
+        return this.getProjectQualifiedName(node);
+    }
+    getNameNode(node) {
+        // Read-side CST rehydration. Target-range navigation
+        // (go-to-definition / declaration / implementation / type & call hierarchy)
+        // reaches the target node's name through `getNameNode` but does NOT run a
+        // build, so a target in a closed (CST-shed) document would otherwise have no
+        // CST to read. Restore it on demand — a no-op when the CST is resident
+        // (every parsed node has a `$cstNode`), so this is behaviour-neutral unless
+        // a residency policy has shed the document.
+        this.services.shared.workspace.CstResidencyService.rehydrateNode(node);
+        for (const property of this.nameProperties) {
+            const cstNode = GrammarUtils.findNodeForProperty(node.$cstNode, property);
+            if (cstNode) {
+                return cstNode;
+            }
+        }
+        return undefined;
+    }
+    findNextName(type, base, container) {
+        const proposal = base.replaceAll(this.nameSeparator, '_');
+        const knownNames = AstUtils.streamAst(container)
+            .filter(node => node.$type === type)
+            .map(node => this.getOwnName(node))
+            .nonNullable()
+            .toArray();
+        return findNextUnique(proposal, knownNames, identity);
+    }
+    findNextDocumentQualifiedName(type, base, projectId, options) {
+        const proposal = base.replaceAll(this.nameSeparator, '_');
+        const shared = this.services.shared.workspace;
+        const isSelf = this.selfDocumentFilter(options);
+        const knownNames = shared.IndexManager.allElements(type)
+            .filter(description => shared.ProjectManager.getProject(description.documentUri)?.id === projectId)
+            .filter(description => !isSelf(description.documentUri))
+            .map(description => description.name)
+            .toArray();
+        return findNextUnique(proposal, knownNames, identity);
+    }
+    findNextProjectQualifiedName(type, base, options) {
+        const proposal = base.replaceAll(this.nameSeparator, '_');
+        const isSelf = this.selfDocumentFilter(options);
+        const knownNames = this.services.shared.workspace.IndexManager.allElements(type)
+            .filter(description => !isSelf(description.documentUri))
+            .map(description => description.name)
+            .toArray();
+        return findNextUnique(proposal, knownNames, identity);
+    }
+    /**
+     * Predicate matching the document a `findNext*` proposal is being made FOR,
+     * so its own indexed entries can be dropped from the taken-name set. Returns
+     * a never-matching predicate when no exclusion was requested, which keeps the
+     * default behaviour byte-identical for existing callers.
+     */
+    selfDocumentFilter(options) {
+        const excluded = options?.excludeDocumentUri;
+        if (excluded === undefined) {
+            return () => false;
+        }
+        const target = this.services.shared.workspace.DocumentUriPolicy.canonicalUri(excluded.toString());
+        return documentUri => this.services.shared.workspace.DocumentUriPolicy.canonicalUri(documentUri.toString()) === target;
+    }
+}
+//# sourceMappingURL=name-provider.js.map

package/lib/langium/naming/name-provider.js.map

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

package/lib/langium/naming/name-separator-validation.d.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * 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 ValidationAcceptor } from '@hydranium/langium';
+import { type ServerLanguageServices } from '../language-module.js';
+import { type ValidationCheckContribution, type ValidationCheckRegistry } from '../validation/validation-contribution.js';
+import type { NameProvider } from './name-provider.js';
+/**
+ * Per-node validation check: flag name-bearing AST nodes whose name
+ * value contains the configured name separator. Such values produce
+ * silent ambiguity — once composed, a qualified name spanning several
+ * nested nodes is indistinguishable from the literal name of one node.
+ *
+ * Polymorphic on {@link NameProvider.nameSeparator}: adopters that configure
+ * a different separator get the corresponding check automatically. The rule
+ * registers under `AstNode` so it fires for every node; nodes without a
+ * name-bearing property are skipped by the check itself.
+ *
+ * This is a **validation** rule, not an **integrity** rule:
+ * - Per-node syntactic check on a single AST node — no cross-document
+ *   consistency dependency.
+ * - Fires via Langium's `ValidationRegistry` at the validation phase.
+ * - Integrity rules (in `IntegrityService`) run at the `Parsed` or
+ *   `Linked` phase and reason about cross-document state.
+ */
+export declare function nameSeparatorCheck(nameProvider: NameProvider): (node: AstNode, accept: ValidationAcceptor) => void;
+/**
+ * Framework's own {@link ValidationCheckContribution} for {@link nameSeparatorCheck}.
+ * Bound under `validation.checks.framework` in `createServerLanguageModule`,
+ * so every adopter receives the name-separator validation out of the box —
+ * no manual `registerValidationChecks` call needed.
+ *
+ * Adopters wanting narrower coverage can call {@link nameSeparatorCheck}
+ * directly inside their own contribution and register the result against
+ * the desired node types.
+ */
+export declare class NameSeparatorCheckContribution implements ValidationCheckContribution {
+    protected readonly nameProvider: NameProvider;
+    constructor(services: ServerLanguageServices);
+    registerValidationChecks(registry: ValidationCheckRegistry): void;
+}
+//# sourceMappingURL=name-separator-validation.d.ts.map