@hydranium/core 1.0.0-next.10

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

@@ -0,0 +1 @@
+{"version":3,"file":"name-separator-validation.d.ts","sourceRoot":"","sources":["../../../src/langium/naming/name-separator-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,oBAAoB,CAAC;AAClG,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,KAAK,2BAA2B,EAAE,KAAK,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AAC1H,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAelH;AAED;;;;;;;;;GASG;AACH,qBAAa,8BAA+B,YAAW,2BAA2B;IAC/E,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;gBAElC,QAAQ,EAAE,sBAAsB;IAI5C,wBAAwB,CAAC,QAAQ,EAAE,uBAAuB,GAAG,IAAI;CAMnE"}

package/lib/langium/naming/name-separator-validation.js

@@ -0,0 +1,61 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+/**
+ * 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 function nameSeparatorCheck(nameProvider) {
+    return (node, accept) => {
+        const ownName = nameProvider.getOwnName(node);
+        if (typeof ownName !== 'string' || ownName.length === 0) {
+            return;
+        }
+        const separator = nameProvider.nameSeparator;
+        if (ownName.includes(separator)) {
+            accept('error', `Name '${ownName}' contains the configured name separator '${separator}', which is reserved for qualified-name composition — use a different character.`, { node });
+        }
+    };
+}
+/**
+ * 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 class NameSeparatorCheckContribution {
+    nameProvider;
+    constructor(services) {
+        this.nameProvider = services.references.NameProvider;
+    }
+    registerValidationChecks(registry) {
+        const checks = {
+            AstNode: nameSeparatorCheck(this.nameProvider)
+        };
+        registry.register(checks);
+    }
+}
+//# sourceMappingURL=name-separator-validation.js.map

package/lib/langium/naming/name-separator-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-separator-validation.js","sourceRoot":"","sources":["../../../src/langium/naming/name-separator-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAOlF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,kBAAkB,CAAC,YAA0B;IAC1D,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;QACrB,MAAM,OAAO,GAAG,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvD,OAAO;QACV,CAAC;QACD,MAAM,SAAS,GAAG,YAAY,CAAC,aAAa,CAAC;QAC7C,IAAI,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,MAAM,CACH,OAAO,EACP,SAAS,OAAO,6CAA6C,SAAS,kFAAkF,EACxJ,EAAE,IAAI,EAAE,CACV,CAAC;QACL,CAAC;IACJ,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,8BAA8B;IACrB,YAAY,CAAe;IAE9C,YAAY,QAAgC;QACzC,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC;IACxD,CAAC;IAED,wBAAwB,CAAC,QAAiC;QACvD,MAAM,MAAM,GAA2C;YACpD,OAAO,EAAE,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC;SAChD,CAAC;QACF,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;CACH"}

package/lib/langium/project/abstract-project-manager.d.ts

@@ -0,0 +1,242 @@
+/********************************************************************************
+ * 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 { Deferred, type Project, type Tracer } from '@hydranium/protocol';
+import { type AstNode, type DocumentBuilder, type FileSystemProvider, type LangiumDocument, type LangiumDocuments, type URI } from '@hydranium/langium';
+import { Disposable } from 'vscode-languageserver';
+import type { WorkspaceFolder } from 'vscode-languageserver-types';
+import type { LogNameOptions } from '../diagnostics/logger.js';
+import { type ServerSharedServicesMinimal } from '../shared-services.js';
+import type { ProjectChangeEvent, ProjectChangeListener } from './project-change-event.js';
+import type { ProjectManager } from './project-manager.js';
+/**
+ * Abstract base for project-aware {@link ProjectManager} implementations.
+ * Implements the machinery: registry, auto-subscription to
+ * `DocumentBuilder.onUpdate`, event channel, cascade computation, and
+ * change-emission.
+ *
+ * Consumers extend this and override only the hooks specific to their
+ * project model. For the no-project case, bind `SingleProjectManager`
+ * instead — it implements {@link ProjectManager} directly with a single
+ * synthetic project that owns every URI.
+ *
+ * ## Required overrides
+ *
+ * - {@link isProjectDescriptor} — abstract; predicate identifying the
+ *   consumer's descriptor files.
+ * - {@link parseProjectDescriptor} — abstract; converts a parsed
+ *   descriptor document into a {@link Project}.
+ *
+ * ## Optional overrides
+ *
+ * - {@link findDescriptorUris} — default walks the workspace folders
+ *   recursively. Override to use a manifest index, glob pattern, or
+ *   explicit listing.
+ * - {@link shouldEnterDirectory} — default skips hidden directories,
+ *   `node_modules`, and `out`. Override to customise exclusion rules
+ *   without re-implementing the walk.
+ * - {@link getAffectedProjects} — default walks {@link Project.dependencies}
+ *   transitively in reverse (projects whose dep closure touches a changed
+ *   project also rebuild). Override for a different rebuild policy.
+ * - {@link getVisibleProjects} — default walks {@link Project.dependencies}
+ *   transitively. Override for a different visibility model.
+ * - {@link computeProject} — default uses closest-ancestor-descriptor-folder
+ *   membership. Override for a different membership model; overriding
+ *   {@link getProject} instead loses the memoization it wraps.
+ */
+export declare abstract class AbstractProjectManager<TProject extends Project = Project> implements ProjectManager<TProject> {
+    protected readonly services: ServerSharedServicesMinimal;
+    /** Project id → {@link Project}. */
+    protected readonly projects: Map<string, TProject>;
+    /** Descriptor URI (`uri.toString()`) → project id. Drives {@link getProject} membership lookups. */
+    protected readonly projectByDescriptor: Map<string, string>;
+    /** Descriptor URI → owning folder URI (cached for efficient closest-ancestor lookups). */
+    protected readonly descriptorDirectories: Map<string, URI>;
+    /**
+     * Memoized {@link getProject} results, keyed by URI string (`undefined` = no owning project,
+     * distinguished from a cache miss by {@link Map.has}). Membership resolution is a hot path —
+     * called per description / node / reference during a build — but the descriptor set only
+     * changes on a project rebuild, so the result is stable between rebuilds. Cleared by
+     * {@link invalidateMembershipCache} wherever the descriptor maps mutate.
+     */
+    protected readonly membershipCache: Map<string, TProject | undefined>;
+    protected readonly listeners: ProjectChangeListener<TProject>[];
+    protected readonly readyDeferred: Deferred<void>;
+    protected discoveryRan: boolean;
+    protected readonly fileSystemProvider: FileSystemProvider;
+    protected readonly langiumDocuments: LangiumDocuments;
+    protected readonly documentBuilder: DocumentBuilder;
+    protected readonly tracer: Tracer;
+    constructor(services: ServerSharedServicesMinimal, options?: LogNameOptions);
+    get ready(): Promise<void>;
+    onProjectsChanged(listener: ProjectChangeListener<TProject>): Disposable;
+    /**
+     * Predicate: is the given URI a project descriptor file? **Abstract** —
+     * concrete subclasses must implement, paired with their
+     * {@link parseProjectDescriptor} override. The predicate gates both
+     * initial discovery ({@link walkForDescriptors}) and incremental
+     * tracking ({@link onBuildUpdate}); a default of `false` would
+     * silently leave the manager idle even after the parser is wired,
+     * so the predicate is required at the class level.
+     *
+     * Implementations are typically schema-driven — filename pattern,
+     * extension, or location. Avoid registry lookups: new descriptors
+     * appearing at runtime would not yet be in the registry.
+     */
+    abstract isProjectDescriptor(uri: URI | string): boolean;
+    /**
+     * Whether `uri` should be tracked as a project descriptor. Enforces the
+     * framework invariant that a **virtual document** (no backing file, a
+     * `virtual:` URI) can never be a descriptor — a contributed stdlib / library
+     * document whose URI happens to match a broad adopter
+     * {@link isProjectDescriptor} predicate must not spawn a phantom
+     * project — then defers to the adopter predicate. Every descriptor gate
+     * (initial walk + incremental {@link onBuildUpdate}) routes through here, so
+     * the invariant holds for all adopters without each having to guard it.
+     */
+    protected isDescriptorUri(uri: URI | string): boolean;
+    /**
+     * Default implementation: `true` iff the owning project's
+     * {@link Project.referenceName} equals {@link UNQUALIFIED_PROJECT_REFERENCE},
+     * or `uri` is not owned by any project. Subclasses with cheaper
+     * lookups override.
+     */
+    isUnqualifiedProjectReference(uri: URI | string): boolean;
+    /**
+     * Adopter-facing concept name used in the change-log lines this manager
+     * emits ({@link logProjectChange}). Default `'project'`; adopters override
+     * to their own domain term.
+     */
+    protected conceptName(): string;
+    /**
+     * Emit an `Add/Update` / `Remove` change-log line for a project. `uri` is the
+     * descriptor file; its workspace-relative path is shown via the
+     * `HydraniumWorkspaceManager` the framework binds. `info`-level, so it
+     * is suppressed when the log threshold is above `info`.
+     */
+    protected logProjectChange(action: 'Add/Update' | 'Remove', id: string, uri: URI): void;
+    /**
+     * Default implementation: returns `true` while the registry holds at
+     * most one project. Conservative — flips to `false` as soon as a
+     * second project is registered, even if all documents still belong
+     * to the first. Subclasses with a richer notion of "meaningful
+     * project boundary" override.
+     */
+    isSingleProject(): boolean;
+    /**
+     * Convert a parsed descriptor document into a {@link Project}, or
+     * return `undefined` if the descriptor is malformed / incomplete.
+     * Called from {@link loadDescriptor} during discovery and updates.
+     *
+     * Adopters populate {@link Project.referenceName} explicitly — empty
+     * sentinel ({@link UNQUALIFIED_PROJECT_REFERENCE}) for projects that
+     * do not qualify their names, or a sanitised / version-stripped form
+     * for adopters with a custom reference scheme.
+     */
+    protected abstract parseProjectDescriptor(uri: URI, document: LangiumDocument): Promise<TProject | undefined>;
+    /**
+     * Locate descriptor URIs across the given workspace folders. Default
+     * walks recursively via {@link fileSystemProvider}, respecting
+     * {@link shouldEnterDirectory} for folder exclusions. Override to use
+     * a manifest index, glob, or explicit listing.
+     */
+    protected findDescriptorUris(folders: readonly WorkspaceFolder[]): Promise<URI[]>;
+    /**
+     * Recursive helper for the default {@link findDescriptorUris}. Override
+     * to customise traversal *behaviour*; override {@link shouldEnterDirectory}
+     * if only the directory-exclusion rule needs to change.
+     */
+    protected walkForDescriptors(folder: URI, accumulator: URI[]): Promise<void>;
+    /**
+     * Predicate controlling whether the default descriptor walk descends
+     * into a sub-directory. Default skips hidden directories
+     * (`name.startsWith('.')`), `node_modules`, and `out` — the common
+     * "ignore build outputs and tooling" rules. Override to tighten or
+     * loosen the set without re-implementing the recursion.
+     */
+    protected shouldEnterDirectory(_uri: URI, name: string): boolean;
+    /**
+     * Compute the set of projects whose member documents need to rebuild
+     * given the directly changed projects. Default walks the dependency
+     * graph in reverse — any project whose declared {@link Project.dependencies}
+     * include a changed id transitively also rebuilds (cycle-safe).
+     *
+     * Override for a different rebuild policy (no transitivity, custom
+     * reachability, etc.).
+     */
+    protected getAffectedProjects(directlyChanged: readonly string[]): readonly string[];
+    /**
+     * Whether replacing `previous` with `updated` — the same project re-parsed
+     * (both carry the same {@link Project.id}) — forces the project's member
+     * documents, and via {@link getAffectedProjects} its dependents, to
+     * rebuild. Consulted only on the same-id update path; an id change is
+     * handled as remove-old + add-new and always rebuilds.
+     *
+     * The default compares the fields the framework itself reads when building
+     * or linking members: {@link Project.referenceName} (the prefix
+     * cross-project qualified names resolve against) and
+     * {@link Project.dependencies} (the visibility closure). It intentionally
+     * ignores {@link Project.version} — the framework never reads it (it is
+     * pass-through client metadata), so a version-only change still emits an
+     * `updated` event but rebuilds nothing.
+     *
+     * Override to widen the comparison with adopter descriptor fields that a
+     * member build observes, combining with `super.requiresMemberRebuild(...)`.
+     */
+    protected requiresMemberRebuild(previous: TProject, updated: TProject): boolean;
+    /**
+     * Default: transitive closure of {@link Project.dependencies} including
+     * the source project itself. Override for a different visibility model.
+     */
+    getVisibleProjects(projectId: string): readonly string[];
+    isVisible(sourceProjectId: string, targetProjectId: string, selfVisible?: boolean): boolean;
+    protected collectVisibleProjects(projectId: string, visited: Set<string>, ordered: string[]): void;
+    discoverProjects(folders: readonly WorkspaceFolder[]): Promise<void>;
+    /**
+     * Parse a single descriptor URI and register the resulting project.
+     * Returns the parsed project, or `undefined` if parsing failed (errors
+     * are logged, not thrown — the rest of discovery / update continues).
+     */
+    protected loadDescriptor(uri: URI): Promise<TProject | undefined>;
+    /**
+     * Handle a `DocumentBuilder.onUpdate` event. Filters for descriptor
+     * URIs, diffs the registry, and emits {@link ProjectChangeEvent} with
+     * the registry diff plus the affected documents that need rebuilding.
+     *
+     * Descriptor URIs that triggered the cycle are excluded from
+     * {@link ProjectChangeEvent.affectedDocuments} — re-adding them would
+     * loop.
+     */
+    protected onBuildUpdate(changed: readonly URI[], deleted: readonly URI[]): Promise<void>;
+    /** Iterate the document set once, collecting URIs whose owning project is in the affected set. */
+    protected collectAffectedDocuments(affectedProjectIds: ReadonlySet<string>, excludedUris: ReadonlySet<string>): URI[];
+    /**
+     * The project owning the given URI, memoized per URI (see {@link membershipCache}).
+     * The membership computation lives in {@link computeProject} — override THAT, not
+     * this, so a subclass's custom model inherits the memoization + invalidation.
+     */
+    getProject(uri: URI | string): TProject | undefined;
+    /**
+     * Compute the project owning {@link target} — default: the project whose descriptor
+     * directory is the closest ancestor. Subclasses override for a different membership
+     * model; the result is memoized by {@link getProject}.
+     *
+     * The lookup is O(N) in the number of registered projects per call, but memoization
+     * collapses the repeated per-description / per-node calls to one per URI per rebuild.
+     * Subclasses that additionally need O(1) per unique URI can maintain a reverse index.
+     */
+    protected computeProject(target: URI): TProject | undefined;
+    /** Drop all memoized membership results. Called wherever the descriptor maps mutate. */
+    protected invalidateMembershipCache(): void;
+    getProjectForNode(node: AstNode): TProject | undefined;
+    getProjectById(id: string): TProject | undefined;
+    getProjects(): readonly TProject[];
+    getProjectUris(projectId: string): readonly URI[];
+    protected emit(event: ProjectChangeEvent<TProject>): void;
+}
+//# sourceMappingURL=abstract-project-manager.d.ts.map

package/lib/langium/project/abstract-project-manager.d.ts.map

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