@hydranium/core 1.0.0-next.8 → 1.0.0-next.86

package/src/langium/ast-extension/ast-node-builder.ts

@@ -78,15 +78,13 @@ export type AstNodeBuilder<TMap> = <TType extends string & keyof TMap>(
  * AST-interface mapping, so call sites get full inference from the type
  * constant alone — no explicit generic parameter at every call site.
  *
- * Runtime behaviour: reads `reflection.getTypeMetaData(type).properties` and,
- * for every property whose metadata carries a `defaultValue`, pre-fills the
- * result before merging the caller's `init`. Array defaults are materialised
- * as a fresh `[]` per call (never shared with the metadata's array instance,
- * which downstream callers mutate); scalar defaults (`false`, `0`, `''`, …)
- * are copied as-is since they're immutable. Grammar-generated containment
- * lists and `?=`-style boolean flags therefore default automatically;
- * TS-augmented fields (declared via `declare module './generated/ast.js'`)
- * are unaffected by the runtime defaulting but remain typed at call sites.
+ * Runtime behaviour: pre-fills every grammar-declared default (see
+ * {@link withTypeDefaults}) before merging the caller's `init`, so containment
+ * lists and `?=`-style boolean flags default automatically. TS-augmented fields
+ * (declared via `declare module './generated/ast.js'`) are unaffected by the
+ * runtime defaulting but remain typed at call sites.
+ *
+ * Use {@link buildAstNode} instead when the type name is only known at runtime.
  *
  * The init shape only relaxes array-typed fields to optional (via
  * {@link ArrayKeys}) — there is no equivalent structural signal for "this
@@ -101,19 +99,7 @@ export function makeAstNodeBuilder<TMap>(reflection: AstReflection): AstNodeBuil
       init: AstNodeInit<Extract<TMap[TType], AstNode>>,
       extras?: Record<string, unknown>
    ): Extract<TMap[TType], AstNode> {
-      const meta = reflection.getTypeMetaData(typeConstant.$type);
-      const result: Record<string, unknown> = { $type: typeConstant.$type };
-      if (meta?.properties) {
-         for (const [propName, propInfo] of Object.entries(meta.properties)) {
-            const defaultValue = propInfo.defaultValue;
-            if (defaultValue === undefined) {
-               continue;
-            }
-            // Arrays are duplicated so each node carries its own mutable instance;
-            // scalars are immutable and safe to copy by reference.
-            result[propName] = Array.isArray(defaultValue) ? [...defaultValue] : defaultValue;
-         }
-      }
+      const result = withTypeDefaults(reflection, typeConstant.$type);
       Object.assign(result, init);
       if (extras) {
          // Extras win over init: this is the explicit escape hatch, so when a
@@ -123,3 +109,61 @@ export function makeAstNodeBuilder<TMap>(reflection: AstReflection): AstNodeBuil
       return result as unknown as Extract<TMap[TType], AstNode>;
    };
 }
+
+/**
+ * Build a node whose type is only known as a RUNTIME string.
+ *
+ * The typed {@link makeAstNodeBuilder} cannot express this: its `TMap` generic
+ * resolves the AST interface from a `$type` literal, and a type name that
+ * arrives over the wire — a protocol-layer reference request naming a node that
+ * does not exist yet — has no literal to resolve from. Callers that DO know the
+ * type at compile time want the typed builder, which checks their mandatory
+ * fields; this one checks nothing beyond the reflection lookup.
+ *
+ * Applies the same reflection-driven defaulting, so a node built here carries
+ * grammar-declared containment arrays rather than leaving them `undefined`. An
+ * unknown type name yields a node with `$type` and whatever `init` supplied,
+ * because reflection answers no metadata for it and refusing would turn a
+ * permissive lookup into a throw at a call site that can only guess.
+ *
+ * **The `type` argument is authoritative: `init` cannot rebind `$type`.** The
+ * typed builder gets this for free — `AstNodeInit` omits `$type`, so a call site
+ * cannot reach it — but here `init` is loosely typed, and the case that needs
+ * the guarantee is RETYPING: a caller spreading an existing node to produce one
+ * of a different type (`{ ...source }`) carries the SOURCE's `$type` in, which
+ * would silently win over the type actually requested and hand back a node of
+ * the wrong type with no error anywhere.
+ */
+export function buildAstNode<TAst extends AstNode = AstNode>(
+   reflection: AstReflection,
+   type: string,
+   init?: Partial<AstNode> & Record<string, unknown>
+): TAst {
+   const result = withTypeDefaults(reflection, type);
+   if (init) {
+      Object.assign(result, init);
+      result.$type = type;
+   }
+   return result as unknown as TAst;
+}
+
+/**
+ * Seed a node with `$type` plus every property the grammar declares a default
+ * for. Array defaults are materialised as a fresh `[]` per call — never shared
+ * with the metadata's own array instance, which downstream callers mutate —
+ * while scalar defaults are copied as-is since they are immutable.
+ */
+function withTypeDefaults(reflection: AstReflection, type: string): Record<string, unknown> {
+   const result: Record<string, unknown> = { $type: type };
+   const meta = reflection.getTypeMetaData(type);
+   if (meta?.properties) {
+      for (const [propName, propInfo] of Object.entries(meta.properties)) {
+         const defaultValue = propInfo.defaultValue;
+         if (defaultValue === undefined) {
+            continue;
+         }
+         result[propName] = Array.isArray(defaultValue) ? [...defaultValue] : defaultValue;
+      }
+   }
+   return result;
+}

package/src/langium/bootstrap.ts

@@ -12,15 +12,15 @@ import { type LangiumSharedCoreServices } from '@hydranium/langium';
 import { type LangiumServices, type LangiumSharedServices } from '@hydranium/langium/lsp';
 import type { ServerSharedServicesMinimal } from './shared-services.js';
 import { collectProducibleTypes } from './language-types.js';
-import { AstDocumentManager } from '../documents/ast-document-manager.js';
+import { DefaultAstDocumentManager } from '../documents/ast-document-manager.js';
 import { HydraniumTextDocuments } from '../documents/hydranium-text-documents.js';
-import { BuildPipelineIntegration } from './document-builder/build-pipeline-integration.js';
+import { DefaultBuildPipelineIntegration } from './document-builder/build-pipeline-integration.js';
 import { HydraniumDocumentBuilder } from './document-builder/document-builder.js';
-import { ModelService } from './model-service/model-service.js';
+import { DefaultModelService } from './model-service/model-service.js';
 import { HydraniumScopeComputation } from './scope/hydranium-scope-computation.js';
 import { HydraniumScopeProvider } from './scope/hydranium-scope-provider.js';
 import { processEnv } from '../util/environment.js';
-import { TransferEncoder } from './transfer/transfer-encoder.js';
+import { DefaultTransferEncoder } from './transfer/transfer-encoder.js';
 import { HydraniumWorkspaceManager } from './workspace/hydranium-workspace-manager.js';
 
 /**
@@ -73,7 +73,14 @@ const EXPECTED_SHARED_SLOTS: readonly ExpectedSlot[] = [
       side: 'shared',
       path: 'workspace.BuildPipelineIntegration',
       get: services => nested(services, 'workspace', 'BuildPipelineIntegration')
-   }
+   },
+   // Unbound, this fails where the cause is least visible: the render pass runs
+   // inside the `Validated` phase, so a `TypeError` there propagates out of
+   // `notifyDocumentPhase` and the document reaches `Validated` with Langium's
+   // publisher never invoked — the client receives no diagnostics for the file
+   // and the stack names the document builder.
+   { side: 'shared', path: 'MessageRenderer', get: services => nested(services, 'MessageRenderer') },
+   { side: 'shared', path: 'ServerLocale', get: services => nested(services, 'ServerLocale') }
 ];
 
 /**
@@ -199,17 +206,17 @@ const STRICT_SHARED_SLOTS: readonly StrictSlot[] = [
    {
       side: 'shared',
       path: 'workspace.AstDocumentManager',
-      base: AstDocumentManager,
+      base: DefaultAstDocumentManager,
       get: s => nested(s, 'workspace', 'AstDocumentManager')
    },
    {
       side: 'shared',
       path: 'workspace.BuildPipelineIntegration',
-      base: BuildPipelineIntegration,
+      base: DefaultBuildPipelineIntegration,
       get: s => nested(s, 'workspace', 'BuildPipelineIntegration')
    },
-   { side: 'shared', path: 'model.TransferEncoder', base: TransferEncoder, get: s => nested(s, 'model', 'TransferEncoder') },
-   { side: 'shared', path: 'model.ModelService', base: ModelService, get: s => nested(s, 'model', 'ModelService') }
+   { side: 'shared', path: 'model.TransferEncoder', base: DefaultTransferEncoder, get: s => nested(s, 'model', 'TransferEncoder') },
+   { side: 'shared', path: 'model.ModelService', base: DefaultModelService, get: s => nested(s, 'model', 'ModelService') }
 ];
 
 const STRICT_LANGUAGE_SLOTS: readonly StrictSlot[] = [

package/src/langium/config/configuration-provider.ts

@@ -0,0 +1,119 @@
+/********************************************************************************
+ * Copyright (c) 2026 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 ConfigurationInitializedParams, DefaultConfigurationProvider } from '@hydranium/langium';
+import type { ConfigurationItem, DidChangeConfigurationRegistrationOptions } from 'vscode-languageserver';
+
+/**
+ * Configuration provider that asks the client about a section the first time
+ * something reads it.
+ *
+ * Langium's base requests one section per registered language, named after the
+ * language id, and never asks again. A read of any other section — including
+ * whatever `lsp.configurationRoot` is bound to — then resolves `undefined` with
+ * no request on the wire, which is indistinguishable from a setting the user has
+ * not set.
+ *
+ * Asking on first read rather than from a list collected up front: a reader
+ * names its section during DI, after `initialized` has taken its one-shot pass,
+ * so a list would have to be complete before the server initialized.
+ */
+export class HydraniumConfigurationProvider extends DefaultConfigurationProvider {
+   /**
+    * The client-facing hooks, captured because they arrive once as arguments to
+    * {@link initialized} and are needed on every later read. Absent in a
+    * headless composition, which has no connection to ask.
+    */
+   protected registerForSection?: (params: DidChangeConfigurationRegistrationOptions) => void;
+   protected fetchSections?: (items: ConfigurationItem[]) => Promise<unknown>;
+
+   /**
+    * Sections already dealt with, holding the in-flight work so concurrent
+    * readers share one round trip. Entries stay after they settle: they record
+    * that the section was HANDLED, and without that an unset section is
+    * re-requested on every read, "unset" and "not fetched" being the same
+    * absence in the store.
+    *
+    * A section the client's capabilities ruled out counts as handled, having
+    * been settled by asking nothing.
+    */
+   protected readonly requestedSections = new Map<string, Promise<void>>();
+
+   override async initialized(params: ConfigurationInitializedParams): Promise<void> {
+      this.registerForSection = params.register;
+      this.fetchSections = params.fetchConfiguration;
+      await super.initialized(params);
+   }
+
+   /**
+    * The `ready` await precedes the emptiness check: the base resolves it at the
+    * end of its own initial fetch, so testing the store first calls every
+    * language section missing and re-requests what is already on its way.
+    */
+   override async getConfiguration(language: string, configuration: string): Promise<unknown> {
+      await this.ready;
+      const section = this.toSectionName(language);
+      if (this.settings[section] === undefined) {
+         await this.requestSection(section);
+      }
+      return super.getConfiguration(language, configuration);
+   }
+
+   /** Ask about `section` once, sharing the request with any concurrent reader. */
+   protected requestSection(section: string): Promise<void> {
+      const existing = this.requestedSections.get(section);
+      if (existing) {
+         return existing;
+      }
+      const request = this.doRequestSection(section);
+      this.requestedSections.set(section, request);
+      return request;
+   }
+
+   /**
+    * The hooks are gated on the client having declared `workspace.configuration`.
+    * A connection binds them whatever the client said, so their presence is not
+    * consent: calling them sends a `client/registerCapability` and a
+    * `workspace/configuration` to a client that advertised support for neither,
+    * which is entitled to answer either with a method-not-found and may drop the
+    * connection.
+    *
+    * That flag is exact for the fetch and KNOWINGLY coarse for the registration,
+    * which the spec governs by
+    * `workspace.didChangeConfiguration.dynamicRegistration`. The base registers
+    * under `workspace.configuration` alone before any of this runs, so gating
+    * the registration on the narrower flag here would withhold a request whose
+    * twin has already gone out, sparing the client nothing. A client declaring
+    * `workspace.configuration` without dynamic registration is still registered
+    * for, by the base and by this; closing that means changing the base's pass,
+    * not this gate.
+    *
+    * Registering before fetching, so an edit landing between the two arrives as
+    * a notification instead of being lost; the reverse order drops it.
+    *
+    * A `null` result is left out of the store rather than written, so the
+    * section reads as unset, and no `onConfigurationSectionUpdate` fires — the
+    * value goes to the caller that asked for it, and an event would announce a
+    * change that is only this provider catching up.
+    */
+   protected async doRequestSection(section: string): Promise<void> {
+      if (!this.workspaceConfig) {
+         return;
+      }
+      this.registerForSection?.({ section });
+      if (!this.fetchSections) {
+         return;
+      }
+      const fetched = await this.fetchSections([{ section }]);
+      const value = Array.isArray(fetched) ? fetched[0] : fetched;
+      if (value !== null && value !== undefined) {
+         this.updateSectionConfiguration(section, value);
+      }
+   }
+}

package/src/langium/config/index.ts

@@ -7,4 +7,5 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
+export * from './configuration-provider.js';
 export * from './settings.js';

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

@@ -92,14 +92,17 @@ export class LspLogger extends AbstractLogger implements Logger {
          // a Node concern; skip it cleanly there.
          const env = processEnv();
          if (env) {
-            const envLevel = parseLogLevel(env[DEFAULT_LOG_LEVEL_ENV]);
-            if (envLevel) {
-               Logger.setLevel(envLevel);
-            }
+            // The file-tee target FIRST: the other order writes the level
+            // announcement before the sink exists, losing the one line that says
+            // which threshold the rest of the file was written at.
             const envLogFile = env[DEFAULT_LOG_FILE_ENV];
             if (envLogFile) {
                setLogFilePath(envLogFile);
             }
+            const envLevel = parseLogLevel(env[DEFAULT_LOG_LEVEL_ENV]);
+            if (envLevel) {
+               this.applyLevel(envLevel, DEFAULT_LOG_LEVEL_ENV);
+            }
          }
       }
       // Apply the configured threshold from the root logger only — `derive`
@@ -109,16 +112,48 @@ export class LspLogger extends AbstractLogger implements Logger {
       if (options.logThreshold !== undefined) {
          const level = ObservableValue.from(options.logThreshold);
          if (level.value) {
-            Logger.setLevel(level.value);
+            this.applyLevel(level.value, 'setting');
          }
          level.onChange(next => {
             if (next) {
-               Logger.setLevel(next);
+               this.applyLevel(next, 'setting');
             }
          });
       }
    }
 
+   /**
+    * Set the process-wide threshold and announce the transition under whichever
+    * of the two thresholds can carry the notice, so a reader sees every change
+    * and its absence means the threshold never moved.
+    *
+    * `error` and `off` admit no notice of their own — `off` nothing at all, and
+    * an error-severity line is read as a fault, which a client that marks its
+    * log as having seen an error keeps for the session. Entering either is
+    * therefore announced BEFORE the switch, under the outgoing threshold; every
+    * other change is announced after it, at the level being entered. Leaving
+    * `error` or `off` for one of those two says nothing, both thresholds being
+    * unable to carry it.
+    *
+    * Only on a real transition: the bound setting re-fires for configuration
+    * changes that leave the value alone.
+    */
+   protected applyLevel(next: LogThreshold, source: string): void {
+      const previous = Logger.getLevel();
+      if (previous === next) {
+         return;
+      }
+      const message = `Log level ${previous} → ${next} (${source})`;
+      const announceFirst = next === 'error' || next === 'off';
+      if (announceFirst && previous !== 'error') {
+         this.logAt(previous, message);
+      }
+      Logger.setLevel(next);
+      if (!announceFirst) {
+         this.logAt(next, message);
+      }
+   }
+
    /**
     * Route logger timing and timestamps through the injected framework
     * {@link Clock} (the dedicated `shared.Clock` slot) so server-side log time

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

@@ -65,6 +65,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 +103,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 = {}

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;
+   }
+}