@hydranium/core 1.0.0-next.10

package/lib/langium/workspace/hydranium-workspace-manager.d.ts

@@ -0,0 +1,232 @@
+/********************************************************************************
+ * 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 Logger, type Tracer } from '@hydranium/protocol';
+import { DefaultWorkspaceManager, type LangiumDocument, type URI } from '@hydranium/langium';
+import { type CancellationToken } from 'vscode-languageserver';
+import type { WorkspaceFolder } from 'vscode-languageserver-types';
+import { type LogNameOptions } from '../diagnostics/logger.js';
+import type { ProjectChangeEvent } from '../project/project-change-event.js';
+import type { ProjectManager } from '../project/project-manager.js';
+import type { ServerSharedServicesMinimal } from '../shared-services.js';
+import type { WritableFileSystemProvider } from '../../documents/ast-document-manager.js';
+import { type DocumentUriPolicy } from './document-uri-policy.js';
+import { type AdditionalDocumentContribution } from './additional-document-contribution.js';
+/**
+ * Decide what to do with a process-level unhandled promise rejection.
+ *
+ * Langium's internal `Symbol(OperationCancelled)` marker — emitted when a
+ * `documentBuilder.build` is preempted by a concurrent write lock or
+ * cancellation token — is benign and is swallowed silently (without it the
+ * server logs spurious "Unhandled rejection" entries for cancellations that
+ * are not errors).
+ *
+ * Every OTHER reason is re-surfaced through {@link Logger.error}. This matters
+ * because Node disables its default crash/warn for ALL unhandled rejections as
+ * soon as any `unhandledRejection` listener is registered — so a handler that
+ * swallowed everything would make genuine unhandled rejections (real bugs)
+ * vanish silently. Logging keeps them visible while preserving the server's
+ * resilience (it does not re-crash the process).
+ *
+ * Pure and listener-free so it is unit-testable without touching the `process`
+ * singleton; {@link installOperationCancelledSuppression} wires it up.
+ */
+export declare function handleProcessUnhandledRejection(reason: unknown, logger: Logger): void;
+/**
+ * Install a process-level `unhandledRejection` listener that routes every
+ * rejection through {@link handleProcessUnhandledRejection} — swallowing
+ * Langium's `OperationCancelled` marker and logging everything else via the
+ * supplied {@link Logger}.
+ *
+ * Idempotent — safe to call from every {@link HydraniumWorkspaceManager}
+ * constructor. The `process` listener is installed at most once, because one
+ * per tree would pile up on a singleton, but each call RE-POINTS the logger it
+ * routes through: the listener reads it at rejection time rather than closing
+ * over the first caller's, so the most recently built tree is the one that
+ * hears about a genuine rejection.
+ *
+ * Applies to every Langium-based server that experiences concurrent builds.
+ */
+export declare function installOperationCancelledSuppression(logger: Logger): void;
+/**
+ * Framework {@link DefaultWorkspaceManager} subclass that integrates the
+ * project tier with Langium's workspace startup.
+ *
+ * ## Phase 0 — project discovery
+ *
+ * Overrides {@link performStartup} to await
+ * {@link ProjectManager.discoverProjects} **before** Langium's standard
+ * startup phases (additional documents → file traversal → workspace
+ * documents). By the time `documentBuilder.build` runs, the project
+ * registry is fully populated and every parsed document can resolve its
+ * owning project via `projectManager.getProject(uri)`.
+ *
+ * Single-project consumers using `SingleProjectManager` pay no cost —
+ * the override is a no-op resolve.
+ *
+ * Discovery has a side effect the startup sequence has to compensate for:
+ * it reads each descriptor through `LangiumDocuments.getOrCreateDocument`,
+ * so those documents already exist when Langium's traversal runs — and
+ * Langium's traversal deliberately drops URIs that already have a document
+ * ("ensure that the documents don't already exist"), so it never returns
+ * them. {@link performStartup} adds them back; see the method comment for
+ * what breaks without it.
+ *
+ * ## Cascade rebuild
+ *
+ * Subscribes to {@link ProjectManager.onProjectsChanged} in the
+ * constructor. When a project's identity, version, or dependencies
+ * change post-startup, the project manager emits the affected document
+ * URIs (its own members plus any transitive dependents per the
+ * `getAffectedProjects` hook). This manager re-runs
+ * `DocumentBuilder.resetToState(doc, DocumentState.Changed)` on each
+ * affected document so the next build cycle re-links them with the new
+ * visibility scope.
+ *
+ * Descriptor URIs that triggered the cycle are intentionally excluded
+ * from the affected set by `AbstractProjectManager.onBuildUpdate` —
+ * re-adding them would loop.
+ */
+export declare class HydraniumWorkspaceManager extends DefaultWorkspaceManager {
+    protected readonly projectManager: ProjectManager;
+    protected readonly tracer: Tracer;
+    /**
+     * Deferred backing {@link workspaceInitialized}. The framework default
+     * resolves it from {@link initializeWorkspace} once Langium's standard
+     * workspace setup completes. Adopters that need to gate first-`didOpen`
+     * on additional async work (project-scope discovery, schema fetch, etc.)
+     * override {@link initializeWorkspace} and resolve / reject this Deferred
+     * after their work completes.
+     */
+    protected readonly workspaceInitializedDeferred: Deferred<unknown>;
+    /**
+     * Resolves when the workspace is ready to handle the first `didOpen`
+     * event. `HydraniumTextDocuments.listen` awaits this promise inside its
+     * `didOpen` handler so the gate is hit at first use, not at DI. The
+     * framework resolves it from {@link initializeWorkspace}; adopters with
+     * extra async init override `initializeWorkspace` to thread their work
+     * before the resolve.
+     */
+    readonly workspaceInitialized: Promise<unknown>;
+    protected readonly uriPolicy: DocumentUriPolicy;
+    protected readonly writableFileSystemProvider: WritableFileSystemProvider;
+    protected readonly additionalDocuments: Record<string, AdditionalDocumentContribution>;
+    /** Registry consulted by {@link warnIfUnroutable} to check a seeded document routes. */
+    protected readonly languageRegistry: ServerSharedServicesMinimal['ServiceRegistry'];
+    constructor(services: ServerSharedServicesMinimal, options?: LogNameOptions);
+    /**
+     * Contribution form of Langium's `loadAdditionalDocuments`. Runs the base
+     * behaviour first (a no-op unless a further subclass adds documents), then
+     * lets every {@link AdditionalDocumentContribution} in the shared
+     * `additionalDocuments` group build in-memory documents via the bound
+     * `LangiumDocumentFactory` and seed them through Langium's `collector`
+     * — so each is added to the workspace and indexed like a file-backed
+     * document. Adopters contribute a stdlib / built-in set here instead of
+     * overriding this method.
+     */
+    protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
+    /**
+     * Warn when a seeded additional document's URI matches no registered
+     * language.
+     *
+     * Such a document is added to the workspace and indexed, but every
+     * per-language service is resolved per URI — so scope computation, naming,
+     * validation and serialisation all fail to route to it, and it contributes
+     * nothing to the scopes it was written to populate. Nothing else reports
+     * this: the document exists, so no lookup errors, it is simply inert.
+     *
+     * The usual cause is a `virtualUri` with no file extension:
+     * `virtualUri(contributor)` yields `virtual:<contributor>`, and routing has
+     * nothing to match on — there is no extension, and a virtual document is
+     * never open in `TextDocuments`, so the declared-languageId rung cannot
+     * serve it either. The convention is to end the URI with a registered
+     * extension by passing it as the last segment,
+     * `virtualUri(contributor, 'name.<ext>')`.
+     */
+    protected warnIfUnroutable(document: LangiumDocument): void;
+    protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
+    /**
+     * Add back the documents project discovery created that Langium's file
+     * traversal then filtered out.
+     *
+     * `AbstractProjectManager.discoverProjects` has to parse each descriptor to
+     * read it, which it does through `LangiumDocuments.getOrCreateDocument`.
+     * Langium's `performStartup` traversal skips any URI that already has a
+     * document, so every descriptor is missing from the list it returns — and
+     * `initializeWorkspace` builds exactly that list.
+     *
+     * The consequence is not a slow first build but a WRONG one. Descriptor
+     * documents stay at `Parsed` with nothing in the global index, while the
+     * documents that did make the list run all the way through `Linked` against
+     * that empty index. Every cross-document reference into a descriptor fails,
+     * and the failure sticks: a later build skips documents already at
+     * `Validated`, so nothing re-links them until the user edits the file.
+     *
+     * Invisible to an adopter whose descriptors ARE its model files (every file
+     * is a descriptor, the returned list is empty, `build([])` is a no-op).
+     * Fatal for one whose descriptors are a subset — a folder-scoped project
+     * model, or a second grammar whose files are never descriptors.
+     *
+     * Only documents created by discovery are re-added: pre-existing ones are
+     * either additional/library documents (already collected by
+     * `loadAdditionalDocuments`) or leftovers from an earlier initialization,
+     * and neither belongs in this build list.
+     */
+    protected withDiscoveredDescriptors(documents: LangiumDocument[], discovered: readonly LangiumDocument[]): LangiumDocument[];
+    /**
+     * One-shot startup diagnostic. Warns when a workspace root resolves through a
+     * symlink / `..` / case variant, so the URI a client opens (`S`) diverges
+     * from the canonical document identity (`R`) the build keys by — the
+     * condition the {@link DocumentUriPolicy} seam exists to reconcile.
+     * Probing the roots is sufficient and cheap: a divergent ancestor means every
+     * file beneath it diverges, and the loaded documents' URIs are already
+     * canonical (their original spelling is gone). Emits NOTHING for a plain
+     * on-disk workspace, or a filesystem without `realpath` — so a non-empty line
+     * is the empirical signal that a deployment actually exercises the divergence
+     * machinery.
+     */
+    protected probePathDivergence(folders: WorkspaceFolder[]): void;
+    /**
+     * Resolve the `{workspace}` file-tee placeholder from the first workspace
+     * folder. No-op when no folder is known or no `{workspace}`-templated log
+     * target is configured. See {@link toLogFileWorkspaceToken} for the token
+     * derivation — a log-capturing test harness uses the same function so the
+     * server's file name and the harness's correlation key agree.
+     */
+    protected resolveWorkspaceLogTarget(folders: WorkspaceFolder[]): void;
+    /**
+     * Override of Langium's workspace setup to resolve / reject
+     * {@link workspaceInitializedDeferred} once setup completes. Adopters with
+     * extra async work override this method, do their work in a sub-helper,
+     * and either delegate to `super.initializeWorkspace(...)` (preserving the
+     * default resolve) or call `this.workspaceInitializedDeferred.resolve(...)`
+     * themselves after the additional work finishes.
+     */
+    initializeWorkspace(folders: WorkspaceFolder[], cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Default cascade-rebuild handler. Iterates {@link ProjectChangeEvent.affectedDocuments}
+     * and resets each to {@link DocumentState.Changed} so the next build cycle
+     * re-runs the pipeline (parse → link → validate) under the new project
+     * visibility scope.
+     *
+     * Subclasses can override for additional behaviour (e.g. logging,
+     * telemetry, custom rebuild policies); call `super` to preserve the
+     * default cascade.
+     */
+    protected onProjectsChanged(event: ProjectChangeEvent): void;
+    /**
+     * Format a URI as a workspace-relative path suitable for log messages.
+     * Returns the path relative to `workspace` when provided (defaults to the
+     * first workspace folder's URI); falls back to the URI string when no
+     * workspace folder is known. Adopters with a multi-workspace model or a
+     * different display convention override on their workspace-manager
+     * subclass.
+     */
+    wsRelativePath(uri: URI | string, workspace?: string): string;
+}
+//# sourceMappingURL=hydranium-workspace-manager.d.ts.map

package/lib/langium/workspace/hydranium-workspace-manager.d.ts.map

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

package/lib/langium/workspace/hydranium-workspace-manager.js

@@ -0,0 +1,368 @@
+/********************************************************************************
+ * 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 } from '@hydranium/protocol';
+import { DefaultWorkspaceManager, DocumentState, UriUtils } from '@hydranium/langium';
+import { resolveLogFilePlaceholder, toLogFileWorkspaceToken } from '../diagnostics/logger.js';
+import { findRealpathDivergence } from './document-uri-policy.js';
+import { collectAdditionalDocuments } from './additional-document-contribution.js';
+import { onProcessEvent } from '../../util/environment.js';
+/**
+ * Module-level guard so repeated workspace-manager construction (e.g.
+ * test environments creating multiple instances across files) doesn't
+ * pile up listeners on the `process` singleton.
+ */
+let operationCancelledSuppressionInstalled = false;
+/**
+ * The logger the installed listener routes through, re-pointed by every
+ * install rather than captured by the first. A process hosts more than one
+ * services tree — a test worker builds many, and a CLI subcommand spawns one
+ * beside a running head — and a handler holding the first tree's logger sends
+ * every later tree's genuine rejections to a logger nobody is reading.
+ */
+let operationCancelledSuppressionLogger;
+/**
+ * Decide what to do with a process-level unhandled promise rejection.
+ *
+ * Langium's internal `Symbol(OperationCancelled)` marker — emitted when a
+ * `documentBuilder.build` is preempted by a concurrent write lock or
+ * cancellation token — is benign and is swallowed silently (without it the
+ * server logs spurious "Unhandled rejection" entries for cancellations that
+ * are not errors).
+ *
+ * Every OTHER reason is re-surfaced through {@link Logger.error}. This matters
+ * because Node disables its default crash/warn for ALL unhandled rejections as
+ * soon as any `unhandledRejection` listener is registered — so a handler that
+ * swallowed everything would make genuine unhandled rejections (real bugs)
+ * vanish silently. Logging keeps them visible while preserving the server's
+ * resilience (it does not re-crash the process).
+ *
+ * Pure and listener-free so it is unit-testable without touching the `process`
+ * singleton; {@link installOperationCancelledSuppression} wires it up.
+ */
+export function handleProcessUnhandledRejection(reason, logger) {
+    if (typeof reason === 'symbol' && String(reason) === 'Symbol(OperationCancelled)') {
+        return;
+    }
+    logger.error('Unhandled promise rejection: ' + (reason instanceof Error ? (reason.stack ?? reason.message) : String(reason)));
+}
+/**
+ * Install a process-level `unhandledRejection` listener that routes every
+ * rejection through {@link handleProcessUnhandledRejection} — swallowing
+ * Langium's `OperationCancelled` marker and logging everything else via the
+ * supplied {@link Logger}.
+ *
+ * Idempotent — safe to call from every {@link HydraniumWorkspaceManager}
+ * constructor. The `process` listener is installed at most once, because one
+ * per tree would pile up on a singleton, but each call RE-POINTS the logger it
+ * routes through: the listener reads it at rejection time rather than closing
+ * over the first caller's, so the most recently built tree is the one that
+ * hears about a genuine rejection.
+ *
+ * Applies to every Langium-based server that experiences concurrent builds.
+ */
+export function installOperationCancelledSuppression(logger) {
+    operationCancelledSuppressionLogger = logger;
+    if (operationCancelledSuppressionInstalled) {
+        return;
+    }
+    operationCancelledSuppressionInstalled = true;
+    // Node-only: a browser worker has no `process` / `unhandledRejection` — the
+    // accessor makes this a no-op there.
+    onProcessEvent('unhandledRejection', reason => {
+        if (operationCancelledSuppressionLogger) {
+            handleProcessUnhandledRejection(reason, operationCancelledSuppressionLogger);
+        }
+    });
+}
+/**
+ * Framework {@link DefaultWorkspaceManager} subclass that integrates the
+ * project tier with Langium's workspace startup.
+ *
+ * ## Phase 0 — project discovery
+ *
+ * Overrides {@link performStartup} to await
+ * {@link ProjectManager.discoverProjects} **before** Langium's standard
+ * startup phases (additional documents → file traversal → workspace
+ * documents). By the time `documentBuilder.build` runs, the project
+ * registry is fully populated and every parsed document can resolve its
+ * owning project via `projectManager.getProject(uri)`.
+ *
+ * Single-project consumers using `SingleProjectManager` pay no cost —
+ * the override is a no-op resolve.
+ *
+ * Discovery has a side effect the startup sequence has to compensate for:
+ * it reads each descriptor through `LangiumDocuments.getOrCreateDocument`,
+ * so those documents already exist when Langium's traversal runs — and
+ * Langium's traversal deliberately drops URIs that already have a document
+ * ("ensure that the documents don't already exist"), so it never returns
+ * them. {@link performStartup} adds them back; see the method comment for
+ * what breaks without it.
+ *
+ * ## Cascade rebuild
+ *
+ * Subscribes to {@link ProjectManager.onProjectsChanged} in the
+ * constructor. When a project's identity, version, or dependencies
+ * change post-startup, the project manager emits the affected document
+ * URIs (its own members plus any transitive dependents per the
+ * `getAffectedProjects` hook). This manager re-runs
+ * `DocumentBuilder.resetToState(doc, DocumentState.Changed)` on each
+ * affected document so the next build cycle re-links them with the new
+ * visibility scope.
+ *
+ * Descriptor URIs that triggered the cycle are intentionally excluded
+ * from the affected set by `AbstractProjectManager.onBuildUpdate` —
+ * re-adding them would loop.
+ */
+export class HydraniumWorkspaceManager extends DefaultWorkspaceManager {
+    projectManager;
+    tracer;
+    /**
+     * Deferred backing {@link workspaceInitialized}. The framework default
+     * resolves it from {@link initializeWorkspace} once Langium's standard
+     * workspace setup completes. Adopters that need to gate first-`didOpen`
+     * on additional async work (project-scope discovery, schema fetch, etc.)
+     * override {@link initializeWorkspace} and resolve / reject this Deferred
+     * after their work completes.
+     */
+    workspaceInitializedDeferred = new Deferred();
+    /**
+     * Resolves when the workspace is ready to handle the first `didOpen`
+     * event. `HydraniumTextDocuments.listen` awaits this promise inside its
+     * `didOpen` handler so the gate is hit at first use, not at DI. The
+     * framework resolves it from {@link initializeWorkspace}; adopters with
+     * extra async init override `initializeWorkspace` to thread their work
+     * before the resolve.
+     */
+    workspaceInitialized = this.workspaceInitializedDeferred.promise;
+    uriPolicy;
+    writableFileSystemProvider;
+    additionalDocuments;
+    /** Registry consulted by {@link warnIfUnroutable} to check a seeded document routes. */
+    languageRegistry;
+    constructor(services, options = {}) {
+        super(services);
+        this.projectManager = services.workspace.ProjectManager;
+        this.projectManager.onProjectsChanged(event => this.onProjectsChanged(event));
+        this.uriPolicy = services.workspace.DocumentUriPolicy;
+        this.writableFileSystemProvider = services.workspace.FileSystemProvider;
+        this.additionalDocuments = services.additionalDocuments;
+        this.languageRegistry = services.ServiceRegistry;
+        this.tracer = services.Tracer.for(options.logName ?? 'WorkspaceManager').trace('instantiated');
+        installOperationCancelledSuppression(this.tracer);
+    }
+    /**
+     * Contribution form of Langium's `loadAdditionalDocuments`. Runs the base
+     * behaviour first (a no-op unless a further subclass adds documents), then
+     * lets every {@link AdditionalDocumentContribution} in the shared
+     * `additionalDocuments` group build in-memory documents via the bound
+     * `LangiumDocumentFactory` and seed them through Langium's `collector`
+     * — so each is added to the workspace and indexed like a file-backed
+     * document. Adopters contribute a stdlib / built-in set here instead of
+     * overriding this method.
+     */
+    async loadAdditionalDocuments(folders, collector) {
+        await super.loadAdditionalDocuments(folders, collector);
+        const contributions = Object.keys(this.additionalDocuments);
+        if (contributions.length === 0) {
+            return;
+        }
+        // Observable like the discovery / build-phase spans: one timed line
+        // reporting how many contributions ran and how many documents they
+        // seeded. `tags` is read at the done-emit, so the document count pushed
+        // inside the callback appears in the log line.
+        const tags = [`${contributions.length} contributions`];
+        let documentCount = 0;
+        await this.tracer.time('Load additional documents', async () => {
+            await collectAdditionalDocuments(this.additionalDocuments, folders, document => {
+                documentCount++;
+                this.warnIfUnroutable(document);
+                collector(document);
+            });
+            tags.push(`${documentCount} documents`);
+        }, 'info', { logAfterMs: 0, tags });
+    }
+    /**
+     * Warn when a seeded additional document's URI matches no registered
+     * language.
+     *
+     * Such a document is added to the workspace and indexed, but every
+     * per-language service is resolved per URI — so scope computation, naming,
+     * validation and serialisation all fail to route to it, and it contributes
+     * nothing to the scopes it was written to populate. Nothing else reports
+     * this: the document exists, so no lookup errors, it is simply inert.
+     *
+     * The usual cause is a `virtualUri` with no file extension:
+     * `virtualUri(contributor)` yields `virtual:<contributor>`, and routing has
+     * nothing to match on — there is no extension, and a virtual document is
+     * never open in `TextDocuments`, so the declared-languageId rung cannot
+     * serve it either. The convention is to end the URI with a registered
+     * extension by passing it as the last segment,
+     * `virtualUri(contributor, 'name.<ext>')`.
+     */
+    warnIfUnroutable(document) {
+        if (this.languageRegistry.hasServices(document.uri)) {
+            return;
+        }
+        const extensions = this.languageRegistry.all.flatMap(language => language.LanguageMetaData.fileExtensions);
+        this.tracer.warn(`Additional document '${document.uri.toString()}' matches no registered language, so every per-language ` +
+            'service (scope computation, naming, validation, serialization) will fail to route to it and it will ' +
+            `contribute nothing to scopes. End its URI with a registered file extension (${extensions.join(', ')}); ` +
+            'for a virtual document that means passing it as the last segment, `virtualUri(contributor, "name.<ext>")`.');
+    }
+    async performStartup(folders) {
+        // Resolve the `{workspace}` file-tee placeholder (if configured) as early
+        // as possible — before any build logging — so per-workspace log capture
+        // names its file correctly and the buffered startup lines flush.
+        this.resolveWorkspaceLogTarget(folders);
+        // Snapshot the document set around discovery so the descriptor documents
+        // it creates can be identified afterwards. Plain iteration rather than
+        // stream operators, so the two passes work against any conforming
+        // `LangiumDocuments`; both run once per workspace initialization, next to
+        // a discovery walk of the whole tree.
+        const beforeDiscovery = new Set();
+        for (const document of this.langiumDocuments.all) {
+            beforeDiscovery.add(document.uri.toString());
+        }
+        // Phase 0: project discovery. By the time Langium's standard startup
+        // runs below, `getProject(uri)` returns a definitive answer for every URI
+        // that belongs to a discovered project.
+        await this.projectManager.discoverProjects(folders);
+        const discovered = [];
+        for (const document of this.langiumDocuments.all) {
+            if (!beforeDiscovery.has(document.uri.toString())) {
+                discovered.push(document);
+            }
+        }
+        const documents = await super.performStartup(folders);
+        this.probePathDivergence(folders);
+        return this.withDiscoveredDescriptors(documents, discovered);
+    }
+    /**
+     * Add back the documents project discovery created that Langium's file
+     * traversal then filtered out.
+     *
+     * `AbstractProjectManager.discoverProjects` has to parse each descriptor to
+     * read it, which it does through `LangiumDocuments.getOrCreateDocument`.
+     * Langium's `performStartup` traversal skips any URI that already has a
+     * document, so every descriptor is missing from the list it returns — and
+     * `initializeWorkspace` builds exactly that list.
+     *
+     * The consequence is not a slow first build but a WRONG one. Descriptor
+     * documents stay at `Parsed` with nothing in the global index, while the
+     * documents that did make the list run all the way through `Linked` against
+     * that empty index. Every cross-document reference into a descriptor fails,
+     * and the failure sticks: a later build skips documents already at
+     * `Validated`, so nothing re-links them until the user edits the file.
+     *
+     * Invisible to an adopter whose descriptors ARE its model files (every file
+     * is a descriptor, the returned list is empty, `build([])` is a no-op).
+     * Fatal for one whose descriptors are a subset — a folder-scoped project
+     * model, or a second grammar whose files are never descriptors.
+     *
+     * Only documents created by discovery are re-added: pre-existing ones are
+     * either additional/library documents (already collected by
+     * `loadAdditionalDocuments`) or leftovers from an earlier initialization,
+     * and neither belongs in this build list.
+     */
+    withDiscoveredDescriptors(documents, discovered) {
+        if (discovered.length === 0) {
+            return documents;
+        }
+        const collected = new Set(documents.map(document => document.uri.toString()));
+        const missing = discovered.filter(document => !collected.has(document.uri.toString()));
+        if (missing.length === 0) {
+            return documents;
+        }
+        this.tracer.debug(`Re-adding ${missing.length} project-descriptor document(s) to the initial build.`);
+        return [...missing, ...documents];
+    }
+    /**
+     * One-shot startup diagnostic. Warns when a workspace root resolves through a
+     * symlink / `..` / case variant, so the URI a client opens (`S`) diverges
+     * from the canonical document identity (`R`) the build keys by — the
+     * condition the {@link DocumentUriPolicy} seam exists to reconcile.
+     * Probing the roots is sufficient and cheap: a divergent ancestor means every
+     * file beneath it diverges, and the loaded documents' URIs are already
+     * canonical (their original spelling is gone). Emits NOTHING for a plain
+     * on-disk workspace, or a filesystem without `realpath` — so a non-empty line
+     * is the empirical signal that a deployment actually exercises the divergence
+     * machinery.
+     */
+    probePathDivergence(folders) {
+        if (!this.uriPolicy) {
+            return;
+        }
+        for (const folder of folders) {
+            const real = findRealpathDivergence(folder.uri, this.writableFileSystemProvider);
+            if (!real) {
+                continue;
+            }
+            const policyName = this.uriPolicy.constructor.name;
+            const collapsed = this.uriPolicy.canonicalUri(folder.uri) === this.uriPolicy.canonicalUri(real);
+            this.tracer.warn(`Workspace root '${folder.uri}' resolves through a symlink/'..'/case variant to '${real.toString()}', ` +
+                `so client URIs under it diverge from canonical document identity. ` +
+                (collapsed
+                    ? `The bound ${policyName} collapses both spellings to one identity, so subscriptions stay consistent.`
+                    : `The bound ${policyName} does NOT collapse them — the link and its target would become distinct documents.`));
+        }
+    }
+    /**
+     * Resolve the `{workspace}` file-tee placeholder from the first workspace
+     * folder. No-op when no folder is known or no `{workspace}`-templated log
+     * target is configured. See {@link toLogFileWorkspaceToken} for the token
+     * derivation — a log-capturing test harness uses the same function so the
+     * server's file name and the harness's correlation key agree.
+     */
+    resolveWorkspaceLogTarget(folders) {
+        const first = folders[0];
+        if (first) {
+            resolveLogFilePlaceholder('workspace', toLogFileWorkspaceToken(first.uri));
+        }
+    }
+    /**
+     * Override of Langium's workspace setup to resolve / reject
+     * {@link workspaceInitializedDeferred} once setup completes. Adopters with
+     * extra async work override this method, do their work in a sub-helper,
+     * and either delegate to `super.initializeWorkspace(...)` (preserving the
+     * default resolve) or call `this.workspaceInitializedDeferred.resolve(...)`
+     * themselves after the additional work finishes.
+     */
+    async initializeWorkspace(folders, cancelToken) {
+        try {
+            await super.initializeWorkspace(folders, cancelToken);
+            this.workspaceInitializedDeferred.resolve(undefined);
+        }
+        catch (error) {
+            this.workspaceInitializedDeferred.reject(error);
+            throw error;
+        }
+    }
+    /**
+     * Default cascade-rebuild handler. Iterates {@link ProjectChangeEvent.affectedDocuments}
+     * and resets each to {@link DocumentState.Changed} so the next build cycle
+     * re-runs the pipeline (parse → link → validate) under the new project
+     * visibility scope.
+     *
+     * Subclasses can override for additional behaviour (e.g. logging,
+     * telemetry, custom rebuild policies); call `super` to preserve the
+     * default cascade.
+     */
+    onProjectsChanged(event) {
+        for (const uri of event.affectedDocuments) {
+            const document = this.langiumDocuments.getDocument(uri);
+            if (document) {
+                this.documentBuilder.resetToState(document, DocumentState.Changed);
+            }
+        }
+    }
+    wsRelativePath(uri, workspace = this.workspaceFolders?.[0]?.uri) {
+        return workspace ? UriUtils.relative(workspace, uri) : typeof uri === 'string' ? uri : uri.path.toString();
+    }
+}
+//# sourceMappingURL=hydranium-workspace-manager.js.map

package/lib/langium/workspace/hydranium-workspace-manager.js.map

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