@hydranium/core 1.0.0-next.19 → 1.0.0-next.193

package/src/documents/index.ts

@@ -8,7 +8,12 @@
  ********************************************************************************/
 
 export * from './client-ids.js';
+export * from './client-session-errors.js';
+export * from './client-session-registry.js';
 export * from './language-client-text-shadow.js';
 export * from './hydranium-text-documents.js';
+export * from './model-ledger.js';
+export * from './version-sync-service.js';
 export * from './ast-document-manager.js';
 export * from './self-save-registry.js';
+export * from './file-system-task-queue.js';

package/src/documents/language-client-text-shadow.ts

@@ -57,12 +57,23 @@ export function isFullReplace(edits: readonly TextEdit[]): boolean {
  *  - {@link computeEdits} after each outgoing server→client sync (updates the shadow optimistically).
  *  - {@link set} when the server receives a `didChange` from the language client (the client now
  *    holds that text; we shouldn't resend it).
+ *  - {@link setOpenedText} when the client opens a document the server did not baseline for it —
+ *    an equality-only baseline, since that text is a snapshot rather than a tracked one.
  *  - {@link invalidate} when the client rejects an edit (`applied=false`) or a doc is closed —
  *    the shadow is now stale and the next sync must fall back to a full replace.
  */
 export class LanguageClientTextShadow {
    protected shadow = new Map<string, string>();
 
+   /**
+    * Per URI, the text the client declared it opened the document with, held
+    * only until a real baseline exists. Consulted by {@link computeEdits} when
+    * there is no shadow, and dropped on {@link invalidate}: a snapshot that
+    * outlived what the client holds would let the equality check skip an edit
+    * the client still needs.
+    */
+   protected opened = new Map<string, string>();
+
    /**
     * @param onFallback invoked when {@link computeEdits} falls back to a full-range replace due to
     *    apply-verify mismatch. Useful for logging regressions.
@@ -85,23 +96,54 @@ export class LanguageClientTextShadow {
    }
 
    /**
-    * The text the language client is believed to hold, or `undefined` when
-    * there is no baseline (first sync, or after an {@link invalidate}).
+    * Record the buffer the language client declared at `didOpen`, for a URI
+    * with no baseline yet.
+    *
+    * Deliberately NOT a {@link set}: this text is only ever compared for
+    * EQUALITY, never diffed against. A line-keyed diff is position-dependent,
+    * so keying one to a `didOpen` snapshot the client may have moved past
+    * splices its buffer — the failure {@link computeEdits}'s full-replace
+    * fallback exists to avoid.
+    */
+   setOpenedText(uri: string, text: string): void {
+      this.opened.set(uri, text);
+   }
+
+   /**
+    * The text the language client is believed to hold: the tracked text, else
+    * the buffer it declared at `didOpen`.
     *
     * Read at the `workspace/applyEdit` egress BEFORE {@link computeEdits},
-    * which overwrites it: a push's minimal edits are keyed to this text, so an
-    * echo of that push carries ranges addressing it and nothing else. Losing
-    * it is what makes an incremental echo unreconstructable, and applying such
-    * an echo to the already-advanced synced text duplicates every inserted
-    * line.
+    * which overwrites the tracked text and drops the opened snapshot. A change
+    * the client sends carries ranges addressing this text and nothing else, so
+    * losing it leaves that change unreconstructable — and applying its ranges
+    * to the already-advanced synced text splices lines they never addressed.
+    *
+    * Deliberately wider than what {@link computeEdits} may diff from: an
+    * opened snapshot is a position-dependent key to a buffer the client may
+    * have moved past, so keying a diff to it splices that buffer.
     */
-   get(uri: string): string | undefined {
-      return this.shadow.get(uri);
+   clientText(uri: string): string | undefined {
+      return this.shadow.get(uri) ?? this.opened.get(uri);
+   }
+
+   /**
+    * Whether a tracked text exists for `uri`, which is what decides whether a
+    * push can be diffed at all. Distinct from {@link clientText}, which also
+    * answers from the opened snapshot and so cannot settle this.
+    */
+   isTracked(uri: string): boolean {
+      return this.shadow.has(uri);
    }
 
    /** Forget the shadow for a URI; next {@link computeEdits} falls back to a full-document replace. */
    invalidate(uri: string): void {
       this.shadow.delete(uri);
+      // Drops the opened snapshot too, and this is the only place that has to:
+      // `computeEdits` clears it whenever it consults it, so the sole way it can
+      // outlive what the client holds is surviving under a live shadow until that
+      // shadow is dropped here.
+      this.opened.delete(uri);
    }
 
    /**
@@ -109,7 +151,9 @@ export class LanguageClientTextShadow {
     * the tracked shadow to `newText`. Updates the shadow to `newText` so subsequent calls diff
     * against it.
     *
-    *  - Empty array when the shadow already equals `newText` (caller should skip the RPC).
+    *  - Empty array when the shadow already equals `newText` (caller should skip the RPC),
+    *    or when there is no shadow and the client opened the document with exactly `newText`
+    *    (see {@link setOpenedText}) — pushing it anyway dirties the client's buffer on open.
     *  - Full-range replace when there is no shadow (first sync or post-{@link invalidate}).
     *  - Line-level diff otherwise. Before returning, we locally reconstruct `newText` by applying
     *    the diff to `old`; if that doesn't match, we fall back to a full-range replace and notify
@@ -124,7 +168,11 @@ export class LanguageClientTextShadow {
       this.shadow.set(uri, newText);
       const fullReplace: TextEdit = { range: FULL_RANGE, newText };
       if (old === undefined) {
-         return [fullReplace];
+         // The opened snapshot has served its purpose either way: the shadow above
+         // is now the baseline, so leaving it would only risk a later stale match.
+         const openedText = this.opened.get(uri);
+         this.opened.delete(uri);
+         return openedText === newText ? [] : [fullReplace];
       }
       const edits = diffToEdits(old, newText);
       const verifyDoc = this.documents.create(uri, 'plaintext', 0, old);

package/src/documents/model-ledger.ts

@@ -0,0 +1,66 @@
+/********************************************************************************
+ * 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 AstNode } from '@hydranium/langium';
+import { asModelVersion, type ModelVersion, UNRECORDED_VERSION } from '@hydranium/protocol';
+
+/** What {@link ModelLedger} holds for one root. */
+export interface ModelRecord {
+   readonly version: ModelVersion;
+   /** For a root whose CST no longer is the text it describes: changed in place, or shed. */
+   readonly text?: string;
+}
+
+/**
+ * The version of the text each root was parsed from, and that text where the
+ * root's CST does not hold it. Stores what it is told; the rest of the
+ * framework relies on these:
+ *
+ * - every workspace root is recorded through `VersionSyncService.modelProduced` when produced;
+ * - a version is recorded only for text the store held at that version, else `STALE_VERSION`;
+ * - the builder's placeholder for a file it has not parsed carries no version;
+ * - re-recording a root without text keeps the text recorded before.
+ */
+export interface ModelLedger {
+   record(root: AstNode, version: number, text?: string): void;
+   /** `UNRECORDED_VERSION`, which every write conflicts with, for a root nothing recorded. */
+   versionOf(root: AstNode): ModelVersion;
+   /** The recorded text, else the root's CST text; `undefined` for a root with neither. */
+   textOf(root: AstNode): string | undefined;
+   /** Mark `root`, registered before any parse, as no parse of any text, dropping its record. */
+   markPlaceholder(root: AstNode): void;
+   /** Keyed on the root, not its state: a rebuilt document is reset below `Parsed` but keeps its root. */
+   isPlaceholder(root: AstNode): boolean;
+}
+
+export class DefaultModelLedger implements ModelLedger {
+   protected readonly records = new WeakMap<AstNode, ModelRecord>();
+   protected readonly placeholders = new WeakSet<AstNode>();
+
+   record(root: AstNode, version: number, text?: string): void {
+      this.records.set(root, { version: asModelVersion(version), text: text ?? this.records.get(root)?.text });
+   }
+
+   versionOf(root: AstNode): ModelVersion {
+      return this.records.get(root)?.version ?? UNRECORDED_VERSION;
+   }
+
+   textOf(root: AstNode): string | undefined {
+      return this.records.get(root)?.text ?? root.$cstNode?.root.fullText;
+   }
+
+   markPlaceholder(root: AstNode): void {
+      this.placeholders.add(root);
+      this.records.delete(root);
+   }
+
+   isPlaceholder(root: AstNode): boolean {
+      return this.placeholders.has(root);
+   }
+}

package/src/documents/self-save-registry.ts

@@ -22,10 +22,32 @@ export interface SelfSaveRegistryOptions {
 /**
  * Tracks `mtime` of files written by the server itself so the echo
  * `didChangeWatchedFiles` event from the OS file watcher can be suppressed,
- * avoiding redundant rebuilds after each save. Entries are matched by mtime
- * (not by a time window) and expire after a TTL.
+ * avoiding redundant rebuilds after each save.
  */
-export class SelfSaveRegistry {
+export interface SelfSaveRegistry {
+   /**
+    * Record a self-write, and drop any registration already past its TTL.
+    *
+    * Keyed by `fsPath` rather than URI string, because the two sides of a
+    * suppression see different URI forms for one file.
+    */
+   register(fsPath: string, mtimeMs: number): void;
+
+   /**
+    * Whether `fsPath` carries a live registration at exactly `mtimeMs`.
+    *
+    * A registration expires after the TTL, so a write recorded longer ago than
+    * that answers `false` — the caller's decision holds only while the echo it
+    * suppresses could still be in flight. A query never mutates the registry.
+    */
+   isRegistered(fsPath: string, mtimeMs: number): boolean;
+}
+
+/**
+ * Compares entries by mtime rather than by a time window, so the echo of a
+ * save whose content is unchanged is still recognised.
+ */
+export class DefaultSelfSaveRegistry implements SelfSaveRegistry {
    protected readonly entries = new Map<string, { mtimeMs: number; registeredAt: number }>();
    /**
     * Read time through the shared {@link Clock} rather than `Date.now()`: the
@@ -59,23 +81,40 @@ export class SelfSaveRegistry {
       return isCaseInsensitiveFileSystem() ? fsPath.toLowerCase() : fsPath;
    }
 
-   /** Record a self-write. Key by `fsPath` (not URI string) to avoid URI-form mismatches. */
    register(fsPath: string, mtimeMs: number): void {
+      this.evictExpired();
       this.entries.set(this.key(fsPath), { mtimeMs, registeredAt: this.clock.now() });
    }
 
-   /** True if `mtimeMs` matches a recent self-write. Evicts stale entries. Not consumed on match. */
-   matches(fsPath: string, mtimeMs: number): boolean {
-      const key = this.key(fsPath);
-      const entry = this.entries.get(key);
-      if (!entry) {
-         return false;
-      }
-      if (this.clock.now() - entry.registeredAt > this.ttlMs) {
-         this.entries.delete(key);
+   isRegistered(fsPath: string, mtimeMs: number): boolean {
+      const entry = this.entries.get(this.key(fsPath));
+      if (!entry || this.isExpired(entry.registeredAt)) {
          return false;
       }
       // Accept mtime equality (some filesystems have 1-second precision).
       return entry.mtimeMs === mtimeMs;
    }
+
+   /**
+    * Drop every expired registration.
+    *
+    * On the WRITE path, so the query stays free of side effects. Evicting from
+    * the query instead reaches only the keys something happens to ask about,
+    * and a path written once and never queried again is then retained for the
+    * life of the process. Bounded by the paths self-written inside one TTL
+    * window, so the sweep is over a handful of entries and sits behind a file
+    * write either way.
+    */
+   protected evictExpired(): void {
+      for (const [key, entry] of this.entries) {
+         if (this.isExpired(entry.registeredAt)) {
+            this.entries.delete(key);
+         }
+      }
+   }
+
+   /** Strictly greater, so an entry aged exactly to the TTL is still eligible. */
+   protected isExpired(registeredAt: number): boolean {
+      return this.clock.now() - registeredAt > this.ttlMs;
+   }
 }

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

@@ -0,0 +1,267 @@
+/********************************************************************************
+ * 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 { DocumentState, type LangiumDocument, type URI } from '@hydranium/langium';
+import { type Tracer, UNRECORDED_VERSION } 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';
+import { HydraniumWorkspaceLock } from '../langium/workspace/hydranium-workspace-lock.js';
+import { HydraniumTextDocuments } from './hydranium-text-documents.js';
+
+/** A build {@link VersionSyncService.requestRecoveryBuild} schedules. */
+export interface RecoveryBuildRequest {
+   /** Remove the document instead of building it. */
+   readonly deleted?: boolean;
+   /** Staged for the build, as `HydraniumDocumentBuilder.scheduleUpdate` takes it. */
+   readonly reason?: string;
+   /** Asked again inside the lock, where a build that ran meanwhile may have made the request moot. */
+   readonly stillNeeded: () => boolean;
+   /** Build even while a {@link VersionSyncService.registerDeferredBuilds} check holds the URI back. */
+   readonly ignoreDeferred?: boolean;
+}
+
+/**
+ * Keeps each workspace root's `ModelLedger` record in step with the
+ * text store, and owns every build that syncs a root to its text or recovers
+ * one a build left behind.
+ */
+export interface VersionSyncService {
+   /**
+    * Report a root a factory, registry, integrity repair or other producer
+    * made. Below `Parsed` it is marked a placeholder. Otherwise `origin.version`,
+    * the store's version read before the parse, is recorded; a registered
+    * document is then reconciled with the store, re-versioned and recorded at
+    * the store's version of its text, built if behind, and announced on
+    * {@link onDidRecordModel}. `origin.text` stands for a root whose CST is not
+    * the text it describes.
+    */
+   modelProduced(document: LangiumDocument, origin?: { version?: number; text?: string }): void;
+   /**
+    * 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
+    * 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.
+    */
+   requestRecoveryBuild(uri: URI, request: RecoveryBuildRequest): Promise<boolean>;
+   /**
+    * 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.
+    */
+   syncTo(uri: URI, textVersion: number): Promise<boolean> | 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,
+    * since no build records a version for it, and so does a URI with no document.
+    */
+   isSyncedTo(uri: URI, textVersion: number): boolean;
+   /**
+    * Register `isDeferred`, which answers whether its caller holds back a build
+    * of a URI it will request later, as the update handler does for a debounced
+    * editor change. A caller that drops a held change has to leave the URI to
+    * another build.
+    */
+   registerDeferredBuilds(isDeferred: (uri: URI) => boolean): Disposable;
+   /**
+    * Fires for every reconciled root. A cancel cannot skip it, unlike a
+    * `Parsed` phase listener. It can fire inside a build's write lock, so a
+    * listener that requests a build must not await it.
+    */
+   readonly onDidRecordModel: Event<LangiumDocument>;
+}
+
+/** A request waiting in {@link PendingRecoveryBuilds}, with the failed builds that carried it. */
+export interface QueuedRecoveryBuild {
+   readonly request: RecoveryBuildRequest;
+   failures: number;
+   readonly answer: (built: boolean) => void;
+}
+
+/** The requests waiting on one URI's builds in {@link DefaultVersionSyncService}. */
+export interface PendingRecoveryBuilds {
+   readonly queued: QueuedRecoveryBuild[];
+}
+
+/**
+ * Collaborators are resolved per call: the registry and its document factory,
+ * which construct each other, report roots to this service.
+ */
+export class DefaultVersionSyncService implements VersionSyncService {
+   protected readonly tracer: Tracer;
+   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`. */
+   protected readonly maxBuildRetries: number = 1;
+
+   constructor(
+      protected readonly services: ServerSharedServices,
+      options: LogNameOptions = {}
+   ) {
+      this.tracer = services.Tracer.for(options.logName ?? 'VersionSyncService').trace('instantiated');
+   }
+
+   get onDidRecordModel(): Event<LangiumDocument> {
+      return this.recordedEmitter.event;
+   }
+
+   modelProduced(document: LangiumDocument, origin: { version?: number; text?: string } = {}): void {
+      const workspace = this.services.workspace;
+      const ledger = workspace.ModelLedger;
+      const root = document.parseResult.value;
+      if (document.state < DocumentState.Parsed) {
+         ledger.markPlaceholder(root);
+         return;
+      }
+      if (origin.version !== undefined) {
+         ledger.record(root, origin.version, origin.text);
+      }
+      const store = workspace.TextDocuments;
+      // Unregistered, it is a probe or a load whose registration reports it again.
+      if (!(store instanceof HydraniumTextDocuments) || workspace.LangiumDocuments.getDocument(document.uri) !== document) {
+         return;
+      }
+      const uri = document.uri.toString();
+      // Against the parsed text: the text document may already hold a newer edit.
+      const version = store.reconcileExternalContent(uri, origin.text ?? this.parsedText(document));
+      if (version !== undefined) {
+         if (document.textDocument.version !== version) {
+            // An empty-changes update only re-stamps the version.
+            store.update(document.textDocument, [], version);
+         }
+         ledger.record(root, version, origin.text);
+      }
+      void this.syncTo(document.uri, store.version(uri));
+      this.recordedEmitter.fire(document);
+   }
+
+   syncTo(uri: URI, textVersion: number): Promise<boolean> | 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 => {
+         const key = uri.toString();
+         const queued: QueuedRecoveryBuild = { request, failures: 0, answer };
+         const pending = this.pendingBuilds.get(key);
+         if (pending) {
+            // Not dropped: the pending build may have read the text before this request's change.
+            pending.queued.push(queued);
+            return;
+         }
+         const entry: PendingRecoveryBuilds = { queued: [queued] };
+         this.pendingBuilds.set(key, entry);
+         void this.runBuilds(key, uri, entry);
+      });
+   }
+
+   registerDeferredBuilds(isDeferred: (uri: URI) => boolean): Disposable {
+      this.deferredBuildChecks.add(isDeferred);
+      return Disposable.create(() => this.deferredBuildChecks.delete(isDeferred));
+   }
+
+   isSyncedTo(uri: URI, textVersion: number): boolean {
+      const root = this.services.workspace.LangiumDocuments.getDocument(uri)?.parseResult.value;
+      if (root === undefined) {
+         return true;
+      }
+      const ledger = this.services.workspace.ModelLedger;
+      const recorded = ledger.versionOf(root);
+      return recorded === UNRECORDED_VERSION || ledger.isPlaceholder(root) || recorded >= textVersion;
+   }
+
+   /** The text `document`'s root was parsed from, or for a root built without either record or CST, the document's own. */
+   protected parsedText(document: LangiumDocument): string {
+      return this.services.workspace.ModelLedger.textOf(document.parseResult.value) ?? document.textDocument.getText();
+   }
+
+   /**
+    * 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
+    * 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.
+    */
+   protected async runBuilds(key: string, uri: URI, entry: PendingRecoveryBuilds): Promise<void> {
+      const tracer = this.tracer.withUri(key);
+      const lock = this.services.workspace.WorkspaceLock;
+      // Any other lock resolves a cancelled write as if it had completed, unnoticed.
+      const counting = lock instanceof HydraniumWorkspaceLock ? lock : undefined;
+      while (entry.queued.length > 0) {
+         let carried: QueuedRecoveryBuild[] = [];
+         let build: Promise<void> | undefined;
+         let cancellations: number | undefined;
+         try {
+            // The read waits until no write runs or is queued. It must not await
+            // the build, a write that queues behind it.
+            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 = needed;
+               if (needed.length > 0) {
+                  build = this.scheduleBatch(
+                     uri,
+                     needed.map(queued => queued.request)
+                  );
+                  // Read after the build is queued, which cancels the write before it.
+                  cancellations = counting?.writeCancellations;
+               }
+            });
+            await build;
+            // A write cancelled the build, before it ran or while it did.
+            if (cancellations !== undefined && counting?.writeCancellations !== cancellations) {
+               entry.queued.unshift(...carried);
+               continue;
+            }
+            carried.forEach(queued => queued.answer(true));
+         } 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}`);
+               entry.queued.unshift(...retried);
+            }
+            if (givenUp.length > 0) {
+               tracer.error(`Requested build failed again; giving up. ${detail}`);
+               givenUp.forEach(queued => queued.answer(false));
+            }
+         }
+      }
+      this.pendingBuilds.delete(key);
+   }
+
+   /** Whether `request` still needs its build, and no deferral it heeds holds it back. Runs inside the lock read. */
+   protected isStillNeeded(uri: URI, request: RecoveryBuildRequest): boolean {
+      return request.stillNeeded() && (request.ignoreDeferred === true || !this.isDeferred(uri));
+   }
+
+   /**
+    * One build for every request of `batch`, removing the document when the
+    * latest of them asks to, as `HydraniumDocumentBuilder.scheduleUpdate`
+    * merges a change and a deletion. Runs inside the lock read.
+    */
+   protected scheduleBatch(uri: URI, batch: readonly RecoveryBuildRequest[]): Promise<void> {
+      const deleted = batch.at(-1)?.deleted === true;
+      const reason = batch.find(request => request.reason !== undefined)?.reason;
+      return this.services.workspace.DocumentBuilder.scheduleUpdate(deleted ? [] : [uri], deleted ? [uri] : [], reason);
+   }
+
+   protected isDeferred(uri: URI): boolean {
+      return [...this.deferredBuildChecks].some(isDeferred => isDeferred(uri));
+   }
+}

package/src/index.ts

@@ -28,6 +28,7 @@ export * from './langium/project/index.js';
 export * from './langium/residency/index.js';
 export * from './langium/scope/index.js';
 export * from './langium/serialization/index.js';
+export * from './langium/trivia/index.js';
 export * from './langium/transfer/index.js';
 export * from './langium/update-rewrite/index.js';
 export * from './langium/validation/index.js';
@@ -35,5 +36,10 @@ export * from './langium/workspace/index.js';
 export * from './langium/service-registry.js';
 export * from './langium/language-types.js';
 export * from './launcher/index.js';
+export * from './locale/index.js';
+// The renderer only. The `./messages` subpath additionally enumerates this
+// package's own declarations, which the root barrel already re-exports through
+// the modules that raise them.
+export * from './messages/renderer.js';
 export * from './documents/index.js';
 export * from './util/index.js';

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