@hydranium/core 1.0.0-next.10

package/lib/langium/transfer/transfer-encoder.d.ts

@@ -0,0 +1,294 @@
+/********************************************************************************
+ * Copyright (c) 2023-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 Tracer, type TransferDiagnostic, type TransferElement, type TransferDocument, type TransferTypeFor } from '@hydranium/protocol';
+import { type AstNode, DocumentCache, type LangiumDocument } from '@hydranium/langium';
+import { Diagnostic } from 'vscode-languageserver-protocol';
+import { type AstDocument } from '../../documents/ast-document-manager.js';
+import { type LogNameOptions } from '../diagnostics/logger.js';
+import { type ServerSharedServicesMinimal } from '../shared-services.js';
+import { type TransferLspDiagnostic } from '../validation/document-validator.js';
+/**
+ * Which set of properties {@link TransferEncoder.toTransfer} emits.
+ *
+ * - `'full'` — every own property of the node (Langium internals aside),
+ *   including AST-extension-derived computed scalars and synthetic child
+ *   mirrors. This is the wire shape clients consume, and the default.
+ * - `'grammar'` — only the grammar-declared properties, per
+ *   `AstReflection.getTypeMetaData($type).properties`. Excludes every
+ *   computed / synthetic property by construction (no naming convention,
+ *   no registration). Yields the authored state a serializer round-trips —
+ *   a diffable, acyclic baseline for field-level recording / forward-write
+ *   reconcile.
+ */
+export type TransferMode = 'full' | 'grammar';
+/**
+ * Per-encode inputs threaded through the {@link TransferEncoder} walk and its
+ * hooks. Created once per encode entry (see
+ * {@link TransferEncoder.createEncodeContext}) and passed unchanged through
+ * the recursion, so every hook invocation of one encode observes the same
+ * inputs — unlike instance state, which two interleaving encodes would
+ * clobber.
+ *
+ * Adopters widen the context by overriding `createEncodeContext` with a
+ * covariant return type and narrowing the hook parameter types accordingly
+ * (TypeScript method bivariance admits the narrowing). An input that changes
+ * the encoded output must also be folded into {@link TransferEncoder.rootCacheKey}.
+ */
+export interface EncodeContext {
+    /** Property-set selection for this encode — see {@link TransferMode}. */
+    readonly mode: TransferMode;
+    /**
+     * URI of the document whose subtree is being encoded, when known. The
+     * document entry points always set it; the bare {@link TransferEncoder.toTransfer}
+     * door derives it from the node's root when the node is attached to a
+     * document, and leaves it `undefined` for detached / synthetic subtrees.
+     */
+    readonly uri?: string;
+}
+/**
+ * The non-root inputs {@link TransferEncoder.assembleTransferDocument} needs to
+ * build a wire envelope. Both of the encoder's document paths narrow to this
+ * before assembling — a built `LangiumDocument` (whose `uri` / `version` live on
+ * its `textDocument`) and a server-internal `AstDocument` snapshot, which
+ * satisfies the shape structurally — so the assembly seam has exactly one
+ * implementation to override.
+ *
+ * `diagnostics` accepts either the wire shape (an already-projected
+ * `TDiagnostic`, as a snapshot may carry) or a raw LSP {@link Diagnostic}; the
+ * assembly projects each through {@link TransferEncoder.toTransferDiagnostic}.
+ */
+export interface TransferEnvelopeSource<TDiagnostic> {
+    readonly uri: string;
+    readonly version: number;
+    readonly diagnostics: readonly (TDiagnostic | Diagnostic)[];
+}
+/**
+ * One-directional structural mapper from a Langium AST into the wire
+ * transfer-model shape ({@link TransferElement}-based JSON).
+ *
+ * **Direction.** AST → transfer only. The inverse (transfer → AST) is
+ * composite: serialise the transfer to text through the `Serializer` bound at
+ * `serializer.Serializer` (`serializeTransfer`), then re-parse via Langium's
+ * `DocumentBuilder`. No `decode` method exists; the parser is the decoder. The transfer model
+ * is intentionally lossy w.r.t. `$container` / `$cstNode` topology and
+ * `Reference<T>` resolution — those are re-derived by the parser/linker
+ * from text + workspace scope.
+ *
+ * **Generic parameters.**
+ * - `TTransferMap` — per-grammar overlay keyed by AST `$type` strings,
+ *   resolving each AST type to its declared wire shape. Default is
+ *   `Record<string, TransferElement>`, which collapses every encoded node
+ *   to the structural base — adequate for adopters without a generated
+ *   overlay; richer adopters declare typed maps for autocomplete on the
+ *   encoder's return types.
+ * - `TDiagnostic` — wire-diagnostic shape produced by
+ *   {@link toTransferDiagnostic}. Constrained to extend
+ *   {@link TransferDiagnostic} so the framework default (which constructs a
+ *   `TransferDiagnostic` literal) satisfies any tighter binding under
+ *   covariance.
+ *
+ * **Adopter extension surface.** The property walk is decomposed into
+ * per-concern hooks so adopters customise a slice without copying it —
+ * every hook receives the per-encode {@link EncodeContext}:
+ * - {@link createEncodeContext} — widen the context with per-encode
+ *   inputs, resolved once per entry.
+ * - {@link propertyKeys} — which property names the walk visits.
+ * - {@link shouldEmitProperty} — per-key filter on top of the default
+ *   `$`-internals strip.
+ * - {@link resolvePropertyValue} — value substitution per property.
+ * - {@link finalizeTransferNode} — post-decoration per encoded node.
+ * - {@link toTransferValue} — recursion seam per property value. Override
+ *   to special-case reference encoding or to drop specific value shapes.
+ * Envelope-level seams:
+ * - {@link toTransferDocument} — bundle root + diagnostics into the wire
+ *   {@link TransferDocument} envelope. Override to filter / merge
+ *   diagnostics from auxiliary sources or to project a synthesised root.
+ * - {@link toTransferDiagnostic} — project a {@link TransferLspDiagnostic}
+ *   (the framework validator's output) to {@link TDiagnostic}.
+ */
+export declare class TransferEncoder<TTransferMap = Record<string, TransferElement>, TDiagnostic extends TransferDiagnostic = TransferDiagnostic> {
+    protected readonly services: ServerSharedServicesMinimal;
+    protected readonly tracer: Tracer;
+    /**
+     * Per-document cache of encoded transfer roots ({@link toTransferDocument}'s
+     * `'full'` root). Internal — not part of the encoder's public surface.
+     * Lets the data-server's fingerprint and emitted envelope share a single
+     * encode walk within one build (both call `toTransferDocument`).
+     *
+     * Evicts on `DocumentState.Linked`, NOT the default `onUpdate`: the `'full'`
+     * transfer root folds in the AST-extension computed properties, which resolve
+     * against other documents, so it changes on *cascade* rebuilds where the
+     * document's own text (and version) does not. `DocumentCache`'s `state` mode
+     * evicts every document affected by a build (any state `>= Linked`), which
+     * covers those cascade dependents; the default `onUpdate` mode evicts only
+     * the directly-edited documents and would serve a stale root to dependents.
+     */
+    protected readonly rootCache: DocumentCache<string, unknown>;
+    constructor(services: ServerSharedServicesMinimal, options?: LogNameOptions);
+    /**
+     * Cache key for a memoised transfer root, *within* one document — the
+     * {@link rootCache} is keyed `(document uri, this key)`.
+     *
+     * Default: the encode mode alone. That is correct exactly while the encoded
+     * output is a pure function of `(document, mode)`, which holds for every
+     * framework hook.
+     *
+     * **Adopters whose `createEncodeContext` injects an input that changes the
+     * OUTPUT must fold that input in here.** Otherwise two encodes of one
+     * document under different inputs serve each other's result: the first
+     * caller's root is memoised and the second gets it back, silently, with no
+     * type error to catch it. Widening the key is cheap (the cache holds one
+     * entry per distinct key per document) and evicts on the same build
+     * boundary.
+     */
+    protected rootCacheKey(context: EncodeContext): string;
+    /**
+     * Encode an AST node into its transfer-model shape, resolving
+     * cross-references to their `$refText` and recursing into nested nodes.
+     * The {@link TransferMode} argument selects which properties are emitted;
+     * {@link propertyKeys} enumerates them and the per-key hooks filter and
+     * substitute.
+     *
+     * Non-destructive: returns a fresh object graph and leaves the AST
+     * untouched. Synchronous — walks the in-memory AST without serialising.
+     */
+    toTransfer<T extends AstNode>(ast: T, mode?: TransferMode): TransferTypeFor<T, TTransferMap>;
+    /**
+     * Create the {@link EncodeContext} for one encode entry. Called once per
+     * entry point ({@link toTransfer}, {@link toTransferDocument},
+     * {@link astDocumentToTransferDocument}); the result threads unchanged
+     * through the whole recursion. Adopters override with a covariant return
+     * type to carry extra per-encode inputs, resolved here once instead of
+     * once per node.
+     */
+    protected createEncodeContext(mode: TransferMode, uri?: string): EncodeContext;
+    /**
+     * Encode one node under an established context — the recursion core the
+     * entry points and {@link toTransferValue} share. Delegates each concern to
+     * an overridable hook so adopters customise a slice without copying the
+     * walk.
+     */
+    protected encodeNode(ast: AstNode, context: EncodeContext): Record<string, unknown>;
+    /**
+     * Which property names the walk visits for `ast`.
+     *
+     * Default: `'full'` enumerates own properties (including non-enumerable
+     * ones via `Object.getOwnPropertyNames`, which catches
+     * AST-extension-derived properties); `'grammar'` enumerates the
+     * declared-property allowlist per
+     * `AstReflection.getTypeMetaData($type).properties`.
+     */
+    protected propertyKeys(ast: AstNode, context: EncodeContext): readonly string[];
+    /**
+     * Per-key filter. Default: strip the `$`-prefixed Langium internals
+     * (`$container`, `$cstNode`, `$containerProperty`, `$containerIndex`,
+     * `$document`) that would otherwise form cycles `JSON.stringify` rejects
+     * or carry server-internal data clients cannot use. Adopter overrides
+     * refine ON TOP of the default (call `super.shouldEmitProperty` first).
+     */
+    protected shouldEmitProperty(_ast: AstNode, key: string, _context: EncodeContext): boolean;
+    /**
+     * Which value the walk emits under `key`. Default: the node's own value.
+     * Override to substitute a derived value under a grammar property name.
+     */
+    protected resolvePropertyValue(ast: AstNode, key: string, _context: EncodeContext): unknown;
+    /**
+     * Post-decoration hook, invoked once per encoded node after its property
+     * walk. Default: no-op. Override to append synthesised wire-only fields —
+     * gate on `context.mode === 'full'` when the addition must stay out of the
+     * grammar (round-trippable) shape.
+     */
+    protected finalizeTransferNode(_ast: AstNode, _result: Record<string, unknown>, _context: EncodeContext): void;
+    /**
+     * Build a wire {@link TransferDocument} envelope from a built
+     * {@link LangiumDocument}. The `'full'` root is served from the internal
+     * {@link rootCache} (memoised per document until it next rebuilds), under
+     * {@link rootCacheKey} — so the data-server's fingerprint and emitted
+     * envelope share one encode walk within a build, while two encodes whose
+     * contexts differ in an output-affecting way stay separate entries.
+     * Diagnostics are projected fresh on every call (cheap, and they change
+     * independently of the root — a cross-document reference flipping unresolved
+     * bumps diagnostics while the root, encoding the ref as the same
+     * `$refText`, does not).
+     *
+     * The context is created before the cache lookup, not inside the factory,
+     * because the key is derived from it — so it costs one context construction
+     * per call, including on a hit. That is a shallow object plus whatever the
+     * adopter resolves in `createEncodeContext`, against a whole encode walk
+     * saved.
+     *
+     * The cache holds its entries as `unknown`, so the memoised root is
+     * asserted to the caller's `<TAst>` claim on the way out. Nothing checks
+     * that claim — Langium types `parseResult.value` as a bare `AstNode` — but
+     * the runtime walk doesn't depend on the typing being correct.
+     */
+    toTransferDocument<TAst extends AstNode>(langiumDocument: LangiumDocument): TransferDocument<TransferTypeFor<TAst, TTransferMap>, TDiagnostic>;
+    /**
+     * Wrap an already-encoded root into the wire envelope (uri / version /
+     * projected diagnostics).
+     *
+     * **The single chokepoint for every envelope the encoder emits.** Both
+     * document paths land here — {@link toTransferDocument} from a live
+     * `LangiumDocument` and {@link astDocumentToTransferDocument} from an
+     * `AstDocument` snapshot — so one override is seen by data-server emissions
+     * and adopter facade returns alike. It takes a
+     * {@link TransferEnvelopeSource} rather than a `LangiumDocument` precisely
+     * so the snapshot path can reach it without a `LangiumDocuments` lookup.
+     */
+    protected assembleTransferDocument<TAst extends AstNode>(source: TransferEnvelopeSource<TDiagnostic>, root: TransferTypeFor<TAst, TTransferMap>): TransferDocument<TransferTypeFor<TAst, TTransferMap>, TDiagnostic>;
+    /**
+     * Build a wire {@link TransferDocument} envelope from a server-internal
+     * {@link AstDocument} snapshot (the AST-typed envelope emitted by
+     * `AstDocumentManager.onUpdate` / `onSave` and returned from
+     * `ModelService.request` / `update` / `save`). Distinct from
+     * {@link toTransferDocument}(`LangiumDocument`) which encodes against
+     * the live build artifact — adopter facade returns hold the snapshot
+     * directly, and this helper bridges that to the wire shape without a
+     * second `LangiumDocuments.getDocument` lookup.
+     *
+     * The `diagnostic` projection assumes the snapshot's diagnostics carry
+     * the `TransferLspDiagnostic` shape ({@link Diagnostic} plus the
+     * framework validator's `element` / `property` decoration). Snapshots
+     * built from raw Langium diagnostics structurally satisfy this — the
+     * extra fields are optional in the projection.
+     *
+     * Encodes the root, then delegates the envelope to
+     * {@link assembleTransferDocument} (an `AstDocument` satisfies
+     * {@link TransferEnvelopeSource} structurally), so this path shares the
+     * assembly seam rather than duplicating it.
+     */
+    astDocumentToTransferDocument<TAst extends AstNode>(document: AstDocument<TAst, TDiagnostic | TransferLspDiagnostic>): TransferDocument<TransferTypeFor<TAst, TTransferMap>, TDiagnostic>;
+    /**
+     * Project an LSP-shaped diagnostic (typically a
+     * {@link TransferLspDiagnostic} produced by
+     * `HydraniumDocumentValidator` — adds `element` + optional `property`
+     * to the standard {@link Diagnostic} shape) to the wire-diagnostic
+     * shape.
+     *
+     * Default projection produces the full {@link TransferDiagnostic}: maps
+     * LSP severity enum to the wire string union, discriminates the
+     * diagnostic type from Langium's `data.code` (`'lexing-error'` /
+     * `'parsing-error'` else `'validation-error'`), passes through
+     * message / element / property / code. Adopters whose validator
+     * doesn't decorate diagnostics with `element` still get a valid
+     * `TransferDiagnostic` — the field falls back to `''`.
+     *
+     * Override only if the wire-diagnostic shape needs fields beyond
+     * what {@link TransferDiagnostic} carries.
+     */
+    toTransferDiagnostic(diagnostic: TransferLspDiagnostic): TDiagnostic;
+    /**
+     * Recursion seam — converts a single property value during the AST
+     * walk. Arrays recurse element-wise; cross-references collapse to
+     * their `$refText`; nested AST nodes encode via {@link encodeNode} under
+     * the same {@link EncodeContext}; primitives pass through unchanged.
+     */
+    protected toTransferValue(value: unknown, context: EncodeContext): unknown;
+}
+//# sourceMappingURL=transfer-encoder.d.ts.map

package/lib/langium/transfer/transfer-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-encoder.d.ts","sourceRoot":"","sources":["../../../src/langium/transfer/transfer-encoder.ts"],"names":[],"mappings":"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"}

package/lib/langium/transfer/transfer-encoder.js

@@ -0,0 +1,328 @@
+/********************************************************************************
+ * Copyright (c) 2023-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 { AstUtils, DocumentCache, DocumentState, isAstNode, isReference } from '@hydranium/langium';
+import { Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-protocol';
+/**
+ * One-directional structural mapper from a Langium AST into the wire
+ * transfer-model shape ({@link TransferElement}-based JSON).
+ *
+ * **Direction.** AST → transfer only. The inverse (transfer → AST) is
+ * composite: serialise the transfer to text through the `Serializer` bound at
+ * `serializer.Serializer` (`serializeTransfer`), then re-parse via Langium's
+ * `DocumentBuilder`. No `decode` method exists; the parser is the decoder. The transfer model
+ * is intentionally lossy w.r.t. `$container` / `$cstNode` topology and
+ * `Reference<T>` resolution — those are re-derived by the parser/linker
+ * from text + workspace scope.
+ *
+ * **Generic parameters.**
+ * - `TTransferMap` — per-grammar overlay keyed by AST `$type` strings,
+ *   resolving each AST type to its declared wire shape. Default is
+ *   `Record<string, TransferElement>`, which collapses every encoded node
+ *   to the structural base — adequate for adopters without a generated
+ *   overlay; richer adopters declare typed maps for autocomplete on the
+ *   encoder's return types.
+ * - `TDiagnostic` — wire-diagnostic shape produced by
+ *   {@link toTransferDiagnostic}. Constrained to extend
+ *   {@link TransferDiagnostic} so the framework default (which constructs a
+ *   `TransferDiagnostic` literal) satisfies any tighter binding under
+ *   covariance.
+ *
+ * **Adopter extension surface.** The property walk is decomposed into
+ * per-concern hooks so adopters customise a slice without copying it —
+ * every hook receives the per-encode {@link EncodeContext}:
+ * - {@link createEncodeContext} — widen the context with per-encode
+ *   inputs, resolved once per entry.
+ * - {@link propertyKeys} — which property names the walk visits.
+ * - {@link shouldEmitProperty} — per-key filter on top of the default
+ *   `$`-internals strip.
+ * - {@link resolvePropertyValue} — value substitution per property.
+ * - {@link finalizeTransferNode} — post-decoration per encoded node.
+ * - {@link toTransferValue} — recursion seam per property value. Override
+ *   to special-case reference encoding or to drop specific value shapes.
+ * Envelope-level seams:
+ * - {@link toTransferDocument} — bundle root + diagnostics into the wire
+ *   {@link TransferDocument} envelope. Override to filter / merge
+ *   diagnostics from auxiliary sources or to project a synthesised root.
+ * - {@link toTransferDiagnostic} — project a {@link TransferLspDiagnostic}
+ *   (the framework validator's output) to {@link TDiagnostic}.
+ */
+export class TransferEncoder {
+    services;
+    tracer;
+    /**
+     * Per-document cache of encoded transfer roots ({@link toTransferDocument}'s
+     * `'full'` root). Internal — not part of the encoder's public surface.
+     * Lets the data-server's fingerprint and emitted envelope share a single
+     * encode walk within one build (both call `toTransferDocument`).
+     *
+     * Evicts on `DocumentState.Linked`, NOT the default `onUpdate`: the `'full'`
+     * transfer root folds in the AST-extension computed properties, which resolve
+     * against other documents, so it changes on *cascade* rebuilds where the
+     * document's own text (and version) does not. `DocumentCache`'s `state` mode
+     * evicts every document affected by a build (any state `>= Linked`), which
+     * covers those cascade dependents; the default `onUpdate` mode evicts only
+     * the directly-edited documents and would serve a stale root to dependents.
+     */
+    rootCache;
+    // The base reads three slots: `Tracer`, the `DocumentBuilder` the root
+    // cache evicts from, and `AstReflection` for the `'grammar'` allowlist. The
+    // whole bundle is taken anyway, matching the framework's
+    // `(services, options)` constructor convention, so a subclass needing a
+    // further slot — a language `Serializer` for textual re-serialisation, say —
+    // forwards the same parameter via `super(services, options)`.
+    constructor(services, options = {}) {
+        this.services = services;
+        this.tracer = services.Tracer.for(options.logName ?? 'TransferEncoder').trace('instantiated');
+        this.rootCache = new DocumentCache(services, DocumentState.Linked);
+    }
+    /**
+     * Cache key for a memoised transfer root, *within* one document — the
+     * {@link rootCache} is keyed `(document uri, this key)`.
+     *
+     * Default: the encode mode alone. That is correct exactly while the encoded
+     * output is a pure function of `(document, mode)`, which holds for every
+     * framework hook.
+     *
+     * **Adopters whose `createEncodeContext` injects an input that changes the
+     * OUTPUT must fold that input in here.** Otherwise two encodes of one
+     * document under different inputs serve each other's result: the first
+     * caller's root is memoised and the second gets it back, silently, with no
+     * type error to catch it. Widening the key is cheap (the cache holds one
+     * entry per distinct key per document) and evicts on the same build
+     * boundary.
+     */
+    rootCacheKey(context) {
+        return context.mode;
+    }
+    /**
+     * Encode an AST node into its transfer-model shape, resolving
+     * cross-references to their `$refText` and recursing into nested nodes.
+     * The {@link TransferMode} argument selects which properties are emitted;
+     * {@link propertyKeys} enumerates them and the per-key hooks filter and
+     * substitute.
+     *
+     * Non-destructive: returns a fresh object graph and leaves the AST
+     * untouched. Synchronous — walks the in-memory AST without serialising.
+     */
+    toTransfer(ast, mode = 'full') {
+        // Derive the owning document's URI when the node is attached so hooks
+        // (and adopter-widened contexts) can resolve per-document inputs even
+        // through this bare-node door. `findRootNode` never throws; a detached
+        // or synthetic subtree simply yields an undefined URI.
+        const uri = AstUtils.findRootNode(ast).$document?.uri.toString();
+        return this.encodeNode(ast, this.createEncodeContext(mode, uri));
+    }
+    /**
+     * Create the {@link EncodeContext} for one encode entry. Called once per
+     * entry point ({@link toTransfer}, {@link toTransferDocument},
+     * {@link astDocumentToTransferDocument}); the result threads unchanged
+     * through the whole recursion. Adopters override with a covariant return
+     * type to carry extra per-encode inputs, resolved here once instead of
+     * once per node.
+     */
+    createEncodeContext(mode, uri) {
+        return { mode, uri };
+    }
+    /**
+     * Encode one node under an established context — the recursion core the
+     * entry points and {@link toTransferValue} share. Delegates each concern to
+     * an overridable hook so adopters customise a slice without copying the
+     * walk.
+     */
+    encodeNode(ast, context) {
+        const result = { $type: ast.$type };
+        for (const key of this.propertyKeys(ast, context)) {
+            if (!this.shouldEmitProperty(ast, key, context)) {
+                continue;
+            }
+            const value = this.resolvePropertyValue(ast, key, context);
+            // `'grammar'` lists every declared property, including those absent on
+            // this node; skip the absent ones. (`'full'` enumerates only own
+            // properties, so absent properties never surface there.) Part of the
+            // mode contract, not the adopter filter — hence not in shouldEmitProperty.
+            if (context.mode === 'grammar' && value === undefined) {
+                continue;
+            }
+            result[key] = this.toTransferValue(value, context);
+        }
+        this.finalizeTransferNode(ast, result, context);
+        return result;
+    }
+    /**
+     * Which property names the walk visits for `ast`.
+     *
+     * Default: `'full'` enumerates own properties (including non-enumerable
+     * ones via `Object.getOwnPropertyNames`, which catches
+     * AST-extension-derived properties); `'grammar'` enumerates the
+     * declared-property allowlist per
+     * `AstReflection.getTypeMetaData($type).properties`.
+     */
+    propertyKeys(ast, context) {
+        return context.mode === 'grammar'
+            ? Object.keys(this.services.AstReflection.getTypeMetaData(ast.$type).properties)
+            : Object.getOwnPropertyNames(ast);
+    }
+    /**
+     * Per-key filter. Default: strip the `$`-prefixed Langium internals
+     * (`$container`, `$cstNode`, `$containerProperty`, `$containerIndex`,
+     * `$document`) that would otherwise form cycles `JSON.stringify` rejects
+     * or carry server-internal data clients cannot use. Adopter overrides
+     * refine ON TOP of the default (call `super.shouldEmitProperty` first).
+     */
+    shouldEmitProperty(_ast, key, _context) {
+        return !key.startsWith('$');
+    }
+    /**
+     * Which value the walk emits under `key`. Default: the node's own value.
+     * Override to substitute a derived value under a grammar property name.
+     */
+    resolvePropertyValue(ast, key, _context) {
+        return ast[key];
+    }
+    /**
+     * Post-decoration hook, invoked once per encoded node after its property
+     * walk. Default: no-op. Override to append synthesised wire-only fields —
+     * gate on `context.mode === 'full'` when the addition must stay out of the
+     * grammar (round-trippable) shape.
+     */
+    finalizeTransferNode(_ast, _result, _context) {
+        // Intentionally empty — adopter seam.
+    }
+    /**
+     * Build a wire {@link TransferDocument} envelope from a built
+     * {@link LangiumDocument}. The `'full'` root is served from the internal
+     * {@link rootCache} (memoised per document until it next rebuilds), under
+     * {@link rootCacheKey} — so the data-server's fingerprint and emitted
+     * envelope share one encode walk within a build, while two encodes whose
+     * contexts differ in an output-affecting way stay separate entries.
+     * Diagnostics are projected fresh on every call (cheap, and they change
+     * independently of the root — a cross-document reference flipping unresolved
+     * bumps diagnostics while the root, encoding the ref as the same
+     * `$refText`, does not).
+     *
+     * The context is created before the cache lookup, not inside the factory,
+     * because the key is derived from it — so it costs one context construction
+     * per call, including on a hit. That is a shallow object plus whatever the
+     * adopter resolves in `createEncodeContext`, against a whole encode walk
+     * saved.
+     *
+     * The cache holds its entries as `unknown`, so the memoised root is
+     * asserted to the caller's `<TAst>` claim on the way out. Nothing checks
+     * that claim — Langium types `parseResult.value` as a bare `AstNode` — but
+     * the runtime walk doesn't depend on the typing being correct.
+     */
+    toTransferDocument(langiumDocument) {
+        const context = this.createEncodeContext('full', langiumDocument.uri.toString());
+        const root = this.rootCache.get(langiumDocument.uri, this.rootCacheKey(context), () => this.encodeNode(langiumDocument.parseResult.value, context));
+        return this.assembleTransferDocument({
+            uri: langiumDocument.textDocument.uri,
+            version: langiumDocument.textDocument.version,
+            diagnostics: langiumDocument.diagnostics ?? []
+        }, root);
+    }
+    /**
+     * Wrap an already-encoded root into the wire envelope (uri / version /
+     * projected diagnostics).
+     *
+     * **The single chokepoint for every envelope the encoder emits.** Both
+     * document paths land here — {@link toTransferDocument} from a live
+     * `LangiumDocument` and {@link astDocumentToTransferDocument} from an
+     * `AstDocument` snapshot — so one override is seen by data-server emissions
+     * and adopter facade returns alike. It takes a
+     * {@link TransferEnvelopeSource} rather than a `LangiumDocument` precisely
+     * so the snapshot path can reach it without a `LangiumDocuments` lookup.
+     */
+    assembleTransferDocument(source, root) {
+        return {
+            uri: source.uri,
+            version: source.version,
+            root,
+            diagnostics: source.diagnostics.map(diagnostic => this.toTransferDiagnostic(diagnostic))
+        };
+    }
+    /**
+     * Build a wire {@link TransferDocument} envelope from a server-internal
+     * {@link AstDocument} snapshot (the AST-typed envelope emitted by
+     * `AstDocumentManager.onUpdate` / `onSave` and returned from
+     * `ModelService.request` / `update` / `save`). Distinct from
+     * {@link toTransferDocument}(`LangiumDocument`) which encodes against
+     * the live build artifact — adopter facade returns hold the snapshot
+     * directly, and this helper bridges that to the wire shape without a
+     * second `LangiumDocuments.getDocument` lookup.
+     *
+     * The `diagnostic` projection assumes the snapshot's diagnostics carry
+     * the `TransferLspDiagnostic` shape ({@link Diagnostic} plus the
+     * framework validator's `element` / `property` decoration). Snapshots
+     * built from raw Langium diagnostics structurally satisfy this — the
+     * extra fields are optional in the projection.
+     *
+     * Encodes the root, then delegates the envelope to
+     * {@link assembleTransferDocument} (an `AstDocument` satisfies
+     * {@link TransferEnvelopeSource} structurally), so this path shares the
+     * assembly seam rather than duplicating it.
+     */
+    astDocumentToTransferDocument(document) {
+        const root = this.encodeNode(document.root, this.createEncodeContext('full', document.uri));
+        return this.assembleTransferDocument(document, root);
+    }
+    /**
+     * Project an LSP-shaped diagnostic (typically a
+     * {@link TransferLspDiagnostic} produced by
+     * `HydraniumDocumentValidator` — adds `element` + optional `property`
+     * to the standard {@link Diagnostic} shape) to the wire-diagnostic
+     * shape.
+     *
+     * Default projection produces the full {@link TransferDiagnostic}: maps
+     * LSP severity enum to the wire string union, discriminates the
+     * diagnostic type from Langium's `data.code` (`'lexing-error'` /
+     * `'parsing-error'` else `'validation-error'`), passes through
+     * message / element / property / code. Adopters whose validator
+     * doesn't decorate diagnostics with `element` still get a valid
+     * `TransferDiagnostic` — the field falls back to `''`.
+     *
+     * Override only if the wire-diagnostic shape needs fields beyond
+     * what {@link TransferDiagnostic} carries.
+     */
+    toTransferDiagnostic(diagnostic) {
+        const langiumCode = diagnostic.data?.code;
+        const result = {
+            type: langiumCode === 'lexing-error' ? 'lexing-error' : langiumCode === 'parsing-error' ? 'parsing-error' : 'validation-error',
+            element: diagnostic.element ?? '',
+            property: diagnostic.property,
+            // LSP 3.18 allows a `MarkupContent` message; the wire shape is plain text.
+            message: Diagnostic.getMessageString(diagnostic),
+            severity: diagnostic.severity === DiagnosticSeverity.Error
+                ? 'error'
+                : diagnostic.severity === DiagnosticSeverity.Warning
+                    ? 'warning'
+                    : 'info',
+            code: typeof diagnostic.code === 'number' || typeof diagnostic.code === 'string' ? diagnostic.code : langiumCode
+        };
+        return result;
+    }
+    /**
+     * Recursion seam — converts a single property value during the AST
+     * walk. Arrays recurse element-wise; cross-references collapse to
+     * their `$refText`; nested AST nodes encode via {@link encodeNode} under
+     * the same {@link EncodeContext}; primitives pass through unchanged.
+     */
+    toTransferValue(value, context) {
+        if (Array.isArray(value)) {
+            return value.map(element => this.toTransferValue(element, context));
+        }
+        if (isReference(value)) {
+            return value.$refText;
+        }
+        if (isAstNode(value)) {
+            return this.encodeNode(value, context);
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=transfer-encoder.js.map

package/lib/langium/transfer/transfer-encoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-encoder.js","sourceRoot":"","sources":["../../../src/langium/transfer/transfer-encoder.ts"],"names":[],"mappings":"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"}

package/lib/langium/update-rewrite/index.d.ts

@@ -0,0 +1,14 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export * from './normalize-empty-strings.js';
+export * from './semantic-root-rewrite.js';
+export * from './update-rewrite.js';
+export * from './update-rewrite-contribution.js';
+export * from './update-rewrite-service.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/langium/update-rewrite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/langium/update-rewrite/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}