@hydranium/glsp-server 1.0.0-next.10

package/lib/state/abstract-hydranium-glsp-state.js

@@ -0,0 +1,451 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AbstractHydraniumGlspState_1;
+import { DefaultModelState, SOURCE_URI_ARG } from '@eclipse-glsp/server';
+import { Emitter } from 'vscode-jsonrpc';
+import { inject, injectable, optional } from 'inversify';
+import { DocumentState, URI } from '@hydranium/langium';
+import { HydraniumTypes } from './hydranium-shared-core-services.js';
+import { ModelReadyTimeoutError } from './model-ready-timeout-error.js';
+/**
+ * GLSP model state base shared by all hydranium adopters. Tracks the source
+ * AST root + URI alongside GLSP's GModel, exposes a build-state wait with
+ * timeout-and-race semantics, and wires a logger labelled with the adopter's
+ * component name + current document URI.
+ *
+ * **Source-root vs GLSP's `sourceUri`.** GLSP's {@link DefaultModelState}
+ * stores `sourceUri` via the loosely-typed properties map
+ * (`state.set(SOURCE_URI_ARG, uri)`). This base class makes the URI a
+ * first-class typed field set through {@link setSourceRoot}, then mirrors
+ * the value into the inherited properties map so legacy code paths that
+ * still call `state.get(SOURCE_URI_ARG)` continue to work. The inherited
+ * `sourceUri` getter is overridden to a narrowed `string` return (no
+ * `undefined` once {@link setSourceRoot} has run).
+ *
+ * **Hooks.**
+ * - {@link onReadyRefreshed} — runs after {@link ready} returns. Default
+ *   calls {@link refreshSourceRoot} so callers see a fresh AST after a
+ *   wait that may have rebuilt the document. Adopters whose AST is
+ *   immutable between build phases can override to a no-op.
+ * - {@link buildReadyTimeoutError} — constructs the timeout error with the
+ *   workspace-relative path + the document builder's build-status snapshot;
+ *   override only to change the error shape (richer per-adopter output comes
+ *   from overriding `wsRelativePath` / `formatBuildStatus`).
+ * - logging — see {@link baseTracer}. Adopters wanting a different label
+ *   override `setSourceRoot` and derive via
+ *   `this.baseTracer.for('Name').withUri(uri)`.
+ *
+ * **Lifecycle ordering.** Reading {@link sourceUri} or {@link sourceRoot}
+ * before the first {@link setSourceRoot} call throws via the
+ * definite-assignment assertions — callers must invoke `setSourceRoot`
+ * (typically from the storage `loadSourceModel` flow) before reading them.
+ * The {@link logger}/{@link tracer} are the exception: the injected
+ * {@link baseTracer} is always available, so the getters fall back to it
+ * before {@link setSourceRoot} derives the URI-tagged {@link _tracer} —
+ * logging is never `undefined`.
+ */
+let AbstractHydraniumGlspState = class AbstractHydraniumGlspState extends DefaultModelState {
+    static { AbstractHydraniumGlspState_1 = this; }
+    sharedServices;
+    /**
+     * Conflict-resolution policy consulted when a write races a foreign edit
+     * (forward-write, undo, redo, save). Bound by
+     * `HydraniumGlspAppModule` to the adopter's choice — default
+     * `ReconcilingConflictResolver` (field-level merge) unless the adopter
+     * passes a `ForceConflictResolver` (last-writer-wins). Read by
+     * `HydraniumGlspRecordingCommand`'s undo / redo and by adopter
+     * `updateSourceModel` implementations.
+     */
+    conflictResolver;
+    /**
+     * Per-class tracer, caller-tagged with this state's runtime subclass name by
+     * the `HydraniumTypes.Tracer` binding. {@link setSourceRoot} derives the
+     * URI-tagged {@link _tracer} from it; the {@link tracer}/{@link logger}
+     * getters fall back to it before then, so logging is never `undefined`.
+     */
+    baseTracer;
+    _sourceUri;
+    _sourceRoot;
+    _tracer;
+    _version = 0;
+    /** Based-on versions of the secondary write set, keyed by URI. See {@link trackSecondaryDocument}. */
+    _secondaryVersions = new Map();
+    /** Backing emitter for {@link onSecondaryUrisChanged}; fired only on a membership change. */
+    secondaryUrisChangedEmitter = new Emitter();
+    /** Default of one minute. */
+    static DEFAULT_READY_TIMEOUT_MS = 60_000;
+    /** Maximum wait inside {@link readyWithTimeout} before raising {@link ModelReadyTimeoutError}. */
+    readyTimeoutMs = AbstractHydraniumGlspState_1.DEFAULT_READY_TIMEOUT_MS;
+    /**
+     * Capture a freshly built source root alongside its URI, refresh the
+     * logger to label log lines with the URI, and re-index the AST so
+     * downstream GModel projection can resolve elements back to nodes.
+     *
+     * Also mirrors `uri` into the inherited properties map under
+     * {@link SOURCE_URI_ARG} so legacy GLSP code paths (`state.get(...)`)
+     * stay consistent with the typed field.
+     */
+    setSourceRoot(uri, root) {
+        this._sourceUri = uri;
+        this._sourceRoot = root;
+        this._version = this.readDocumentVersion(uri);
+        // Re-read the secondary write set for the same reason the primary is
+        // re-read: the write that brought us here advanced their versions too, and
+        // a stale based-on version would gate the NEXT command against a
+        // superseded number — reporting a conflict that is really this state's own
+        // last write.
+        this.refreshSecondaryVersions();
+        this.set(SOURCE_URI_ARG, uri);
+        this._tracer = this.baseTracer.withUri(uri);
+        this.tracer.debug(`Captured source root at doc.version=v${this._version}`);
+        this.checkDeclaredLanguage(uri);
+        this.index.indexSourceRoot(root, uri);
+    }
+    /**
+     * Typed override of {@link DefaultModelState.sourceUri}. Narrows the
+     * inherited `string | undefined` to `string` (defined after
+     * {@link setSourceRoot}; throws on definite-assignment otherwise).
+     */
+    get sourceUri() {
+        return this._sourceUri;
+    }
+    get sourceRoot() {
+        return this._sourceRoot;
+    }
+    /**
+     * The language services of the grammar this DIAGRAM TYPE edits, as declared
+     * by `AbstractHydraniumGlspDiagramModule.declareLanguage`.
+     *
+     * **Named for what it is, not for "the language".** Reach for it only when
+     * the thing you are asking about lives in the diagram document itself.
+     * Anything reached *through* a reference is decided by its own document: use
+     * {@link languageServicesFor}. Making that choice explicit at the call site
+     * is the point; a neutral-looking `languageServices` invites the diagram's
+     * grammar to be applied to a foreign node, which is the defect this whole
+     * seam exists to prevent.
+     *
+     * Injected rather than derived from {@link sourceUri} so it is available
+     * before the first {@link setSourceRoot} — GLSP constructs operation
+     * handlers at `InitializeClientSession`, well before `RequestModelAction`.
+     * `@optional()` so a harness that binds no diagram module still resolves;
+     * `undefined` then means no diagram module declared a grammar.
+     */
+    diagramLanguage;
+    /**
+     * The language services owning `target` — an AST node (routed by its
+     * document), a URI, or a URI string — falling back to
+     * {@link diagramLanguage} when `target` routes nowhere.
+     *
+     * Use this wherever the thing being named, keyed or completed may live in
+     * another document than the diagram. Two registered languages are free to
+     * differ in `nameProperties` / `nameSeparator` and in their element-key
+     * strategy, so applying the diagram's provider to a foreign node yields a
+     * plausible-looking string that matches nothing — silently, with no
+     * diagnostic. The fallback covers the genuinely unroutable case, a synthetic
+     * node not yet attached to a document, where the diagram's own language is
+     * the only defensible answer.
+     */
+    languageServicesFor(target) {
+        return this.sharedServices.ServiceRegistry.getServicesFor(target) ?? this.diagramLanguage;
+    }
+    /**
+     * The `NameProvider` of the language owning `target` — the shorthand for
+     * `languageServicesFor(target)?.references.NameProvider`.
+     *
+     * The shorthands exist because the long form names `target` twice and
+     * threads an optional through a four-link chain, which is enough friction
+     * that the tempting alternative is a captured provider — the defect this
+     * seam exists to prevent. Keeping the correct call the SHORT one is the
+     * point. They stay provider-level rather than operation-level so they
+     * compose with every provider method and the state does not grow a naming
+     * API of its own.
+     */
+    nameProviderFor(target) {
+        return this.languageServicesFor(target)?.references.NameProvider;
+    }
+    /** The `ScopeProvider` of the language owning `target`. See {@link nameProviderFor}. */
+    scopeProviderFor(target) {
+        return this.languageServicesFor(target)?.references.ScopeProvider;
+    }
+    /** The `ReferenceCandidateProvider` of the language owning `target`. See {@link nameProviderFor}. */
+    candidateProviderFor(target) {
+        return this.languageServicesFor(target)?.references.CandidateProvider;
+    }
+    /**
+     * Warn when the loaded document does not route to the grammar this diagram
+     * module declared.
+     *
+     * The declared language is the one fact the module states that the grammar
+     * itself does not, so it is the one that can drift — a diagram type pointed
+     * at the wrong `LanguageMetaData`, or a file extension reassigned. Both
+     * would otherwise surface much later as references resolving against the
+     * wrong scope. Only a warning, not a throw: the document is loaded and
+     * usable either way, and a hard failure here would take out a diagram over
+     * a mismatch that may be intentional in an adopter serving one diagram type
+     * over several grammars.
+     */
+    checkDeclaredLanguage(uri) {
+        const declared = this.diagramLanguage?.LanguageMetaData.languageId;
+        if (declared === undefined) {
+            return;
+        }
+        const actual = this.sharedServices.ServiceRegistry.getServicesFor(uri)?.LanguageMetaData.languageId;
+        if (actual !== undefined && actual !== declared) {
+            this.tracer.warn(`Diagram module declares language '${declared}' but this document routes to '${actual}'`);
+        }
+    }
+    /** The observability handle as a plain {@link Logger} (a {@link Tracer} is-a Logger). */
+    get logger() {
+        return this.tracer;
+    }
+    /** URI-tagged once {@link setSourceRoot} has run; the class-tagged injected {@link baseTracer} before that. */
+    get tracer() {
+        return this._tracer ?? this.baseTracer;
+    }
+    /**
+     * Text-document version captured at the last {@link setSourceRoot}
+     * call. Mirrors the server-side `TextDocuments.version(uri)` counter
+     * at that point in time — frozen until the next `setSourceRoot`, then
+     * re-read from `LangiumDocuments`.
+     *
+     * Threaded by `HydraniumGlspRecordingCommand` into
+     * {@link updateSourceModel}'s optional `version` parameter so the
+     * downstream `ModelService.update` / `.save` call can opt into the
+     * conflict gate against the captured based-on version. See
+     * `@hydranium/protocol#ConflictError` for the detection contract.
+     *
+     * Falls back to `0` when the document is absent from `LangiumDocuments`
+     * at capture time — the same observable state callers see for a doc
+     * that was never opened. Callers that need to distinguish
+     * "never-versioned" from "v0" must consult the document registry
+     * directly.
+     */
+    get version() {
+        return this._version;
+    }
+    // ============================================================
+    // Secondary documents — the write set beyond the primary
+    // ============================================================
+    /**
+     * Register `uri` as a document this state also writes, capturing its current
+     * text-document version.
+     *
+     * A diagram whose layout lives in its own file, or whose canvas creates
+     * elements in a referenced semantic document, writes more than the document
+     * it was opened on. The primary (`sourceUri`) stays the one that drives
+     * GModel projection and the conflict gate; secondaries are the rest of the
+     * write set.
+     *
+     * Registering is the adopter's call because the set is usually discovered
+     * rather than known: the semantic document a node belongs to is only
+     * identified once the operation names the node. What the framework supplies
+     * is the part an adopter cannot reconstruct after the fact — the version each
+     * document was at BEFORE the command mutated anything (see
+     * {@link capturedVersionOf}). Idempotent; registering the primary is ignored,
+     * since {@link version} already tracks it. Registering a URI not already in
+     * the set fires {@link onSecondaryUrisChanged}.
+     */
+    trackSecondaryDocument(uri) {
+        if (uri === this._sourceUri) {
+            return;
+        }
+        const added = !this._secondaryVersions.has(uri);
+        this._secondaryVersions.set(uri, this.readDocumentVersion(uri));
+        if (added) {
+            this.secondaryUrisChangedEmitter.fire();
+        }
+    }
+    /**
+     * Drop every registered secondary. Call when the write set is rebuilt from
+     * scratch. Fires {@link onSecondaryUrisChanged} when the set was non-empty.
+     */
+    untrackSecondaryDocuments() {
+        if (this._secondaryVersions.size === 0) {
+            return;
+        }
+        this._secondaryVersions.clear();
+        this.secondaryUrisChangedEmitter.fire();
+    }
+    /**
+     * Fires whenever the secondary write set gains or loses a URI — never when a
+     * tracked document's captured version is merely refreshed, which happens on
+     * every {@link setSourceRoot} and changes nothing a subscriber cares about.
+     *
+     * **This exists so no caller has to know when the set can change.** The set is
+     * usually discovered rather than known, and the discovery point is an
+     * operation handler naming a node — not a capture. A subscriber that instead
+     * re-derived the set after each capture would miss exactly that case, and miss
+     * it silently: the document would simply never be watched, with nothing logged.
+     * Announcing the change here moves the obligation to the one place that can
+     * always discharge it.
+     *
+     * The set is the one {@link trackSecondaryDocument} /
+     * {@link untrackSecondaryDocuments} maintain. A subclass that writes
+     * {@link _secondaryVersions} directly bypasses the notification and owns the
+     * consequences.
+     */
+    get onSecondaryUrisChanged() {
+        return this.secondaryUrisChangedEmitter.event;
+    }
+    /** Registered secondary document URIs, in registration order. */
+    get secondaryUris() {
+        return [...this._secondaryVersions.keys()];
+    }
+    /**
+     * Based-on version captured for `uri` — {@link version} for the primary, the
+     * value captured at {@link trackSecondaryDocument} (refreshed by
+     * {@link setSourceRoot}) for a secondary, `undefined` for anything untracked.
+     *
+     * `undefined` rather than `0` for an untracked URI deliberately: `0` is a real
+     * version meaning "present but never edited", so collapsing the two would let
+     * a caller gate a write against a document it never captured.
+     */
+    capturedVersionOf(uri) {
+        if (uri === this._sourceUri) {
+            return this._version;
+        }
+        return this._secondaryVersions.get(uri);
+    }
+    /**
+     * Read a document's current text-document version through the model service's
+     * canonicalizing gateway, so a URI spelled through a symlink still resolves to
+     * the document keyed by its real path rather than stranding at `0` (which
+     * would silently weaken the conflict gate). Optional-chained on `textDocument`
+     * so a fixture that omits it does not throw; real Langium documents always
+     * populate it.
+     */
+    readDocumentVersion(uri) {
+        return this.sharedServices.model.ModelService.getDocument(uri)?.textDocument?.version ?? 0;
+    }
+    /** Re-read every registered secondary's version from the document store. */
+    refreshSecondaryVersions() {
+        for (const uri of [...this._secondaryVersions.keys()]) {
+            this._secondaryVersions.set(uri, this.readDocumentVersion(uri));
+        }
+    }
+    /**
+     * Re-capture the source root from the current Langium document,
+     * replacing any orphaned root. A rebuild between an earlier
+     * {@link setSourceRoot} and the current read can swap the AST out
+     * from under us; downstream consumers (GModel factories, action
+     * handlers) must see the root the freshly built document carries.
+     */
+    refreshSourceRoot() {
+        if (!this._sourceUri) {
+            return;
+        }
+        const document = this.sharedServices.model.ModelService.getDocument(this._sourceUri);
+        // `parseResult.value` is the grammar's entry-rule root for a given URI
+        // (even on parse errors), so we cast to `TRoot` rather than runtime-guard
+        // it — the same cast the encoder makes on `parseResult.value`. The
+        // load-bearing check is the identity test that skips an unchanged root.
+        const root = document?.parseResult.value;
+        if (root !== undefined && root !== this._sourceRoot) {
+            this.setSourceRoot(this._sourceUri, root);
+        }
+    }
+    /**
+     * Wait until the captured document reaches `state`, then run
+     * {@link onReadyRefreshed} so consumers see a fresh AST. Wraps the
+     * wait in {@link Tracer.time} for observability.
+     */
+    async ready(state) {
+        await this.tracer.time(`Wait for state '${DocumentState[state]}'`, () => this.readyWithTimeout(state), 'debug');
+        await this.onReadyRefreshed();
+    }
+    /**
+     * Race `ModelService.waitForDocumentState` against
+     * {@link readyTimeoutMs}. If the timeout fires but the document has
+     * already reached `state` silently (Langium build-phase event race),
+     * log a warning and resolve; otherwise raise
+     * {@link ModelReadyTimeoutError} via {@link buildReadyTimeoutError}.
+     */
+    async readyWithTimeout(state) {
+        const uri = this._sourceUri;
+        const stopwatch = this.sharedServices.Clock.stopwatch();
+        let timer;
+        const timeout = new Promise((resolve, reject) => {
+            timer = this.sharedServices.Clock.setTimer(() => {
+                const elapsed = Math.round(stopwatch.elapsedMs);
+                // Via the canonicalizing gateway (see `readDocumentVersion`), so a
+                // symlinked `_sourceUri` is not reported as a hard timeout.
+                const doc = this.sharedServices.model.ModelService.getDocument(uri);
+                if (doc && doc.state >= state) {
+                    this.logger.warn(`Missed '${DocumentState[state]}' notification after ${elapsed}ms; document is already at state ` +
+                        `'${DocumentState[doc.state]}'. Likely a Langium build-phase event race.`);
+                    resolve();
+                }
+                else {
+                    reject(this.buildReadyTimeoutError(state, elapsed));
+                }
+            }, this.readyTimeoutMs);
+        });
+        try {
+            await Promise.race([this.sharedServices.model.ModelService.waitForDocumentState(uri, state), timeout]);
+        }
+        finally {
+            timer?.dispose();
+        }
+    }
+    /**
+     * Hook for post-{@link ready} work. Default refreshes the captured
+     * source root via {@link refreshSourceRoot} so submission handlers and
+     * GModel factories see the AST the now-ready document carries.
+     * Adopters whose AST is immutable between build phases override to a
+     * no-op.
+     */
+    async onReadyRefreshed() {
+        this.refreshSourceRoot();
+    }
+    /**
+     * Build the {@link ModelReadyTimeoutError} thrown by
+     * {@link readyWithTimeout}. Reports the workspace-relative path plus the
+     * document builder's current build-status snapshot, both via framework
+     * methods — so adopters that override `WorkspaceManager.wsRelativePath` /
+     * `DocumentBuilder.formatBuildStatus` for richer output get it here without
+     * touching this method. Override only to change the error shape itself.
+     */
+    buildReadyTimeoutError(state, elapsed) {
+        const workspace = this.sharedServices.workspace;
+        const shortPath = workspace.WorkspaceManager.wsRelativePath(this._sourceUri);
+        const status = workspace.DocumentBuilder.formatBuildStatus(URI.parse(this._sourceUri));
+        return new ModelReadyTimeoutError(shortPath, DocumentState[state], elapsed, status);
+    }
+};
+__decorate([
+    inject(HydraniumTypes.SharedCoreServices),
+    __metadata("design:type", Object)
+], AbstractHydraniumGlspState.prototype, "sharedServices", void 0);
+__decorate([
+    inject(HydraniumTypes.ConflictResolver),
+    __metadata("design:type", Object)
+], AbstractHydraniumGlspState.prototype, "conflictResolver", void 0);
+__decorate([
+    inject(HydraniumTypes.Tracer),
+    __metadata("design:type", Object)
+], AbstractHydraniumGlspState.prototype, "baseTracer", void 0);
+__decorate([
+    inject(HydraniumTypes.DiagramLanguage),
+    optional(),
+    __metadata("design:type", Object)
+], AbstractHydraniumGlspState.prototype, "diagramLanguage", void 0);
+AbstractHydraniumGlspState = AbstractHydraniumGlspState_1 = __decorate([
+    injectable()
+], AbstractHydraniumGlspState);
+export { AbstractHydraniumGlspState };
+//# sourceMappingURL=abstract-hydranium-glsp-state.js.map

package/lib/state/abstract-hydranium-glsp-state.js.map

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

package/lib/state/full-text-hydranium-glsp-state.d.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * 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 JsonModelState } from '@eclipse-glsp/server';
+import { type AstNode } from '@hydranium/langium';
+import { type MaybePromise } from '@hydranium/protocol';
+import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
+/** Whole-document-text source model: the serialised text of the source root. */
+export interface FullTextSourceModel {
+    text: string;
+}
+/**
+ * Editable GLSP state for adopters whose source model is the **whole document
+ * text** — the source root serialised to its textual form, round-tripped by
+ * re-parsing. The simplest of the framework source-model strategies (the others
+ * project a structured transfer model, over one document or several), and the
+ * natural starting point for a new adopter.
+ *
+ * Fully generic — both seams resolve through shared services, so adopters add
+ * nothing beyond narrowing `TRoot` and their index:
+ * - {@link sourceModel} serialises the source root through the per-URI
+ *   `serializer.Serializer` reached via `sharedServices.ServiceRegistry`
+ *   (so multi-grammar workspaces route to the right serializer). `MaybePromise`
+ *   because serialization may be async; the sync fast path is preserved.
+ * - {@link updateSourceModel} pushes the text back through
+ *   `ModelService.update` (which accepts a raw text payload) and captures the
+ *   re-parsed root.
+ *
+ * No `baseline` / conflict reconcile: a whole-document model has exactly one
+ * field, so every concurrent edit is a same-field collision and undo / redo
+ * degrade to drop-on-divergence. Adopters that need field-level undo use
+ * `ReconcilingTransferHydraniumGlspState` instead.
+ */
+export declare class FullTextHydraniumGlspState<TRoot extends AstNode> extends AbstractHydraniumGlspState<TRoot, FullTextSourceModel> implements JsonModelState<FullTextSourceModel> {
+    get sourceModel(): MaybePromise<FullTextSourceModel>;
+    updateSourceModel(model: FullTextSourceModel): Promise<void>;
+}
+//# sourceMappingURL=full-text-hydranium-glsp-state.d.ts.map

package/lib/state/full-text-hydranium-glsp-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"full-text-hydranium-glsp-state.d.ts","sourceRoot":"","sources":["../../src/state/full-text-hydranium-glsp-state.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAEhF,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IACjC,IAAI,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,0BAA0B,CAAC,KAAK,SAAS,OAAO,CAC1D,SAAQ,0BAA0B,CAAC,KAAK,EAAE,mBAAmB,CAC7D,YAAW,cAAc,CAAC,mBAAmB,CAAC;IAE9C,IAAI,WAAW,IAAI,YAAY,CAAC,mBAAmB,CAAC,CAInD;IAEK,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAQpE"}

package/lib/state/full-text-hydranium-glsp-state.js

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+import { URI } from '@hydranium/langium';
+import { isPromiseLike } from '@hydranium/protocol';
+import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
+/**
+ * Editable GLSP state for adopters whose source model is the **whole document
+ * text** — the source root serialised to its textual form, round-tripped by
+ * re-parsing. The simplest of the framework source-model strategies (the others
+ * project a structured transfer model, over one document or several), and the
+ * natural starting point for a new adopter.
+ *
+ * Fully generic — both seams resolve through shared services, so adopters add
+ * nothing beyond narrowing `TRoot` and their index:
+ * - {@link sourceModel} serialises the source root through the per-URI
+ *   `serializer.Serializer` reached via `sharedServices.ServiceRegistry`
+ *   (so multi-grammar workspaces route to the right serializer). `MaybePromise`
+ *   because serialization may be async; the sync fast path is preserved.
+ * - {@link updateSourceModel} pushes the text back through
+ *   `ModelService.update` (which accepts a raw text payload) and captures the
+ *   re-parsed root.
+ *
+ * No `baseline` / conflict reconcile: a whole-document model has exactly one
+ * field, so every concurrent edit is a same-field collision and undo / redo
+ * degrade to drop-on-divergence. Adopters that need field-level undo use
+ * `ReconcilingTransferHydraniumGlspState` instead.
+ */
+let FullTextHydraniumGlspState = class FullTextHydraniumGlspState extends AbstractHydraniumGlspState {
+    get sourceModel() {
+        const serializer = this.sharedServices.ServiceRegistry.getServices(URI.parse(this._sourceUri)).serializer.Serializer;
+        const text = serializer.serializeAst(this._sourceRoot);
+        return isPromiseLike(text) ? text.then(value => ({ text: value })) : { text };
+    }
+    async updateSourceModel(model) {
+        const document = await this.sharedServices.model.ModelService.update({
+            uri: this._sourceUri,
+            model: model.text,
+            clientId: this.clientId
+        });
+        this.setSourceRoot(this._sourceUri, document.root);
+    }
+};
+FullTextHydraniumGlspState = __decorate([
+    injectable()
+], FullTextHydraniumGlspState);
+export { FullTextHydraniumGlspState };
+//# sourceMappingURL=full-text-hydranium-glsp-state.js.map

package/lib/state/full-text-hydranium-glsp-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"full-text-hydranium-glsp-state.js","sourceRoot":"","sources":["../../src/state/full-text-hydranium-glsp-state.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;;;;;;;AAGlF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAE,aAAa,EAAqB,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAOhF;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEI,IAAM,0BAA0B,GAAhC,MAAM,0BACV,SAAQ,0BAAsD;IAG9D,IAAI,WAAW;QACZ,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;QACrH,MAAM,IAAI,GAAG,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACvD,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IACjF,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,KAA0B;QAC/C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC;YAClE,GAAG,EAAE,IAAI,CAAC,UAAU;YACpB,KAAK,EAAE,KAAK,CAAC,IAAI;YACjB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACzB,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAa,CAAC,CAAC;IAC/D,CAAC;CACH,CAAA;AAlBY,0BAA0B;IADtC,UAAU,EAAE;GACA,0BAA0B,CAkBtC"}