@hydranium/glsp-server 1.0.0-next.28 → 1.0.0-next.280

package/lib/state/abstract-hydranium-glsp-state.d.ts

@@ -8,9 +8,11 @@
  ********************************************************************************/
 import { DefaultModelState, type MaybePromise } from '@eclipse-glsp/server';
 import { Emitter, type Event } from 'vscode-jsonrpc';
-import { type AstNode, DocumentState } from '@hydranium/langium';
-import { type HydraniumScopeProvider, type LanguageTarget, type NameProvider, type ReferenceCandidateProvider, type ServerLanguageServices, type ServerSharedServices } from '@hydranium/core';
-import type { ConflictResolver, Logger, Tracer } from '@hydranium/protocol';
+import { type AstNode, DocumentState, type Reference, type ReferenceInfo } from '@hydranium/langium';
+import { type ClientSession, type HydraniumScopeProvider, type LanguageTarget, type NameProvider, type ReferenceCandidateProvider, type ServerLanguageServices, type ServerSharedServices } from '@hydranium/core';
+import { type BaseVersion, type ModelVersion, type ConflictResolver, type Logger, type Tracer, type TransferElement } from '@hydranium/protocol';
+import { type OperationTransition } from '../command/hydranium-glsp-operation-command.js';
+import { type DiagramStatus, type DiagramStatusEntry } from './diagram-status.js';
 import { type HydraniumGlspIndex } from './hydranium-glsp-index.js';
 import { ModelReadyTimeoutError } from './model-ready-timeout-error.js';
 /**
@@ -38,7 +40,7 @@ import { ModelReadyTimeoutError } from './model-ready-timeout-error.js';
  *   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
+ *   override `captureSourceRoot` and derive via
  *   `this.baseTracer.for('Name').withUri(uri)`.
  *
  * **Lifecycle ordering.** Reading {@link sourceUri} or {@link sourceRoot}
@@ -47,7 +49,7 @@ import { ModelReadyTimeoutError } from './model-ready-timeout-error.js';
  * (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} —
+ * before {@link captureSourceRoot} derives the URI-tagged {@link _tracer} —
  * logging is never `undefined`.
  */
 export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode, TSourceModel = string> extends DefaultModelState {
@@ -62,21 +64,69 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
      * `updateSourceModel` implementations.
      */
     readonly conflictResolver: ConflictResolver;
+    /**
+     * Writes of one diagram edit, the first included, that may conflict before
+     * the edit is dropped with a warning; each further write reconciles again.
+     */
+    protected readonly maxSourceModelWrites: number;
     /**
      * Per-class tracer, caller-tagged with this state's runtime subclass name by
-     * the `HydraniumTypes.Tracer` binding. {@link setSourceRoot} derives the
+     * the `HydraniumTypes.Tracer` binding. {@link captureSourceRoot} 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`.
      */
     protected readonly baseTracer: Tracer;
     /** Narrows {@link DefaultModelState.index} to the framework-extended index type. */
     readonly index: HydraniumGlspIndex;
+    /**
+     * The client session this diagram works as, registered under `clientId` by
+     * the source-model storage's load and ended with the GLSP client session,
+     * or by a resume that takes it over. `undefined` before the load, for
+     * GLSP's placeholder client, and when another participant held the id, in
+     * which case the diagram does not load.
+     *
+     * Every write of the diagram goes through this session, which writes only a
+     * document it has open and opens nothing. A one-shot write to a document
+     * outside the write set goes through
+     * {@link ClientSession.withOpen}, and a document the diagram brings into
+     * existence through {@link ClientSession.create}.
+     */
+    modelSession?: ClientSession<AstNode>;
+    /**
+     * {@link modelSession}, or a throw without one: the diagram never loaded or
+     * has ended. Looking `clientId` up through `ModelService.getSession` instead
+     * would write as whichever participant holds that id.
+     */
+    protected requireModelSession(): ClientSession<AstNode>;
     protected _sourceUri: string;
+    /**
+     * The language {@link _sourceUri} routed to at the last capture, or
+     * `undefined` when it routes nowhere. Captured rather than looked up on
+     * each {@link diagramLanguage} read, which a GModel factory may make once
+     * per element, because the lookup parses the URI and walks the registry.
+     */
+    protected _sourceLanguage?: ServerLanguageServices;
+    /**
+     * The root the last capture took, which every reader of the document
+     * shares. A projection that must see an operation's edits reads
+     * {@link sourceRoot}, which is a copy of it during an operation.
+     */
     protected _sourceRoot: TRoot;
+    /** Settles when the last {@link runExclusive} call queued so far has. */
+    protected exclusiveTail: Promise<unknown>;
     protected _tracer?: Tracer;
-    protected _version: number;
-    /** Based-on versions of the secondary write set, keyed by URI. See {@link trackSecondaryDocument}. */
-    protected readonly _secondaryVersions: Map<string, number>;
+    protected _baseVersion: ModelVersion;
+    /**
+     * The built root each secondary's version was read from, keyed by
+     * canonical URI, and during an operation the root of any other document it
+     * first reached. An operation copies a secondary from here, so the copy,
+     * the base a conflict reconciles from and the version its write is gated
+     * on describe one revision; the registry's current root can be a later
+     * build's.
+     */
+    protected readonly capturedRoots: Map<string, AstNode>;
+    /** Model versions of the secondary write set, keyed by URI. See {@link trackSecondaryDocument}. */
+    protected readonly _secondaryVersions: Map<string, ModelVersion>;
     /** Backing emitter for {@link onSecondaryUrisChanged}; fired only on a membership change. */
     protected readonly secondaryUrisChangedEmitter: Emitter<void>;
     /** Default of one minute. */
@@ -84,45 +134,148 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
     /** Maximum wait inside {@link readyWithTimeout} before raising {@link ModelReadyTimeoutError}. */
     protected readyTimeoutMs: number;
     /**
-     * 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.
+     * Capture a freshly built source root alongside its URI through
+     * {@link captureSourceRoot}, and index the AST so downstream GModel
+     * projection can resolve elements back to nodes.
+     *
+     * Capturing the document already captured keeps what the last GModel build
+     * registered in the index, which only the next build makes again, and drops
+     * an id added through `indexSemanticElement` whose node a rebuild replaced.
      *
-     * 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.
+     * Throws during an operation: a capture there swaps the root out from under
+     * the nodes a handler resolved, and the operation captures when it ends.
      */
     setSourceRoot(uri: string, root: TRoot): void;
+    /**
+     * Take `root` as the source root and read everything derived from it: the
+     * base version, every tracked secondary version, the URI mirrored into the
+     * inherited properties map under {@link SOURCE_URI_ARG}, and the
+     * URI-labelled logger. Everything but the index, which
+     * {@link setSourceRoot} sets. Override to derive more from a capture.
+     */
+    protected captureSourceRoot(uri: string, root: TRoot): void;
     /**
      * Typed override of {@link DefaultModelState.sourceUri}. Narrows the
      * inherited `string | undefined` to `string` (defined after
      * {@link setSourceRoot}; throws on definite-assignment otherwise).
      */
     get sourceUri(): string;
+    /** The root operation handlers edit: during an operation a copy of the built root, outside one the built root. */
     get sourceRoot(): TRoot;
     /**
-     * The language services of the grammar this DIAGRAM TYPE edits, as declared
-     * by `AbstractHydraniumGlspDiagramModule.declareLanguage`.
+     * Run `run` once every earlier call has settled, thrown or not: the
+     * boundary that orders operations, undo and redo, and the storage's capture
+     * and render. Code running inside it never calls this again, since the
+     * call would wait for the section it runs in.
+     */
+    runExclusive<T>(run: () => MaybePromise<T>): Promise<T>;
+    /**
+     * The root of `uri` that operation handlers edit: during an operation a
+     * copy made on the first request and returned for the rest of it, outside
+     * one the root itself. The root is the built root of `uri`, or `orElse()`
+     * when `uri` has no document; `undefined` when neither gives one.
      *
-     * **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.
+     * A handler that edits another document than the source reaches its root
+     * through this, or the edit lands on the root every reader shares. An id
+     * added through `indexSemanticElement` for a node of that root names the
+     * node's copy from then on.
+     */
+    workingRootOf(uri: string, orElse?: () => AstNode | undefined): AstNode | undefined;
+    /** The copy of `uri` the open operation made, without making one. */
+    protected existingWorkingRootOf(uri: string): AstNode | undefined;
+    /**
+     * The key of `uri` among an operation's copies: its canonical form, so two
+     * spellings of one document share one copy.
+     */
+    protected workingKey(uri: string): string;
+    /**
+     * The built node `node` was copied from during an operation; `node` itself
+     * for a built node, for a node the operation created, and outside one.
      *
-     * 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.
+     * A copy has no `$document`, so a lookup that reads its document, scope or
+     * project throws or answers for no document. Handlers pass the built node
+     * there and keep editing the copy. A candidate query takes
+     * {@link referenceInfoOf} instead, since a created node has no built node.
+     */
+    builtNodeOf<T extends AstNode>(node: T): T;
+    /**
+     * A reference to `target` whose `ref` is `target` itself, a copy node
+     * included, so an identity comparison later in the operation finds it.
+     * `undefined` when no reference can be formed. Outside an operation the
+     * nodes are built ones and this is the `ReferenceBuilder`'s answer as is.
+     *
+     * With `tier: 'own'` the `$refText` is the target's own name as
+     * `toOwnReference` gives it, read off `target` itself, so a name the
+     * operation edited is the one written; the builder is the target's
+     * language's, which a copy node, having no `$document`, would not otherwise
+     * reach. `source` plays no part in that tier.
+     *
+     * By default it is `getReferenceName` from `source`'s context, with the
+     * builder of `source`'s language, since `$refText` encoding follows the
+     * grammar writing it. That call reads both nodes' projects, to pick the
+     * qualification and to refuse a reference across projects the target's is
+     * not visible to, and a copy node has none; so it is asked about the built
+     * target, which names a target as built, before any rename in the
+     * operation, and about {@link builtContextOf} the source. A target the
+     * operation created has no built node, and is asked about without a
+     * project.
+     */
+    referenceTo<T extends AstNode>(target: T, source?: AstNode, options?: {
+        readonly tier?: 'own';
+    }): Reference<T> | undefined;
+    /**
+     * A candidate query for `property` of `node`, to pass to
+     * `candidateProviderFor(node)?.find`. It is asked from the built node, and
+     * for a node the operation created from a stand-in of its type under the
+     * built containers it sits in, one per created level: a scope reads local
+     * names off every container up the chain, so anchoring higher drops them.
+     * A protocol context cannot express this: an element source resolves only
+     * through a `resolveElementByName` override, and through the index only
+     * for the nodes it exports. `undefined` for a node in no document and no
+     * copy, such as one not attached yet.
+     */
+    referenceInfoOf(node: AstNode, property: string): ReferenceInfo | undefined;
+    /**
+     * The built node of `node`, or of its nearest container that has one: a
+     * node the operation created has no built node, but its container's
+     * document and project are its own.
      */
-    readonly diagramLanguage?: ServerLanguageServices;
+    protected builtContextOf(node: AstNode): AstNode;
+    /**
+     * Take `root`, which a write of this state's own produced, as the source
+     * root; during an operation the operation takes it and captures it when it
+     * ends.
+     */
+    protected captureWrittenRoot(root: TRoot): void;
+    /**
+     * Resync after a write whose reconcile dropped the edit: during an
+     * operation the operation undoes its side effects, pushes nothing, and
+     * captures the document's current root when it ends.
+     */
+    protected writeDropped(): void;
+    /**
+     * Whether `node` belongs to the root its document is built to now, or to no
+     * document; a root a rebuild replaced holds only stale nodes.
+     */
+    protected isCurrentBuiltNode(node: AstNode): boolean;
+    /**
+     * The language services of the diagram document: the language
+     * {@link sourceUri} routed to at the last {@link setSourceRoot}.
+     *
+     * `undefined` until a document is loaded, as GLSP builds a session's
+     * handlers at `InitializeClientSession`, before `RequestModelAction`
+     * supplies the URI: read it when called, not at construction.
+     *
+     * 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}.
+     */
+    get diagramLanguage(): ServerLanguageServices | undefined;
     /**
      * 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.
+     * document), a URI, or a URI string — falling back, for a node, to the
+     * language the index read from the diagram's root, and otherwise 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
@@ -132,6 +285,9 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
      * 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.
+     *
+     * A node routes through {@link HydraniumGlspIndex.languageServicesFor}, so
+     * an override of the index's routing applies here too.
      */
     languageServicesFor(target: LanguageTarget | undefined): ServerLanguageServices | undefined;
     /**
@@ -151,46 +307,35 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
     scopeProviderFor(target: LanguageTarget | undefined): HydraniumScopeProvider | undefined;
     /** The `ReferenceCandidateProvider` of the language owning `target`. See {@link nameProviderFor}. */
     candidateProviderFor(target: LanguageTarget | undefined): ReferenceCandidateProvider | undefined;
-    /**
-     * 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.
-     */
-    protected checkDeclaredLanguage(uri: string): void;
     /** The observability handle as a plain {@link Logger} (a {@link Tracer} is-a Logger). */
     get logger(): Logger;
-    /** URI-tagged once {@link setSourceRoot} has run; the class-tagged injected {@link baseTracer} before that. */
+    /** URI-tagged once a source root is captured; the class-tagged injected {@link baseTracer} before that. */
     get tracer(): Tracer;
     /**
-     * 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`.
+     * Model version of the root the last {@link captureSourceRoot} took,
+     * frozen until the next one.
      *
-     * 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
+     * The base an operation's write is gated on, taken when the operation
+     * opens; nothing captures during an operation, so it is the version of the
+     * root the operation's copies were made from. 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.
+     * **This, not a number read at write time, is what a write must be gated
+     * on.** A version read when the write is issued is the store's current one,
+     * so it matches by construction and the gate can never fire.
+     */
+    get baseVersion(): ModelVersion;
+    /**
+     * {@link baseVersion} as a plain number: the store's version of the text the
+     * root was parsed from.
+     *
+     * `UNRECORDED_VERSION` when the document was not built when the snapshot
+     * was taken, which no write matches.
      */
     get version(): number;
     /**
-     * Register `uri` as a document this state also writes, capturing its current
-     * text-document version.
+     * Register `uri` as a document this state also writes, snapshotting 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
@@ -203,7 +348,7 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
      * 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,
+     * {@link baseVersionOf}). Idempotent; registering the primary is ignored,
      * since {@link version} already tracks it. Registering a URI not already in
      * the set fires {@link onSecondaryUrisChanged}.
      */
@@ -215,14 +360,15 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
     untrackSecondaryDocuments(): void;
     /**
      * 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.
+     * tracked document's model version is merely refreshed, which happens on
+     * every {@link captureSourceRoot} 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.
+     * operation handler naming a node — not a read of the source root. A
+     * subscriber that instead re-derived the set after each such read 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.
      *
@@ -234,27 +380,53 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
     get onSecondaryUrisChanged(): Event<void>;
     /** Registered secondary document URIs, in registration order. */
     get secondaryUris(): readonly string[];
+    /** Active statuses, least recently set first. See {@link setStatus}. */
+    protected readonly statuses: Map<DiagramStatus, DiagramStatusEntry>;
+    /** Backing emitter for {@link onStatusChanged}. */
+    protected readonly statusChangedEmitter: Emitter<void>;
     /**
-     * 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.
+     * Set `status`'s entry, or withdraw it with `undefined`, and recompute
+     * {@link currentStatus} and {@link editMode} from every active entry.
      *
-     * `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.
+     * `editMode` is derived here and nowhere else: a writer that assigns it
+     * directly is overwritten by the next status change, and its write is not
+     * announced on {@link onStatusChanged}.
      */
-    capturedVersionOf(uri: string): number | undefined;
+    setStatus(status: DiagramStatus, entry: DiagramStatusEntry | undefined): void;
+    /** The active entry whose message the client shows: highest severity, then most recently set. */
+    get currentStatus(): DiagramStatusEntry | undefined;
+    /** The active statuses that block editing; empty while the diagram is editable. */
+    get readonlyStatuses(): DiagramStatus[];
+    /** The status that supplies {@link currentStatus}, for a log line naming it. */
+    get currentStatusSource(): DiagramStatus | undefined;
+    /** Fires when {@link currentStatus} or {@link editMode} changes. */
+    get onStatusChanged(): Event<void>;
     /**
-     * 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.
+     * The base version of a write of `uri`: {@link baseVersion} for the primary,
+     * the version taken at {@link trackSecondaryDocument} (refreshed by
+     * {@link captureSourceRoot}) for a secondary, `undefined` for anything untracked.
+     *
+     * `undefined` rather than v0 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 this state never read.
      */
-    protected readDocumentVersion(uri: string): number;
-    /** Re-read every registered secondary's version from the document store. */
+    baseVersionOf(uri: string): ModelVersion | undefined;
+    /** Re-take every registered secondary's built root and the model version of that root. */
     protected refreshSecondaryVersions(): void;
+    /**
+     * The built root of `uri`, looked up through the model service's
+     * canonicalizing gateway so a symlinked URI does not strand without one;
+     * `undefined` for a URI with no parsed document, whose version is then
+     * `UNRECORDED_VERSION`, which no write matches. The store counts a file it
+     * has not built at `0`, and so does the placeholder the builder registers
+     * before its parse, and a write based on `0` overwrites text this state
+     * never read.
+     */
+    protected readBuiltRoot(uri: string): AstNode | undefined;
+    /** Take `root` as the secondary `uri` was read at, and its version, `UNRECORDED_VERSION` without one. */
+    protected recordSecondary(uri: string, root: AstNode | undefined): void;
+    /** The root the secondary `uri` was read at; see {@link capturedRoots}. */
+    protected capturedRootOf(uri: string): AstNode | undefined;
     /**
      * Re-capture the source root from the current Langium document,
      * replacing any orphaned root. A rebuild between an earlier
@@ -263,18 +435,38 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
      * handlers) must see the root the freshly built document carries.
      */
     protected refreshSourceRoot(): void;
+    /**
+     * The root that `uri`'s text parses to (the text store's, or the built
+     * document's when the store holds none) and the store's version of that
+     * text, read once the document has validated; `undefined` when it cannot be
+     * read. The version is read in the tick the text is, so a write based on it
+     * conflicts with any edit made after.
+     *
+     * **Parsed afresh, never the built root.** The built root can lag the
+     * store, and a root behind the text it is versioned with makes the replay
+     * drop the edits it lacks. The root is parsed, not linked: an encoder hook
+     * reading a reference's `ref` sees `undefined` on it.
+     */
+    protected readCurrentRoot(uri: string): Promise<{
+        root: AstNode;
+        version: ModelVersion;
+    } | undefined>;
     /**
      * 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.
+     *
+     * A source not in the document registry is built first, through
+     * `ModelService.rebuild`. For a source with neither a file nor text, that
+     * build leaves no document, and this rejects rather than timing out.
      */
     ready(state: DocumentState): Promise<void>;
     /**
-     * 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}.
+     * Race `ModelService.ensureDocumentState`, which builds a root behind its
+     * text, against {@link readyTimeoutMs}. If the timeout fires but the
+     * document has already reached `state`, log a warning naming the cause, a
+     * root behind its text or a missed phase event, and resolve; otherwise
+     * raise {@link ModelReadyTimeoutError} via {@link buildReadyTimeoutError}.
      */
     protected readyWithTimeout(state: DocumentState): Promise<void>;
     /**
@@ -295,11 +487,13 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
      */
     protected buildReadyTimeoutError(state: DocumentState, elapsed: number): ModelReadyTimeoutError;
     /**
-     * Persist a new source-model representation back to the document store
-     * after an interactive edit. Adopters wire this against their
-     * language-services facade. The `HydraniumGlspRecordingCommand` calls
-     * it from its `postChange` hook to commit the edited AST back to the
-     * document store.
+     * Persist a new source-model representation back to the document store after
+     * an interactive edit. Adopters wire this against their language-services
+     * facade. An operation calls it once, with the model projected from its
+     * copies; an undo or redo calls it with the transition resolved onto the
+     * current model. An implementation takes the root it wrote through
+     * {@link captureWrittenRoot}, which during an operation leaves the capture
+     * to the operation.
      *
      * Adopters whose source model is a structured transfer projection
      * round-tripped through `ModelService` should extend
@@ -320,14 +514,30 @@ export declare abstract class AbstractHydraniumGlspState<TRoot extends AstNode,
      * `JsonModelState` shape meet the framework state via structural
      * intersection at the recording-command call site.
      *
-     * `version` is the based-on text-document version captured at command
-     * start by `HydraniumGlspRecordingCommand.execute`. Adopters that
-     * route through `ModelService.update` / `.save` pass it as the args'
-     * `version` field to opt into the conflict gate; adopters that don't
-     * care (or whose write path doesn't go through `ModelService`) ignore
-     * the parameter. Undefined when the writer is not the recording-command
-     * (e.g. external storage refresh paths).
-     */
-    abstract updateSourceModel(model: TSourceModel, version?: number): MaybePromise<void>;
+     * `baseVersion` is what the write was authored against: an operation's
+     * write, and an undo's or redo's, passes the {@link baseVersion} it read
+     * the model at. Adopters that write through the diagram's session forward
+     * it as the args' `baseVersion` field; adopters whose write path doesn't go
+     * through the session ignore it.
+     *
+     * **Optional, and every implementation must default it to {@link baseVersion}
+     * rather than to `'any'`.** Optional is forced: GLSP's `JsonModelState`
+     * declares a one-parameter `updateSourceModel` and calls it with one
+     * argument, so a second required parameter makes the state unassignable to
+     * the slot it has to fill. Defaulting to the state's own model version is
+     * what keeps that from costing anything — an operation handler calling
+     * `updateSourceModel(model)` gets the gate, and skipping it has to be typed
+     * out as `'any'`.
+     */
+    abstract updateSourceModel(model: TSourceModel, baseVersion?: BaseVersion): MaybePromise<void>;
+    /**
+     * `transition` as the documents would hold both ends after a write. A
+     * serializer may normalize what it writes, provided normalizing again
+     * changes nothing; an end left as recorded makes an undo or redo conflict
+     * with the write it follows. Default: unchanged.
+     */
+    normalizeTransition(transition: OperationTransition<TSourceModel>): Promise<OperationTransition<TSourceModel>>;
+    /** The root `model` parses back to once serialized for `uri`, as a write would leave it; nothing is written. */
+    protected roundTrip(uri: string, model: TransferElement): Promise<AstNode>;
 }
 //# sourceMappingURL=abstract-hydranium-glsp-state.d.ts.map

package/lib/state/abstract-hydranium-glsp-state.d.ts.map

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