@hydranium/core 1.0.0-next.12 → 1.0.0-next.127

package/src/langium/document-builder/build-pipeline-integration.ts

@@ -31,13 +31,24 @@ const AST_EXTENSION_PHASES: readonly DocumentState[] = [
 ];
 
 /**
- * Build phases at which the `BuildPhasePassService` is driven. Same useful
- * set as {@link AST_EXTENSION_PHASES}: a pass registered at any other state
- * never fires (the listener is not wired), mirroring the AST-extension contract.
+ * Build phases at which the `BuildPhasePassService` is driven. A pass
+ * registered at any other state never fires (the listener is not wired), and
  * `runPasses` no-ops at a phase with no registered pass, so wiring the full set
  * unconditionally costs only an empty-bucket check per phase.
+ *
+ * `IndexedContent` belongs here and NOT in {@link AST_EXTENSION_PHASES}, so the
+ * two cannot be collapsed. Per document it carries nothing `Parsed` does; per
+ * BATCH it is the only phase meaning the global index is whole again, which
+ * batch work keyed on a complete index has nowhere else to run.
  */
-const BUILD_PHASE_PASS_STATES: readonly DocumentState[] = AST_EXTENSION_PHASES;
+const BUILD_PHASE_PASS_STATES: readonly DocumentState[] = [
+   DocumentState.Parsed,
+   DocumentState.IndexedContent,
+   DocumentState.ComputedScopes,
+   DocumentState.Linked,
+   DocumentState.IndexedReferences,
+   DocumentState.Validated
+];
 
 /**
  * Default priority of the framework integrity passes. Integrity mutates / cleans
@@ -65,6 +76,19 @@ export interface BuildPipelineIntegrationOptions {
    readonly integrityPriority?: number;
 }
 
+/**
+ * The build-pipeline slot. Empty because nothing calls this service — it wires
+ * itself in its constructor and every seam it offers is `protected`.
+ *
+ * Typing the slot by the class instead would stop an adopter's subclass
+ * satisfying it, since a class carries its `protected` members into the check
+ * and they compare by declaration rather than by shape. The cost of the empty
+ * shape is that any non-null value satisfies it, so a mis-bound slot compiles
+ * and the framework's phase listeners are then never attached.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- the slot has no public member to name
+export interface BuildPipelineIntegration {}
+
 /**
  * Wires the framework's build-time features (integrity rules, AST
  * enrichment) into Langium's document-build pipeline. The single shared
@@ -90,7 +114,7 @@ export interface BuildPipelineIntegrationOptions {
  * Eagerly constructed (via `DEFAULT_EAGER_SERVICES`) so the listeners are
  * attached before the first build cycle.
  */
-export class BuildPipelineIntegration {
+export class DefaultBuildPipelineIntegration implements BuildPipelineIntegration {
    constructor(
       protected readonly services: ServerSharedServices,
       options: BuildPipelineIntegrationOptions = {}
@@ -128,6 +152,14 @@ export class BuildPipelineIntegration {
          );
       }
 
+      // Per DOCUMENT as well: `reparseAndRelink` re-indexes one document from
+      // inside the `Linked` phase and fires no build-phase notification, so a
+      // batch-level listener cannot see the AST it replaced.
+      builder.onDocumentPhase(
+         DocumentState.IndexedContent,
+         labelPhaseListener(() => this.clearScopeCaches(), 'BuildPipeline.clearScopeCaches')
+      );
+
       // AST enrichment stays per-document (onDocumentPhase) and node-granular —
       // unchanged by the build-phase-pass registry, which is batch-granular. The
       // listener calls the `extendAst` seam directly (the document-phase analog of
@@ -174,6 +206,19 @@ export class BuildPipelineIntegration {
       }
    }
 
+   /**
+    * Drop the cached scopes of every REGISTERED language, not of those owning a
+    * document in the batch. The index a scope is built from is
+    * workspace-global, so narrowing to the batch with
+    * {@link groupDocumentsByLanguage}, the way {@link callIntegrity} does,
+    * leaves a cross-grammar reference resolving against a mid-rebuild scope.
+    */
+   protected clearScopeCaches(): void {
+      for (const languageServices of this.services.ServiceRegistry.all) {
+         languageServices.references.ScopeProvider.clearScopeCaches();
+      }
+   }
+
    /** Run AST enrichment for a single document at `phase` via its language service. */
    protected extendAst(document: LangiumDocument, phase: DocumentState, cancelToken: CancellationToken): void {
       this.services.ServiceRegistry.getServices(document.uri).ast.AstExtensionService.extendDocument(document, phase, cancelToken);

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

@@ -0,0 +1,87 @@
+/********************************************************************************
+ * 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 URI } from '@hydranium/langium';
+
+/** What a build is about, handed to `HydraniumDocumentBuilder.createBuildSession`. */
+export interface BuildSessionContext {
+   /**
+    * Which entry point opened the build: `'build'` is the workspace-wide pass
+    * (initialization), `'update'` an incremental rebuild. A subclass deriving
+    * cascade state skips the work for `'build'`, where every document is in the
+    * set already and `shouldRelink` is never consulted.
+    */
+   readonly kind: 'build' | 'update';
+   /** Formatted description of what caused the build — a URI, a count summary. */
+   readonly trigger: string;
+   /** True when {@link trigger} already states the document count. */
+   readonly triggerCountsDocs: boolean;
+   /** URIs the build was asked to rebuild, already flattened and canonicalized. */
+   readonly changed: readonly URI[];
+   /** URIs the build was asked to delete, already expanded by `collectDeletedURIs`. Empty for a `build` call. */
+   readonly deleted: readonly URI[];
+}
+
+/**
+ * One rebuild, treated as a correlated unit.
+ *
+ * Everything a build phase needs to know about the build it belongs to — what
+ * triggered it, when it started, whether it was cancelled, and the log lines it
+ * has produced so far. A `HydraniumDocumentBuilder` opens one per `update` /
+ * `build` call and holds it for the duration, so a per-phase hook can reach
+ * build-wide facts that no per-line formatting hook could.
+ *
+ * **Identity is the object, not {@link traceId}.** `Tracer.time` short-circuits
+ * when its log level is suppressed and never calls `captureId`, so `traceId` is
+ * `undefined` on every build in a production configuration that logs above
+ * `debug`. A teardown guard keyed on the id would then compare `undefined`
+ * against `undefined` and let a preempted build clear its successor's state.
+ * Reference equality against `HydraniumDocumentBuilder.activeSession` holds in
+ * both configurations, which is why nothing here is keyed on the id.
+ *
+ * Adopters carrying build-scoped state of their own subclass this and return it
+ * from `HydraniumDocumentBuilder.createBuildSession`, narrowing with an
+ * `instanceof` where they read it back. That buys them the framework's
+ * preemption-correct teardown rather than a second copy of it.
+ */
+export class BuildSession {
+   /**
+    * `Tracer.time` correlation id, so a phase line and the build line share a
+    * `#N`. `undefined` until the timer starts, and permanently `undefined` when
+    * the timing line is suppressed.
+    */
+   traceId?: number;
+   /** Set when the build ended in `OperationCancelled`, so the successor can tag itself "cancels #N". */
+   cancelled = false;
+   /** Phase-reached lines produced so far; the first one measures from {@link startMs} rather than from the previous phase. */
+   phasesLogged = 0;
+   /** Lines held back by {@link detailThresholdMs}; flushed or dropped when the build ends. */
+   readonly bufferedLines: string[] = [];
+
+   constructor(
+      /** Millisecond timestamp the build started at, on the same clock as `performance.now()`. */
+      readonly startMs: number,
+      /** What caused this build — a formatted URI, a count summary, or an adopter label. */
+      readonly trigger: string,
+      /** True when {@link trigger} already states the document count, so a phase line must not repeat it. */
+      readonly triggerCountsDocs: boolean,
+      /**
+       * Build duration at or above which the buffered lines are emitted; `0`
+       * disables buffering entirely. Captured per session so the flush decision
+       * uses the same value the buffering decision did, even if the underlying
+       * observable changed mid-build.
+       */
+      readonly detailThresholdMs: number
+   ) {}
+
+   /** True while lines are being held rather than emitted as they are produced. */
+   get buffers(): boolean {
+      return this.detailThresholdMs > 0;
+   }
+}

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

@@ -9,6 +9,7 @@
 
 import { type Clock, type LogThreshold, type MaybeObservableValue, ObservableValue, type Tracer } from '@hydranium/protocol';
 import {
+   type AstNode,
    type BuildOptions,
    DefaultDocumentBuilder,
    type DocumentPhaseListener,
@@ -20,12 +21,17 @@ import {
    interruptAndCheck,
    isOperationCancelled
 } from '@hydranium/langium';
-import { CancellationToken, type Diagnostic } from 'vscode-languageserver-protocol';
+// `Diagnostic` as a VALUE: `renderDiagnostics` needs its `getMessageString`
+// namespace helper to read the `string | MarkupContent` union without
+// restating it.
+import { CancellationToken, Diagnostic } from 'vscode-languageserver-protocol';
 import { type LogNameOptions } from '../diagnostics/logger.js';
+import type { MessageRenderer } from '../../messages/renderer.js';
 import { CST_REHYDRATION_RESET_STATE, isCstShed } from '../residency/cst-residency-service.js';
 import { type ExtendedServiceRegistry } from '../service-registry.js';
 import { type ServerSharedServicesMinimal } from '../shared-services.js';
 import { type DocumentUriPolicy } from '../workspace/document-uri-policy.js';
+import { BuildSession, type BuildSessionContext } from './build-session.js';
 import { type LabeledPhaseListener, labelPhaseListener } from './labeled-phase-listener.js';
 
 /** Document states a phase-reached line is emitted for by default — every built phase. */
@@ -38,6 +44,20 @@ export const DEFAULT_LOGGED_PHASES: DocumentState[] = [
    DocumentState.Validated
 ];
 
+/**
+ * The build reasons the framework stages through
+ * {@link HydraniumDocumentBuilder.markNextReason}: the LSP events the update
+ * handler dispatches on, and `didClose` for the revert the text store runs
+ * after a last close. Exposed so a subclass layering reasons of its own keeps
+ * the names the framework emits.
+ */
+export const HYDRANIUM_BUILD_REASONS = Object.freeze({
+   didOpen: 'didOpen',
+   didChangeContent: 'didChangeContent',
+   didChangeWatchedFiles: 'didChangeWatchedFiles',
+   didClose: 'didClose'
+} as const);
+
 /**
  * Consecutive re-queued builds that leave a waited-on document at the same state
  * before {@link HydraniumDocumentBuilder.awaitDocumentState} stops re-queuing it.
@@ -78,6 +98,18 @@ export interface DocumentBuilderOptions extends LogNameOptions {
     * logged. Default: `25`. Read per phase; accepts a {@link MaybeObservableValue}.
     */
    readonly slowBuildMs?: MaybeObservableValue<number>;
+   /**
+    * Build duration at or above which a build's phase-reached and slow-listener
+    * lines are emitted; they are held for the duration of the build and dropped
+    * when it finishes faster. Default `0` — no buffering, every line emitted as
+    * it is produced, which is the only setting that keeps lines interleaved with
+    * the rest of the log in real time.
+    *
+    * Set it to make a fast rebuild log nothing but its one build line. The
+    * decision needs the build's TOTAL duration, so it cannot be made by any
+    * per-line hook. Read once per build; accepts a {@link MaybeObservableValue}.
+    */
+   readonly phaseDetailMs?: MaybeObservableValue<number>;
    /**
     * Refresh cross-document `ComputedScopes` derivations when a referencing
     * document is cascade-rebuilt (see
@@ -105,15 +137,24 @@ export interface DocumentBuilderOptions extends LogNameOptions {
  * - **In-place rebuild helpers** — {@link reparse} and
  *   {@link reparseAndRelink} — for a build-phase listener that mutated a
  *   document's AST and must reconcile it within the same build.
- * - **Diagnostic dedupe** at `Validated` ({@link dedupeDiagnostics}).
+ * - **Diagnostic dedupe** at `Validated` ({@link dedupeDiagnostics}), followed
+ *   by the **one server-side message render** every head inherits
+ *   ({@link renderDiagnostics}).
+ * - **Build sessions** ({@link BuildSession}): each `update` / `build` call is
+ *   one correlated unit carrying an id, a trigger label, a start time and
+ *   cancellation lineage, so every line of a rebuild reads as belonging to it
+ *   and a preempted build is distinguishable from the winner.
  * - **Logging instrumentation** (default on, opt-out via `logLevel: 'off'`):
- *   phase-reached lines, slow-listener breakdowns on `notifyDocumentPhase`,
- *   and slow-build-phase totals on `notifyBuildPhase`.
+ *   a per-build line, phase-reached lines, slow-listener breakdowns on
+ *   `notifyDocumentPhase`, and slow-build-phase totals on `notifyBuildPhase`.
  *
  * Adopters extend this class — the configuration knobs cover what most
  * adopters need; the `format*Line` methods, `formatUri`, and
  * `collectDeletedURIs` are protected so subclasses can customise wording or
- * domain-aware cascades without re-implementing surrounding logic.
+ * domain-aware cascades without re-implementing surrounding logic. An adopter
+ * with build-scoped state of its own subclasses {@link BuildSession} and
+ * overrides {@link createBuildSession}, which puts that state under the same
+ * preemption-correct teardown rather than a reimplementation of it.
  */
 export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
    protected readonly tracer: Tracer;
@@ -127,8 +168,11 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
    protected readonly slowListenerMs: ObservableValue<number>;
    /** Live slow-build-phase-total threshold; read `.value` per phase. */
    protected readonly slowBuildMs: ObservableValue<number>;
+   /** Live phase-detail buffering threshold; read `.value` once per build, onto the session. */
+   protected readonly phaseDetailMs: ObservableValue<number>;
    protected readonly uriPolicy: DocumentUriPolicy;
    protected readonly clock: Clock;
+   protected readonly messageRenderer: MessageRenderer;
    /** Narrower handle on the same registry as the inherited `serviceRegistry`, for {@link ExtendedServiceRegistry.registrations}. */
    protected readonly languageRegistry: ExtendedServiceRegistry;
    protected languageFileExtensions: string[] = [];
@@ -139,18 +183,36 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
    protected readonly refreshCrossDocumentComputedScopes: boolean;
    /** LSP event name (e.g. `'didChangeWatchedFiles'`) staged for the next `update()` call. */
    protected pendingUpdateReason?: string;
+   /**
+    * The build currently in progress, or `undefined` between builds.
+    *
+    * A subclass carrying its own build-scoped state returns a {@link BuildSession}
+    * subclass from {@link createBuildSession} and narrows this with a typeguard
+    * where it reads that state — rather than redeclaring the field, whose
+    * initialiser would run after `super()` and clear a session opened during
+    * construction.
+    */
+   protected activeSession?: BuildSession;
+   /**
+    * `traceId` of the last build that ended in cancellation, for the successor's
+    * "cancels #N" tag. Held here rather than on a session because the session
+    * that carries it is already gone by the time its successor is opened.
+    */
+   protected lastCancelledTraceId?: number;
 
    constructor(services: ServerSharedServicesMinimal, options: DocumentBuilderOptions = {}) {
       super(services);
       this.languageRegistry = services.ServiceRegistry;
       this.uriPolicy = services.workspace.DocumentUriPolicy;
       this.clock = services.Clock;
+      this.messageRenderer = services.MessageRenderer;
       this.tracer = services.Tracer.for(options.logName ?? 'DocumentBuilder').trace('instantiated');
       this.logLevel = options.logLevel ?? 'debug';
       this.loggedPhases = options.loggedPhases ?? DEFAULT_LOGGED_PHASES;
       this.slowPhaseMs = ObservableValue.from(options.slowPhaseMs ?? 25);
       this.slowListenerMs = ObservableValue.from(options.slowListenerMs ?? 5);
       this.slowBuildMs = ObservableValue.from(options.slowBuildMs ?? 25);
+      this.phaseDetailMs = ObservableValue.from(options.phaseDetailMs ?? 0);
       this.refreshCrossDocumentComputedScopes = options.refreshCrossDocumentComputedScopes ?? false;
       if (this.logLevel !== 'off') {
          this.registerPhaseListeners();
@@ -163,8 +225,8 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
 
    /**
     * Stage an LSP event name for the next `update()` call. Adopters call before
-    * the update fires; `HydraniumDocumentUpdateHandler` does it for the
-    * four LSP events.
+    * the update fires; `HydraniumDocumentUpdateHandler` does it for the LSP
+    * events, and the text store for the revert that follows a last close.
     *
     * The framework stages the value and never reads it back. The consumer is a
     * subclass overriding the build logging, which takes
@@ -193,7 +255,16 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
       const doc = this.langiumDocuments.getDocument(UriUtils.toUri(this.uriPolicy.canonicalUri(uri)));
       const docState = doc ? DocumentState[doc.state] : 'unknown (document not loaded)';
       const lastPhase = this.lastPhaseMs > 0 ? `${Math.round(performance.now() - this.lastPhaseMs)}ms ago` : 'no phase observed';
-      return `current state: '${docState}', last phase: ${lastPhase}`;
+      return `current state: '${docState}', last phase: ${lastPhase}, active build: ${this.formatSession(this.activeSession)}`;
+   }
+
+   /** Render a session for a status line. `undefined` — no build in progress — reads as `none`. */
+   protected formatSession(session: BuildSession | undefined): string {
+      if (!session) {
+         return 'none';
+      }
+      const id = session.traceId !== undefined ? `#${session.traceId}` : 'untimed';
+      return `${id} (${session.trigger}, ${Math.round(performance.now() - session.startMs)}ms in)`;
    }
 
    // ============================================================
@@ -409,7 +480,35 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
       this.ensureLanguageFileExtensions();
       const changedURIs = changed.flatMap(uri => this.flattenAndAdaptURI(uri));
       const deletedURIs = deleted.flatMap(uri => this.collectDeletedURIs(uri));
-      return super.update(changedURIs, deletedURIs, cancelToken);
+      return this.runInSession(
+         {
+            kind: 'update',
+            trigger: this.buildTriggerLabel(changedURIs, deletedURIs),
+            triggerCountsDocs: changedURIs.length + deletedURIs.length !== 1,
+            changed: changedURIs,
+            deleted: deletedURIs
+         },
+         this.rebuildLabel(changedURIs, deletedURIs),
+         () => super.update(changedURIs, deletedURIs, cancelToken)
+      );
+   }
+
+   /**
+    * The workspace-initialization entry point, bracketed by a session like
+    * {@link update}. Langium's `update` reaches `buildDocuments` directly rather
+    * than through here, so the two never nest.
+    */
+   override build<T extends AstNode>(
+      documents: Array<LangiumDocument<T>>,
+      options?: BuildOptions,
+      cancelToken?: CancellationToken
+   ): Promise<void> {
+      const uris = documents.map(document => document.uri);
+      return this.runInSession(
+         { kind: 'build', trigger: `${documents.length} docs`, triggerCountsDocs: true, changed: uris, deleted: [] },
+         `Build documents (${documents.length} docs)`,
+         () => super.build(documents, options, cancelToken)
+      );
    }
 
    /**
@@ -615,6 +714,149 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
       ];
    }
 
+   // ============================================================
+   // Build sessions — one rebuild as a correlated unit
+   // ============================================================
+
+   /**
+    * Open a session, run `body` inside it, and close it — the bracket every
+    * line of a rebuild is emitted within.
+    *
+    * The session is installed **synchronously**, before the timed body runs, so
+    * that state a subclass computed in {@link createBuildSession} is already
+    * readable by the time Langium's `update` consults `shouldRelink`.
+    *
+    * Teardown is preemption-correct, which is the reason this is framework code
+    * rather than a recipe. Langium's write mutex cancels an in-flight build when
+    * a later one arrives, so two sessions overlap: the successor installs itself
+    * as {@link activeSession} while the predecessor is still unwinding, and the
+    * predecessor's `finally` runs LAST. Clearing unconditionally there would
+    * discard the winner's state mid-build. Only the session that is still
+    * current clears — and the check is reference equality on the session object,
+    * not on {@link BuildSession.traceId}, which is `undefined` for every build
+    * whenever the timing level is suppressed and would compare equal to itself
+    * across two different builds.
+    *
+    * Re-entrancy is not hypothetical even without an adopter: {@link
+    * requeueOrphaned} calls `update` from inside a wait, while a build may be
+    * running.
+    */
+   protected runInSession(context: BuildSessionContext, label: string, body: () => Promise<void>): Promise<void> {
+      // Read before installing the new session: the id being superseded belongs
+      // to the OUTGOING build, or — when the previous one already finished
+      // cancelled — to the id it parked for its successor.
+      const supersededId = this.activeSession?.traceId ?? this.lastCancelledTraceId;
+      this.lastCancelledTraceId = undefined;
+      const reason = this.pendingUpdateReason;
+      this.pendingUpdateReason = undefined;
+      const tags: string[] = [];
+      if (reason) {
+         tags.push(`event: ${reason}`);
+      }
+      if (supersededId !== undefined) {
+         tags.push(`cancels #${supersededId}`);
+      }
+
+      const session = this.createBuildSession(context);
+      this.activeSession = session;
+      // A phase's "since previous phase" must measure from the build's start,
+      // not from whenever the last build's final phase happened to land.
+      this.lastPhaseMs = session.startMs;
+      return this.tracer.time(
+         label,
+         async () => {
+            try {
+               await body();
+            } catch (err: unknown) {
+               if (isOperationCancelled(err)) {
+                  session.cancelled = true;
+               }
+               throw err;
+            } finally {
+               this.endSession(session);
+            }
+         },
+         this.logLevel,
+         {
+            logAfterMs: 0,
+            forceMemoryAboveMs: session.buffers ? session.detailThresholdMs : undefined,
+            captureId: id => {
+               session.traceId = id;
+            },
+            tags
+         }
+      );
+   }
+
+   /**
+    * Construct the session for one build. Override to return a
+    * {@link BuildSession} subclass carrying adopter build-scoped state — it is
+    * called before the build body, so anything derived here is readable
+    * throughout it.
+    */
+   protected createBuildSession(context: BuildSessionContext): BuildSession {
+      return new BuildSession(performance.now(), context.trigger, context.triggerCountsDocs, this.phaseDetailMs.value);
+   }
+
+   /**
+    * Close `session`: flush what it buffered, then release it if it is still the
+    * current one (see {@link runInSession} on why that check is conditional).
+    * The flush is unconditional — a preempted build's lines still describe work
+    * that happened.
+    */
+   protected endSession(session: BuildSession): void {
+      this.flushSession(session);
+      if (this.activeSession === session) {
+         this.activeSession = undefined;
+         if (session.cancelled) {
+            this.lastCancelledTraceId = session.traceId;
+         }
+      }
+   }
+
+   /**
+    * Emit the lines `session` held back, if it ran long enough to be worth the
+    * detail; drop them otherwise. Emits through {@link emit} rather than
+    * {@link log}, which would route them straight back into the buffer.
+    */
+   protected flushSession(session: BuildSession): void {
+      const elapsedMs = performance.now() - session.startMs;
+      if (elapsedMs >= session.detailThresholdMs) {
+         for (const line of session.bufferedLines) {
+            this.emit(line);
+         }
+      }
+      session.bufferedLines.length = 0;
+   }
+
+   /** Label for the build's own log line. Override to customise wording. */
+   protected rebuildLabel(changed: URI[], deleted: URI[]): string {
+      if (changed.length === 0 && deleted.length === 0) {
+         return 'Rebuild documents (nothing to do)';
+      }
+      if (changed.length === 1 && deleted.length === 0) {
+         return `Rebuild document: ${this.formatUri(changed[0])}`;
+      }
+      if (changed.length === 0 && deleted.length === 1) {
+         return `Rebuild after delete: ${this.formatUri(deleted[0])}`;
+      }
+      return `Rebuild documents (${changed.length} changed, ${deleted.length} deleted)`;
+   }
+
+   /** Short description of what triggered the build, repeated on every phase line. Override to customise wording. */
+   protected buildTriggerLabel(changed: URI[], deleted: URI[]): string {
+      if (changed.length === 0 && deleted.length === 0) {
+         return 'nothing';
+      }
+      if (changed.length === 1 && deleted.length === 0) {
+         return this.formatUri(changed[0]);
+      }
+      if (changed.length === 0 && deleted.length === 1) {
+         return `deleted ${this.formatUri(deleted[0])}`;
+      }
+      return `${changed.length} changed, ${deleted.length} deleted`;
+   }
+
    // ============================================================
    // Logging — phase-reached listeners
    // ============================================================
@@ -630,13 +872,35 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
       const now = performance.now();
       const elapsedMs = Math.round(now - this.lastPhaseMs);
       this.lastPhaseMs = now;
+      // Counted before the line is formatted, so the formatter stays a pure
+      // function of state a caller can also set up in a test.
+      if (this.activeSession) {
+         this.activeSession.phasesLogged++;
+      }
       this.log(this.phaseReachedLine(state, documents, elapsedMs));
    }
 
-   /** Format the phase-reached log line. Override to customise wording. */
+   /**
+    * Format the phase-reached log line. Override to customise wording.
+    *
+    * Within a session the line names what triggered the build, so a phase read
+    * in isolation still says which rebuild it belongs to. `elapsedMs` is ignored
+    * for the FIRST phase of a session: it measures from the previous build's
+    * last phase, an idle gap that says nothing about this build.
+    */
    protected phaseReachedLine(state: DocumentState, documents: LangiumDocument[], elapsedMs: number): string {
-      const docInfo = documents.length === 1 ? this.formatUri(documents[0].uri) : `${documents.length} docs`;
-      return `Reached phase '${DocumentState[state]}' [${docInfo}, ${elapsedMs}ms since previous phase]`;
+      const session = this.activeSession;
+      let docInfo: string;
+      if (session) {
+         docInfo = session.triggerCountsDocs ? `building ${session.trigger}` : `building ${session.trigger}, ${documents.length} docs`;
+      } else {
+         docInfo = documents.length === 1 ? this.formatUri(documents[0].uri) : `${documents.length} docs`;
+      }
+      const elapsedInfo =
+         session && session.phasesLogged <= 1
+            ? `${Math.round(performance.now() - session.startMs)}ms since build start`
+            : `${elapsedMs}ms since previous phase`;
+      return `Reached phase '${DocumentState[state]}' [${docInfo}, ${elapsedInfo}]`;
    }
 
    // ============================================================
@@ -651,8 +915,12 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
       // build settling inside that window therefore appends after this call has
       // already deduped, and the appended duplicate is published by the listener
       // of the build that deduped. Only `serializeBuilds` closes the window.
+      //
+      // Dedupe before rendering: rendering is deterministic, so it cannot
+      // change which entries are structurally equal, and fewer survive to render.
       if (state === DocumentState.Validated) {
          this.dedupeDiagnostics(document);
+         this.renderDiagnostics(document);
       }
       if (this.logLevel === 'off') {
          return super.notifyDocumentPhase(document, state, cancelToken);
@@ -828,12 +1096,86 @@ export class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
       }
    }
 
+   /**
+    * Render every diagnostic on `document` through the bound message renderer,
+    * in ONE pass over the finished list.
+    *
+    * All three heads read `document.diagnostics` — the LSP publish,
+    * `TransferEncoder.toTransferDiagnostic` and the GLSP validation path — so
+    * one pass here is what keeps the render from happening per head. It is also
+    * the only placement that covers lexer and parser errors, which Langium
+    * pushes onto the document without routing them through `toDiagnostic`.
+    *
+    * Running here rather than from a `Validated` phase listener needs no
+    * ordering assumption: Langium publishes from `addDiagnosticsHandler`, a free
+    * function it registers as such a listener, which can only be outrun.
+    *
+    * **It inherits {@link dedupeDiagnostics}'s window, and therefore the same
+    * precondition.** A build settling inside the listener window appends
+    * diagnostics this pass never saw, and the publisher of the build that
+    * rendered sends them — unrendered. `ModelServiceOptions.serializeBuilds`
+    * closes it and defaults to `true`, so "every diagnostic is rendered" holds
+    * by default and is an opt-out rather than a guarantee. Opting out accepts
+    * unrendered diagnostics on exactly the terms it already accepts duplicates.
+    *
+    * Entries are REPLACED rather than mutated: `sendDiagnostics` passes the
+    * array by reference and serialises later, so an in-place message mutation
+    * reaches the wire even when it runs after the publisher — which would make
+    * a test for the ordering pass in either state.
+    */
+   protected renderDiagnostics(document: LangiumDocument): void {
+      const diagnostics = document.diagnostics;
+      if (!diagnostics || diagnostics.length === 0) {
+         return;
+      }
+      let changed = false;
+      // No try/catch: `renderDiagnostic` carries a no-throw contract, because an
+      // error escaping this phase strands the document at `Validated` with
+      // Langium's publisher never invoked.
+      const rendered = diagnostics.map(diagnostic => {
+         const text = this.messageRenderer.renderDiagnostic(diagnostic);
+         // Against the message's STRING FORM, not the field. `renderDiagnostic`
+         // answers a `string` by contract, while `Diagnostic.message` is
+         // `string | MarkupContent` since LSP 3.17 — so comparing the answer
+         // against the field never matches for a markup message, and a pass
+         // that replaced on mismatch flattened every un-identified markup
+         // diagnostic to its own plain text. That is silent data loss on the
+         // path whose whole job is to leave such entries alone.
+         if (text === Diagnostic.getMessageString(diagnostic)) {
+            return diagnostic;
+         }
+         changed = true;
+         return { ...diagnostic, message: text };
+      });
+      if (changed) {
+         document.diagnostics = rendered;
+      }
+   }
+
    // ============================================================
    // Internal helpers
    // ============================================================
 
-   /** Dispatch a log line at the configured log level; a no-op when `logLevel === 'off'`. */
+   /**
+    * Dispatch a log line at the configured log level; a no-op when `logLevel ===
+    * 'off'`.
+    *
+    * Held on the active session when it buffers, so the "was this build worth a
+    * per-phase breakdown" decision — which needs the build's total duration, and
+    * so cannot be taken by anything that runs while the lines are produced — is
+    * deferred to {@link flushSession}.
+    */
    protected log(message: string): void {
+      const session = this.activeSession;
+      if (session?.buffers) {
+         session.bufferedLines.push(message);
+         return;
+      }
+      this.emit(message);
+   }
+
+   /** Write a line out, bypassing session buffering. The single sink every framework log line reaches. */
+   protected emit(message: string): void {
       this.tracer.logAt(this.logLevel, message);
    }
 }