@hydranium/core 1.0.0-next.28 → 1.0.0-next.281

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

@@ -0,0 +1,275 @@
+/********************************************************************************
+ * 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, 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';
+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 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. 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<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} promise.
+    */
+   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,
+    * 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;
+   /** 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}. */
+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 rejected. */
+   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);
+      }
+      // 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<void> | undefined {
+      const behind = (): boolean => !this.isSyncedTo(uri, textVersion);
+      return behind() ? this.requestRecoveryBuild(uri, { stillNeeded: behind }) : undefined;
+   }
+
+   requestRecoveryBuild(uri: URI, request: RecoveryBuildRequest): Promise<void> {
+      return new Promise<void>((resolve, reject) => {
+         const key = uri.toString();
+         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.
+            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
+    * 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.
+    */
+   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.resolve());
+               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.resolve());
+         } catch (err: unknown) {
+            const retried = carried.filter(queued => queued.failures++ < this.maxBuildRetries);
+            const givenUp = carried.filter(queued => !retried.includes(queued));
+            if (retried.length > 0) {
+               // 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) {
+               // 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));
+            }
+         }
+      }
+      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,12 +28,20 @@ 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';
 export * from './langium/workspace/index.js';
 export * from './langium/service-registry.js';
 export * from './langium/language-types.js';
+export * from './langium/composite-ast-reflection.js';
+export * from './langium/single-langium-copy.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-extension-service.ts

@@ -40,6 +40,9 @@ import { type AstExtensionRegistry } from './ast-extension-contribution.js';
  * global scope is built by `IndexedContent` (which runs before
  * `ComputedScopes`), so reading a reference's `.ref` inside a `ComputedScopes`
  * callback triggers Langium's lazy lookup and returns the resolved target node.
+ * A cascade rebuild does not re-run such a derivation unless
+ * {@link DocumentBuilderOptions.refreshCrossDocumentComputedScopes} is set, so
+ * one that reads another document's node goes stale when that node changes.
  *
  * **DO NOT** stage a `state: ComputedScopes` placeholder hoping to refine it
  * via a separate `state: Linked` registration when a downstream consumer

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