@hydranium/core 1.0.0-next.266 → 1.0.0-next.268

package/src/documents/version-sync-service.ts

@@ -8,7 +8,7 @@
  ********************************************************************************/
 
 import { DocumentState, type LangiumDocument, type URI } from '@hydranium/langium';
-import { type Tracer, UNRECORDED_VERSION } from '@hydranium/protocol';
+import { type Tracer, UNRECORDED_VERSION, describeError, describeErrorWithStack } from '@hydranium/protocol';
 import { Disposable, Emitter, type Event } from 'vscode-languageserver-protocol';
 import { type LogNameOptions } from '../langium/diagnostics/logger.js';
 import { type ServerSharedServices } from '../langium/module.js';
@@ -46,20 +46,21 @@ export interface VersionSyncService {
    /**
     * Build `uri` from a `WorkspaceLock` read, so the build queues behind a
     * running one rather than cancelling it. Requests made while one for `uri`
-    * is pending share its next build. Resolves `true` once a build that carried
-    * this request completed, or once a check before a build found it no longer
+    * is pending share its next build. Resolves once a build that carried this
+    * request completed, or once a check before a build found it no longer
     * needed or deferred. A build a later write cancelled does not count: the
-    * request rides the next one. Resolves `false` once builds carrying this
-    * request have failed more often than it may retry, so a caller waiting on
-    * the build can stop. Never rejects.
+    * request rides the next one. Rejects with the last build's error once builds
+    * carrying this request have failed more often than it may retry, so a
+    * caller waiting on the build can stop; the caller ends that failure, and
+    * logs it if nothing else reports it.
     */
-   requestRecoveryBuild(uri: URI, request: RecoveryBuildRequest): Promise<boolean>;
+   requestRecoveryBuild(uri: URI, request: RecoveryBuildRequest): Promise<void>;
    /**
     * Build `uri` unless it is {@link isSyncedTo synced to} `textVersion`, asked
     * again inside the lock. `undefined` when no build is needed, else the
-    * {@link requestRecoveryBuild} answer.
+    * {@link requestRecoveryBuild} promise.
     */
-   syncTo(uri: URI, textVersion: number): Promise<boolean> | undefined;
+   syncTo(uri: URI, textVersion: number): Promise<void> | undefined;
    /**
     * Whether `uri`'s root was parsed from text at `textVersion` or later; requests
     * nothing. A root with no recorded version or a placeholder counts as synced,
@@ -85,7 +86,10 @@ export interface VersionSyncService {
 export interface QueuedRecoveryBuild {
    readonly request: RecoveryBuildRequest;
    failures: number;
-   readonly answer: (built: boolean) => void;
+   /** Settles the request once a build carried it or it was no longer needed. */
+   readonly resolve: () => void;
+   /** Settles the request once it has used its retries, with the last build's error. */
+   readonly reject: (error: unknown) => void;
 }
 
 /** The requests waiting on one URI's builds in {@link DefaultVersionSyncService}. */
@@ -102,7 +106,7 @@ export class DefaultVersionSyncService implements VersionSyncService {
    protected readonly recordedEmitter = new Emitter<LangiumDocument>();
    protected readonly deferredBuildChecks = new Set<(uri: URI) => boolean>();
    protected readonly pendingBuilds = new Map<string, PendingRecoveryBuilds>();
-   /** Retries of each request after a failed build before it is answered `false`. */
+   /** Retries of each request after a failed build before it is rejected. */
    protected readonly maxBuildRetries: number = 1;
 
    constructor(
@@ -142,19 +146,22 @@ export class DefaultVersionSyncService implements VersionSyncService {
          }
          ledger.record(root, version, origin.text);
       }
-      void this.syncTo(document.uri, store.version(uri));
+      // Nothing waits on this build, so its failure ends here.
+      this.syncTo(document.uri, store.version(uri))?.catch((error: unknown) =>
+         this.tracer.withUri(uri).error(`The build that would sync the root to its text failed. ${describeErrorWithStack(error)}`)
+      );
       this.recordedEmitter.fire(document);
    }
 
-   syncTo(uri: URI, textVersion: number): Promise<boolean> | undefined {
+   syncTo(uri: URI, textVersion: number): Promise<void> | undefined {
       const behind = (): boolean => !this.isSyncedTo(uri, textVersion);
       return behind() ? this.requestRecoveryBuild(uri, { stillNeeded: behind }) : undefined;
    }
 
-   requestRecoveryBuild(uri: URI, request: RecoveryBuildRequest): Promise<boolean> {
-      return new Promise<boolean>(answer => {
+   requestRecoveryBuild(uri: URI, request: RecoveryBuildRequest): Promise<void> {
+      return new Promise<void>((resolve, reject) => {
          const key = uri.toString();
-         const queued: QueuedRecoveryBuild = { request, failures: 0, answer };
+         const queued: QueuedRecoveryBuild = { request, failures: 0, resolve, reject };
          const pending = this.pendingBuilds.get(key);
          if (pending) {
             // Not dropped: the pending build may have read the text before this request's change.
@@ -189,8 +196,8 @@ export class DefaultVersionSyncService implements VersionSyncService {
 
    /**
     * Run `entry`'s requests, one build per batch, until none is queued, and
-    * answer each. A request a failed build carried is queued again
-    * {@link maxBuildRetries} times, then answered `false`; one a cancelled
+    * settle each. A request a failed build carried is queued again
+    * {@link maxBuildRetries} times, then rejected; one a cancelled
     * build carried is queued again without counting. The entry is dropped
     * in the same tick as the last check of the queue, so no request lands in
     * an entry nothing runs any more.
@@ -210,7 +217,7 @@ export class DefaultVersionSyncService implements VersionSyncService {
             await lock.read(() => {
                carried = entry.queued.splice(0);
                const needed = carried.filter(queued => this.isStillNeeded(uri, queued.request));
-               carried.filter(queued => !needed.includes(queued)).forEach(queued => queued.answer(true));
+               carried.filter(queued => !needed.includes(queued)).forEach(queued => queued.resolve());
                carried = needed;
                if (needed.length > 0) {
                   build = this.scheduleBatch(
@@ -227,18 +234,19 @@ export class DefaultVersionSyncService implements VersionSyncService {
                entry.queued.unshift(...carried);
                continue;
             }
-            carried.forEach(queued => queued.answer(true));
+            carried.forEach(queued => queued.resolve());
          } catch (err: unknown) {
-            const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
             const retried = carried.filter(queued => queued.failures++ < this.maxBuildRetries);
             const givenUp = carried.filter(queued => !retried.includes(queued));
             if (retried.length > 0) {
-               tracer.warn(`Requested build failed; retrying. ${detail}`);
+               // The only line about this failure when the retry succeeds.
+               tracer.warn(`Requested build failed; retrying. ${describeErrorWithStack(err)}`);
                entry.queued.unshift(...retried);
             }
             if (givenUp.length > 0) {
-               tracer.error(`Requested build failed again; giving up. ${detail}`);
-               givenUp.forEach(queued => queued.answer(false));
+               // Each requester ends the failure, so the log line is theirs.
+               tracer.debug(`Requested build failed again; giving up. ${describeError(err)}`);
+               givenUp.forEach(queued => queued.reject(err));
             }
          }
       }

package/src/langium/diagnostics/lsp-logger.ts

@@ -19,6 +19,7 @@ import {
    type LogThreshold,
    ObservableValue,
    type MaybeObservableValue,
+   describeErrorWithStack,
    parseLogLevel
 } from '@hydranium/protocol';
 import { type URI } from '@hydranium/langium';
@@ -308,7 +309,7 @@ function formatLogArg(value: unknown): string {
       return value;
    }
    if (value instanceof Error) {
-      return value.stack ?? value.message;
+      return describeErrorWithStack(value);
    }
    if (typeof value === 'object') {
       try {

package/src/langium/document-builder/document-builder.ts

@@ -7,7 +7,14 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { type Clock, type LogThreshold, type MaybeObservableValue, ObservableValue, type Tracer } from '@hydranium/protocol';
+import {
+   type Clock,
+   type LogThreshold,
+   type MaybeObservableValue,
+   ObservableValue,
+   type Tracer,
+   describeErrorWithStack
+} from '@hydranium/protocol';
 import {
    type AstNode,
    type BuildOptions,
@@ -356,7 +363,7 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
          try {
             listener(event);
          } catch (error: unknown) {
-            this.tracer.error(`A build-ended listener failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
+            this.tracer.error(`A build-ended listener failed: ${describeErrorWithStack(error)}`);
          }
       }
    }
@@ -488,12 +495,15 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
          // land while a busy workspace keeps cancelling builds.
          let stalledRequeues = 0;
          let lastRequeueState: DocumentState | undefined;
-         const giveUp = (reason: string): void => {
+         let settled = false;
+         let cancelled = false;
+         const giveUp = (reason: string, cause?: unknown): void => {
             cleanup();
             reject(
                new Error(
                   `Gave up building ${this.formatUri(uri)} to '${DocumentState[state]}' ` +
-                     `(at '${DocumentState[document.state]}'): ${reason}`
+                     `(at '${DocumentState[document.state]}'): ${reason}`,
+                  { cause }
                )
             );
          };
@@ -517,9 +527,16 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
                stalledRequeues = 0;
                lastRequeueState = document.state;
             }
-            void this.requeueOrphaned(document, state, reason).then(built => {
-               if (!built && rejectWhenStuck) {
-                  giveUp('its recovery build failed');
+            this.requeueOrphaned(document, state, reason).catch((error: unknown) => {
+               const line = `A recovery build of ${this.formatUri(uri)} failed. ${describeErrorWithStack(error)}`;
+               if (rejectWhenStuck && !settled) {
+                  giveUp('its recovery build failed', error);
+               } else if (settled && !cancelled) {
+                  // The wait ended with an outcome its caller reports, and the retry warned.
+                  this.tracer.withUri(uri.toString()).debug(line);
+               } else {
+                  // The waiter has gone, or waits on its cancellation token alone, so nothing else reports this.
+                  this.tracer.withUri(uri.toString()).error(line);
                }
             });
          };
@@ -559,10 +576,12 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
          };
          const buildDisposable = this.onBuildEnded(buildEnded);
          const cancelDisposable = cancelToken.onCancellationRequested(() => {
+            cancelled = true;
             cleanup();
             reject(OperationCancelled);
          });
          const cleanup = (): void => {
+            settled = true;
             phaseDisposable.dispose();
             skipDisposable.dispose();
             buildDisposable.dispose();
@@ -628,11 +647,11 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
     * the build neither runs beside a locked one nor cancels the build a
     * re-queue is fired from, and skipped if a write that ran meanwhile carried
     * the document to `state`. The waiter resolves off the resulting phase
-    * notification; the answer only tells it whether the build was given up.
+    * notification; the promise only tells it whether the build was given up.
     */
-   protected requeueOrphaned(document: LangiumDocument, state: DocumentState, reason: string): Promise<boolean> {
+   protected requeueOrphaned(document: LangiumDocument, state: DocumentState, reason: string): Promise<void> {
       const tracer = this.tracer.withUri(document.uri.toString());
-      tracer.info(`Re-queuing orphaned document (at '${DocumentState[document.state]}', needs '${DocumentState[state]}'): ${reason}`);
+      tracer.debug(`Re-queuing orphaned document (at '${DocumentState[document.state]}', needs '${DocumentState[state]}'): ${reason}`);
       return this.versionSyncService().requestRecoveryBuild(document.uri, {
          // Skipped on purpose: a waiting caller is answered sooner, at the cost
          // of a possible duplicate build once the debounce fires.
@@ -1391,7 +1410,7 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
       if (cancelledListeners > 0) {
          this.tracer
             .withUri(document.uri.toString())
-            .info(this.cancelledDocumentPhaseLine(document, state, cancelledListeners, listeners.length));
+            .debug(this.cancelledDocumentPhaseLine(document, state, cancelledListeners, listeners.length));
       }
       if (totalMs >= this.slowPhaseMs.value) {
          this.log(this.slowDocumentPhaseLine(document, state, listeners, perListenerMs, totalMs));

package/src/langium/integrity/integrity-service.ts

@@ -213,8 +213,11 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
          await interruptAndCheck(cancelToken);
       }
       const totalMs = Math.round(performance.now() - phaseStart);
-      if (totalMs >= 25 || mutatedCount > 0) {
+      // A repair is the operator's to know of; the timing alone is diagnosis.
+      if (mutatedCount > 0) {
          this.tracer.info(`enforce ${DocumentState[phase]}: docs=${documents.length}, mutated=${mutatedCount} [${totalMs}ms]`);
+      } else if (totalMs >= 25) {
+         this.tracer.debug(`enforce ${DocumentState[phase]}: docs=${documents.length}, mutated=${mutatedCount} [${totalMs}ms]`);
       }
       // One line per rule (count + self-% + self-ms), sorted by cost — only when profiling.
       session?.report('debug');

package/src/langium/model-service/client-session.ts

@@ -17,9 +17,10 @@ import {
    ObservableValue,
    type TextVersion,
    type Tracer,
-   type TransferElement
+   type TransferElement,
+   describeErrorWithStack
 } from '@hydranium/protocol';
-import { type AstNode, UriUtils } from '@hydranium/langium';
+import { type AstNode, isOperationCancelled, UriUtils } from '@hydranium/langium';
 import { type CancellationToken, type Disposable, Emitter, type Event } from 'vscode-languageserver';
 import { type AstDocument, type SavedAstDocument } from '../../documents/ast-document-manager.js';
 import { DocumentNotOpenError, SessionClosedError } from '../../documents/client-session-errors.js';
@@ -410,7 +411,23 @@ export class DefaultClientSession<
       const applied = uris.map((uri, i) => this.services.workspace.AstDocumentManager.update(uri, texts[i], this.clientId));
       await Promise.all(applied);
       const state = this.services.workspace.DocumentBuilder.finalBuildState();
-      return Promise.all(uris.map(uri => service.rebuild(uri, state, cancelToken)));
+      const rebuilt = await Promise.allSettled(uris.map(uri => service.rebuild(uri, state, cancelToken)));
+      const failures = rebuilt.flatMap((result, i) => (result.status === 'rejected' ? [{ uri: uris[i], reason: result.reason }] : []));
+      if (failures.length === 0) {
+         return rebuilt.flatMap(result => (result.status === 'fulfilled' ? [result.value] : []));
+      }
+      // The first is thrown as it is, so a typed failure keeps its type; one build
+      // usually carries the set and fails each with the same error. Any other
+      // failure reaches no one else, so it is logged here.
+      const [{ uri: firstUri, reason: firstReason }] = failures;
+      for (const { uri, reason } of failures.slice(1)) {
+         if (isOperationCancelled(reason)) {
+            this.tracer.with(uri).debug(`Rebuild of ${uri} cancelled beside that of ${firstUri}`);
+         } else if (reason !== firstReason) {
+            this.tracer.with(uri).error(`Rebuild of ${uri} failed beside that of ${firstUri}. ${describeErrorWithStack(reason)}`);
+         }
+      }
+      throw firstReason;
    }
 
    /**

package/src/langium/model-service/model-service.ts

@@ -18,9 +18,18 @@ import {
    type TransferElement,
    type TextVersion,
    type Tracer,
-   UNRECORDED_VERSION
+   UNRECORDED_VERSION,
+   describeErrorWithStack
 } from '@hydranium/protocol';
-import { type AstNode, DocumentState, type LangiumDocument, OperationCancelled, UriUtils, type URI } from '@hydranium/langium';
+import {
+   type AstNode,
+   DocumentState,
+   type LangiumDocument,
+   OperationCancelled,
+   isOperationCancelled,
+   UriUtils,
+   type URI
+} from '@hydranium/langium';
 import { type AstDiagnostic } from '../validation/document-validator.js';
 import { type DocumentUriPolicy } from '../workspace/document-uri-policy.js';
 import { ReentrantWriteLockError, isInsideWriteLock, isWriteLockScopeInstalled } from '../workspace/write-lock-scope.js';
@@ -571,23 +580,37 @@ export class DefaultModelService<
     * given up. A `Parsed` phase listener cannot serve: a cancel right after the
     * parse skips it, and the resumed build does not parse again.
     */
-   protected nextParseOrDeletion(
-      uri: URI,
-      cancelToken: CancellationToken = CancellationToken.None,
-      build?: Promise<boolean>
-   ): Promise<void> {
+   protected nextParseOrDeletion(uri: URI, cancelToken: CancellationToken = CancellationToken.None, build?: Promise<void>): Promise<void> {
       const builder = this.services.workspace.DocumentBuilder;
       return new Promise<void>((resolve, reject) => {
+         let ended = false;
+         let cancelled = false;
+         // Handled before any return, so a build given up after the wait ended is not an unhandled rejection.
+         build?.catch((error: unknown) => {
+            const line = `The build that would sync the root to its text failed. ${describeErrorWithStack(error)}`;
+            if (cancelled) {
+               // The waiter has gone, so nothing else reports this.
+               this.tracer.withUri(uri.toString()).error(line);
+            } else if (ended) {
+               // A parse or deletion came first: the waiter goes on and reports its own outcome, and the retry warned.
+               this.tracer.withUri(uri.toString()).debug(line);
+            } else {
+               done(() => reject(new Error(`The build that would sync ${uri.toString()} to its text failed`, { cause: error })));
+            }
+         });
          // A cancelled token's listener runs a macrotask later, after a build
          // that started meanwhile may have parsed.
          if (cancelToken.isCancellationRequested) {
+            ended = true;
+            cancelled = true;
             reject(OperationCancelled);
             return;
          }
          const done = (settle: () => void): void => {
+            ended = true;
             parsed.dispose();
             deleted.dispose();
-            cancelled.dispose();
+            cancelling.dispose();
             settle();
          };
          const parsed = this.services.workspace.VersionSyncService.onDidRecordModel(document => {
@@ -600,11 +623,9 @@ export class DefaultModelService<
                done(resolve);
             }
          });
-         const cancelled = cancelToken.onCancellationRequested(() => done(() => reject(OperationCancelled)));
-         void build?.then(built => {
-            if (!built) {
-               done(() => reject(new Error(`The build that would sync ${uri.toString()} to its text failed`)));
-            }
+         const cancelling = cancelToken.onCancellationRequested(() => {
+            cancelled = true;
+            done(() => reject(OperationCancelled));
          });
       });
    }
@@ -808,8 +829,9 @@ export class DefaultModelService<
     * so every language client reflects the latest content before a save returns.
     * No-op tail for headless adopters — `syncChains` is empty without an LSP
     * client. Bounded by {@link SAVE_SETTLE_TIMEOUT_MS} so a hung build, or an
-    * applyEdit reverse-RPC deadlock, can't freeze the caller; on timeout or a
-    * failed wait it logs a warning and returns rather than throwing.
+    * applyEdit reverse-RPC deadlock, can't freeze the caller; it returns rather
+    * than throwing, warning on timeout. A failed wait is logged at `error`, at
+    * `debug` when cancelled and at `warn` when the document is gone.
     *
     * Adopters with a save flow that must converge editor + disk before returning
     * (e.g. a dual form/code editor that would otherwise show a content-conflict
@@ -824,15 +846,26 @@ export class DefaultModelService<
          await this.waitForDocumentStateCanonical(canonical, IntegrityService.SettledState, cancelToken, { sync: true });
          await this.syncChains.get(key);
       })();
+      // The settle ends a failed wait, so it logs it, at one level whether the wait failed inside the bound or after it.
+      const reportFailedWait = (error: unknown, when: string): void => {
+         const tracer = this.tracer.withUri(key);
+         if (isOperationCancelled(error)) {
+            tracer.debug(`Save settle cancelled ${when}`);
+         } else if (!this.services.workspace.LangiumDocuments.hasDocument(UriUtils.toUri(canonical))) {
+            tracer.warn(`Save settle failed ${when}; the document is gone. ${describeErrorWithStack(error)}`);
+         } else {
+            tracer.error(`Save settle failed ${when}. ${describeErrorWithStack(error)}`);
+         }
+      };
       try {
          if ((await this.services.Clock.raceTimer(settled, SAVE_SETTLE_TIMEOUT_MS)) === TIMED_OUT) {
             this.tracer.withUri(key).warn(`Save settle exceeded ${SAVE_SETTLE_TIMEOUT_MS}ms — returning anyway`);
+            // The race has settled, so a later failure of the wait, such as a given-up sync build, reaches no one else.
+            void settled.catch((error: unknown) => reportFailedWait(error, 'after the timeout'));
          }
       } catch (err: unknown) {
-         // A failed wait, such as a cancelled token or a document the builder
-         // does not hold, gets its own line so it is not blamed on the bound.
-         const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
-         this.tracer.withUri(key).warn(`Save settle failed before the timeout — returning anyway. ${detail}`);
+         // Its own line, so the failure is not blamed on the bound.
+         reportFailedWait(err, 'before the timeout — returning anyway');
       }
    }
 
@@ -1123,7 +1156,7 @@ export class DefaultModelService<
             if (isClientGoneError(err)) {
                uriLogger.debug(`applyEdit to ${LANGUAGE_CLIENT_ID} skipped: client disconnected`);
             } else {
-               uriLogger.error(`applyEdit to ${LANGUAGE_CLIENT_ID} failed: ${err}`);
+               uriLogger.error(`applyEdit to ${LANGUAGE_CLIENT_ID} failed: ${describeErrorWithStack(err)}`);
             }
          }
       }
@@ -1162,7 +1195,7 @@ export class DefaultModelService<
          try {
             listener(Object.freeze({ uris: built.map(document => this.uriPolicy.canonicalUri(document.uri.toString())), phase }));
          } catch (err: unknown) {
-            this.tracer.error(`onModelsBuilt listener threw: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
+            this.tracer.error(`onModelsBuilt listener threw: ${describeErrorWithStack(err)}`);
          }
       });
    }
@@ -1267,9 +1300,7 @@ export class DefaultModelService<
          try {
             listener(event);
          } catch (err: unknown) {
-            this.tracer
-               .with(uri)
-               .error(`onModelUpdated listener threw: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
+            this.tracer.with(uri).error(`onModelUpdated listener threw: ${describeErrorWithStack(err)}`);
          }
       }
    }

package/src/langium/project/abstract-project-manager.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { Deferred, type Project, type Tracer, UNQUALIFIED_PROJECT_REFERENCE } from '@hydranium/protocol';
+import { Deferred, type Project, type Tracer, UNQUALIFIED_PROJECT_REFERENCE, describeErrorWithStack } from '@hydranium/protocol';
 import {
    type AstNode,
    AstUtils,
@@ -226,7 +226,7 @@ export abstract class AbstractProjectManager<TProject extends Project = Project>
       try {
          entries = await this.fileSystemProvider.readDirectory(folder);
       } catch (error) {
-         this.tracer.warn(`Failed to read directory ${folder.toString()}: ${error}`);
+         this.tracer.warn(`Failed to read directory ${folder.toString()}: ${describeErrorWithStack(error)}`);
          return;
       }
       for (const entry of entries) {
@@ -395,7 +395,7 @@ export abstract class AbstractProjectManager<TProject extends Project = Project>
          }
          return project;
       } catch (error) {
-         this.tracer.error(`Failed to parse ${this.conceptName()} descriptor at ${uri.toString()}: ${error}`);
+         this.tracer.error(`Failed to parse ${this.conceptName()} descriptor at ${uri.toString()}: ${describeErrorWithStack(error)}`);
          return undefined;
       }
    }
@@ -620,7 +620,7 @@ export abstract class AbstractProjectManager<TProject extends Project = Project>
          try {
             listener(event);
          } catch (error) {
-            this.tracer.error(`Project change listener failed: ${error}`);
+            this.tracer.error(`Project change listener failed: ${describeErrorWithStack(error)}`);
          }
       }
    }

package/src/langium/scope/hydranium-scope-computation.ts

@@ -59,6 +59,10 @@ import { type HydraniumAstNodeDescriptionProvider } from './ast-node-description
  * duplicated walks.
  */
 export class HydraniumScopeComputation extends DefaultScopeComputation {
+   /** The framework's name provider, which its language module binds to the slot. */
+   declare protected readonly nameProvider: NameProvider;
+   /** The framework's description provider, which its language module binds to the slot. */
+   declare protected readonly descriptions: HydraniumAstNodeDescriptionProvider;
    protected readonly tracer: Tracer;
 
    constructor(
@@ -155,17 +159,15 @@ export class HydraniumScopeComputation extends DefaultScopeComputation {
     * workspace-visible rather than being filtered out everywhere.
     */
    protected exportProject(node: AstNode, exports: AstNodeDescription[], document: LangiumDocument): void {
-      const nameProvider = this.nameProvider as NameProvider;
-      const documentName = nameProvider.getDocumentQualifiedName(node);
+      const documentName = this.nameProvider.getDocumentQualifiedName(node);
       if (!documentName) {
          return;
       }
       const projectId = this.getProjectIdForDocument(document);
-      const descriptions = this.descriptions as HydraniumAstNodeDescriptionProvider;
       exports.push(
          projectId !== undefined
-            ? descriptions.createProject({ node, name: documentName, document, projectId })
-            : descriptions.createUniversal({ node, name: documentName, document })
+            ? this.descriptions.createProject({ node, name: documentName, document, projectId })
+            : this.descriptions.createUniversal({ node, name: documentName, document })
       );
    }
 
@@ -182,16 +184,14 @@ export class HydraniumScopeComputation extends DefaultScopeComputation {
     * document-qualified name.
     */
    protected exportPublic(node: AstNode, exports: AstNodeDescription[], document: LangiumDocument): void {
-      const nameProvider = this.nameProvider as NameProvider;
       const projectId = this.getProjectIdForDocument(document);
       if (projectId === undefined) {
          return;
       }
-      const documentName = nameProvider.getDocumentQualifiedName(node);
-      const projectName = nameProvider.getProjectQualifiedName(node);
+      const documentName = this.nameProvider.getDocumentQualifiedName(node);
+      const projectName = this.nameProvider.getProjectQualifiedName(node);
       if (projectName && projectName !== documentName) {
-         const descriptions = this.descriptions as HydraniumAstNodeDescriptionProvider;
-         exports.push(descriptions.createPublic({ node, name: projectName, document, projectId }));
+         exports.push(this.descriptions.createPublic({ node, name: projectName, document, projectId }));
       }
    }
 
@@ -239,9 +239,9 @@ export class HydraniumScopeComputation extends DefaultScopeComputation {
       if (!container) {
          return;
       }
-      const name = (this.nameProvider as NameProvider).getOwnName(node);
+      const name = this.nameProvider.getOwnName(node);
       if (name) {
-         symbols.add(container, (this.descriptions as HydraniumAstNodeDescriptionProvider).createLocal({ node, name, document }));
+         symbols.add(container, this.descriptions.createLocal({ node, name, document }));
       }
    }
 }

package/src/langium/validation/document-validator.ts

@@ -698,9 +698,11 @@ export class HydraniumDocumentValidator extends DefaultDocumentValidator {
     */
    protected buildElementPath<N extends AstNode>(node: N, info: DiagnosticInfo<N, string>): string {
       const directPath = this.astNodeLocator.getAstNodePath(node);
-      const containerPath = directPath ? undefined : this.astNodeLocator.getAstNodePath(node.$container ?? ({ $type: 'Dummy' } as AstNode));
-      const nodePath = directPath || containerPath;
-      if (!nodePath) {
+      // The locator answers '' for the root, which is the root's path rather than a miss.
+      const isRoot = node.$container === undefined;
+      const containerPath = directPath || isRoot ? undefined : this.astNodeLocator.getAstNodePath(node.$container);
+      const nodePath = directPath || containerPath || '';
+      if (!nodePath && !isRoot) {
          this.tracer.warn('Cannot create diagnostic element path: Unable to determine AST node path.');
          return '';
       }

package/src/langium/workspace/hydranium-workspace-lock.ts

@@ -18,7 +18,7 @@ import { runInWriteLockScope } from './write-lock-scope.js';
 export interface HydraniumWorkspaceLockOptions extends LogNameOptions {
    /**
     * How long a write may keep running after a later write cancelled it before
-    * the lock logs an error. Every write and read waits behind it meanwhile, so
+    * the lock logs a warning. Every write and read waits behind it meanwhile, so
     * one that never ends stops the server. Defaults to 10 s; `0` turns the
     * check off.
     */
@@ -109,7 +109,7 @@ export class HydraniumWorkspaceLock extends DefaultWorkspaceLock {
    }
 
    protected reportStalledWrite(): void {
-      this.tracer.error(
+      this.tracer.warn(
          `A write is still running ${this.stalledWriteWarnMs} ms after it was cancelled, and every write and read waits behind it. ` +
             'Likely causes: a model-service write or rebuild from inside a build in a host with no write-lock scope tracker, ' +
             'which waits for the build it runs in, or a write action that ignores its cancellation token. ' +

package/src/langium/workspace/hydranium-workspace-manager.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { Deferred, type Logger, type Tracer } from '@hydranium/protocol';
+import { Deferred, type Logger, type Tracer, describeError, describeErrorWithStack } from '@hydranium/protocol';
 import {
    DefaultWorkspaceManager,
    DocumentState,
@@ -69,7 +69,7 @@ export function handleProcessUnhandledRejection(reason: unknown, logger: Logger)
    if (typeof reason === 'symbol' && String(reason) === 'Symbol(OperationCancelled)') {
       return;
    }
-   logger.error('Unhandled promise rejection: ' + (reason instanceof Error ? (reason.stack ?? reason.message) : String(reason)));
+   logger.error('Unhandled promise rejection: ' + describeErrorWithStack(reason));
 }
 
 /**
@@ -507,11 +507,10 @@ export class HydraniumWorkspaceManager extends DefaultWorkspaceManager {
          await super.initializeWorkspace(folders, cancelToken);
          this.workspaceInitializedDeferred.resolve(undefined);
       } catch (error: unknown) {
-         const message = error instanceof Error ? error.message : String(error);
          if (isOperationCancelled(error) || isConnectionGoneError(error)) {
-            this.tracer.debug(`Initial workspace build did not complete: ${message}`);
+            this.tracer.debug(`Initial workspace build did not complete: ${describeError(error)}`);
          } else {
-            this.tracer.error(`Initial workspace build failed: ${message}`);
+            this.tracer.error(`Initial workspace build failed: ${describeErrorWithStack(error)}`);
          }
          this.workspaceInitializedDeferred.reject(error);
          throw error;

package/src/langium/workspace/persistent-file-system-provider.ts

@@ -8,6 +8,7 @@
  ********************************************************************************/
 
 import { URI } from '@hydranium/langium';
+import { describeErrorWithStack } from '@hydranium/protocol';
 import { type WritableFileSystemProvider } from './file-system-provider.js';
 import { serverSharedFactory, type ServerSharedServicesMinimal } from '../shared-services.js';
 import { type FileSystemSeed, InMemoryFileSystemProvider, type InMemoryFileSystemOptions } from './in-memory-file-system-provider.js';
@@ -250,7 +251,7 @@ export class PersistentFileSystemProvider extends InMemoryFileSystemProvider {
    }
 
    protected reportStoreFailure(operation: string, uri: URI, error: unknown): void {
-      this.tracer.error(`Failed to ${operation} ${uri.toString()}: ${error instanceof Error ? error.message : String(error)}`);
+      this.tracer.error(`Failed to ${operation} ${uri.toString()}: ${describeErrorWithStack(error)}`);
    }
 }