@hydranium/core 1.0.0-next.10

package/lib/langium/language-types.js.map

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

package/lib/langium/model-service/index.d.ts

@@ -0,0 +1,10 @@
+/********************************************************************************
+ * 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 './model-service.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/langium/model-service/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/langium/model-service/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,cAAc,oBAAoB,CAAC"}

package/lib/langium/model-service/index.js

@@ -0,0 +1,10 @@
+/********************************************************************************
+ * 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 './model-service.js';
+//# sourceMappingURL=index.js.map

package/lib/langium/model-service/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/langium/model-service/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,cAAc,oBAAoB,CAAC"}

package/lib/langium/model-service/model-service.d.ts

@@ -0,0 +1,598 @@
+/********************************************************************************
+ * 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 CanonicalUri, type CloseModelArgs, type MaybeObservableValue, type MaybePromise, ObservableValue, type TransferDiagnostic, type TransferElement, type OpenModelArgs, type Tracer, type TransferSaveArgs, type TransferUpdateArgs } from '@hydranium/protocol';
+import { type AstNode, DocumentState, type LangiumDocument, type URI } from '@hydranium/langium';
+import { type DocumentUriPolicy } from '../workspace/document-uri-policy.js';
+import { type CancellationToken, type Disposable } from 'vscode-languageserver';
+import { AstDocument, type AstDocumentSavedEvent, type AstDocumentUpdatedEvent } from '../../documents/ast-document-manager.js';
+import { type LogNameOptions } from '../diagnostics/logger.js';
+import { type ServerSharedServices } from '../module.js';
+/**
+ * Constructor options for {@link ModelService}. All fields are optional,
+ * and the defaults are the behaviour described on each one.
+ */
+export interface ModelServiceOptions extends LogNameOptions {
+    /**
+     * When set, {@link ModelService.update} logs a `warn` line if its
+     * end-to-end wait (serialise + content-change apply + rebuild +
+     * settled-phase wait) exceeds this many milliseconds. Default
+     * `undefined` (no warn line ever emitted; the underlying
+     * `Logger.time` debug timing log is unchanged either way).
+     *
+     * Pure observability — does NOT abort the update, does NOT change
+     * resolution semantics. Adopters wanting a hard timeout that throws
+     * instead override {@link ModelService.update} on their subclass and
+     * race the parent call against their own deadline.
+     *
+     * Recommended starting threshold: 2-5 seconds for interactive paths
+     * (form save, diagram edit). Workspaces with very large documents
+     * or slow validation may legitimately exceed 5s on the cold path —
+     * tune per workspace.
+     *
+     * Accepts a {@link MaybeObservableValue} so the threshold can be a
+     * fixed constant or bound to a user setting via `Settings.number`
+     * and retuned live. Leaving it unset disables the warn line entirely
+     * (and skips the per-update stopwatch).
+     */
+    readonly slowUpdateWarnMs?: MaybeObservableValue<number>;
+    /**
+     * Serialise the facade's own build under the workspace WRITE lock, the way
+     * Langium's `DefaultDocumentUpdateHandler` dispatches its build. Default
+     * `true`.
+     *
+     * **Why it defaults on.** Unlocked, the facade's build races the LSP bridge's
+     * build of the same URI — both are legitimate (the bridge exists only under a
+     * `Connection`, so the facade stands in for it headless), but nothing
+     * serialises them, so both run a full validation pass and Langium appends the
+     * second onto the first. Every diagnostic is then duplicated, and the
+     * duplication compounds per rebuild. Serialised, Langium elides the second
+     * build entirely, so the redundant work goes too.
+     *
+     * **What `false` costs.** The facade's build is then unserialised and can run
+     * concurrently with the bridge's build of the same URI, so the affected
+     * documents are validated twice per write — double the validation work.
+     * Reported diagnostics stay correct even then, because
+     * `HydraniumDocumentBuilder.dedupeDiagnostics` collapses the byte-identical
+     * duplicates a repeated pass produces before any listener sees them; what this
+     * option removes is the wasted pass, not just its visible symptom.
+     *
+     * **What `false` buys.** `WorkspaceLock` is not reentrant. A caller that
+     * reaches `update` / `save` / `rebuild` while already holding the write lock —
+     * an integrity rule or build-phase pass that writes through this facade —
+     * deadlocks: acquiring the lock cancels the running holder, and the new
+     * acquisition then waits for that holder to release while the holder waits
+     * for this call. On `true` that shape is DETECTED and rejected with
+     * {@link ReentrantWriteLockError} rather than hanging, wherever a host
+     * installs a write-lock scope tracker (`@hydranium/core/node` does at entry
+     * load; see {@link isInsideWriteLock}). Setting `false` is the escape hatch
+     * for an adopter whose reentrant shape is unavoidable — nothing acquires the
+     * lock then, so there is nothing to be reentrant about; prefer it over
+     * unserialised builds only in that case.
+     *
+     * Accepts a {@link MaybeObservableValue} so it can be bound to a setting and
+     * flipped without a restart.
+     */
+    readonly serializeBuilds?: MaybeObservableValue<boolean>;
+}
+/**
+ * In-process facade over the framework's document plumbing
+ * (`HydraniumTextDocuments`, `LangiumDocuments`,
+ * `DocumentBuilder`, `WritableFileSystemProvider`). Owns the
+ * `open / request / update / save / ready` lifecycle that protocol heads
+ * (LSP, data-server, GLSP) delegate to so coordinating those primitives
+ * doesn't have to be re-implemented per-head.
+ *
+ * "Model" here means the parsed AST — distinct from the wire-shape
+ * `TransferDocument` in `@hydranium/protocol`.
+ *
+ * **Why a facade**
+ *
+ * Multiple in-process consumers want the same workspace-level
+ * operations:
+ * - The data-server head turns these into typed RPC methods.
+ * - The GLSP head uses the same lifecycle for diagram-driven edits;
+ *   GModel operation handlers route through `update` for AST mutation,
+ *   `waitForDocumentState` for indexed-phase waits before reads, etc.
+ * - Server-internal callers (integrity service, ad-hoc bridges, tests)
+ *   want the same operations without the wire serialisation step.
+ *
+ * Coordinating the primitives per-head drifts between heads — different
+ * superseded-version handling, different settled-phase choices, different
+ * content-change paths. The facade collapses that duplication and gives
+ * adopters one extension surface — {@link rewriteModel},
+ * {@link serialize} — to customise the in-process behaviour without
+ * re-implementing the plumbing.
+ *
+ * **Read-latest supersession**
+ *
+ * The default `update` and `save` flows use Langium's per-URI
+ * `DocumentBuilder.waitUntil` to wait for the integrity-settled landmark
+ * ({@link IntegrityService.SettledState}), then read the post-build state. Concurrent
+ * in-process callers on the same URI all see the latest post-build
+ * snapshot — none deadlock waiting for a specific version's settled
+ * event. Adopters wanting strict version-matched semantics (resolve
+ * with vN's snapshot specifically, log "vN superseded by vM at vN+1")
+ * override {@link update} to attach a phase-listener with explicit
+ * version checks; the framework default doesn't need it for safety.
+ *
+ * **Returns AST snapshots, not wire envelopes**
+ *
+ * The facade returns {@link AstDocument} (the in-process AST-typed
+ * envelope), not `TransferDocument` (the lossy wire shape). In-
+ * process callers consume `$container` / `Reference<T>` directly;
+ * encoding-on-return would be wasteful and would force the wire-side
+ * lossy `$refText` shape on every consumer. The wire-side caller
+ * (`DataServer.updateModelDocument` etc.) encodes once on return via
+ * the injected `TransferEncoder` — symmetric with the
+ * `getModelDocument` envelope path.
+ *
+ * **Subscriptions** ({@link onModelUpdated} / {@link onModelSaved} /
+ * {@link onClientClosed}) are thin pass-throughs over
+ * `DocumentBuilder.onDocumentPhase` and
+ * `HydraniumTextDocuments.onDidSave` / `onDidClose`. Filtering
+ * by URI happens here so consumers can subscribe per-document without
+ * implementing the URI gate at each callsite.
+ *
+ * **Generic parameters.**
+ * - `TAst` — the AST root type each consumer expects on the returned
+ *   {@link AstDocument}. Constrained to {@link AstNode}.
+ * - `TDiagnostic` — wire diagnostic shape used by the injected
+ *   `TransferEncoder`. Defaults to {@link TransferDiagnostic}.
+ * - `TTransfer` — transfer-model root accepted by `update` / `save`
+ *   args. Constrained to {@link TransferElement}. Defaults to the
+ *   structural base.
+ */
+export declare class ModelService<TAst extends AstNode, TDiagnostic = TransferDiagnostic, 
+/**
+ * Structured payload accepted by `update` / `save`. Constrained to
+ * {@link TransferElement} — the minimal `{ readonly $type: string }`
+ * shape. Both transfer-model overlay roots (which extend
+ * `TransferElement` explicitly) and AST root types (which have
+ * `$type: string` as a required `AstNode` field) satisfy the
+ * constraint, so in-process callers (e.g. GLSP state or an
+ * integrity service) that pass AST roots remain compatible.
+ */
+TTransfer extends TransferElement = TransferElement> {
+    protected readonly services: ServerSharedServices;
+    protected readonly tracer: Tracer;
+    /**
+     * The single document-identity seam (`services.workspace.DocumentUriPolicy`),
+     * cached for the public doors that canonicalize an incoming URI once before
+     * threading the resulting {@link CanonicalUri} through the internal cores. A
+     * field reference to the shared service, NOT a `canonicalUri` wrapper method —
+     * the wrapper was deliberately removed so canonicalisation has a single policy
+     * (see {@link DocumentUriPolicy}).
+     */
+    protected readonly uriPolicy: DocumentUriPolicy;
+    /**
+     * Live slow-update-warn threshold cell, or `undefined` when the option
+     * was not supplied (warn line + stopwatch disabled). Reads `.value` per
+     * update so a setting-bound threshold retunes without reconstruction.
+     */
+    protected readonly slowUpdateWarn?: ObservableValue<number>;
+    /** See {@link ModelServiceOptions.serializeBuilds}. Defaults to `true`. */
+    protected readonly serializeBuilds: ObservableValue<boolean>;
+    /**
+     * Per-URI applyEdit coalescing: at most one in-flight `applyEditToLanguageClient`
+     * RPC per URI, newest text wins. A newer settle while the current RPC is in
+     * flight overwrites {@link pendingSync}; the chain picks up the latest on its
+     * next iteration so the shadow never drifts from Monaco.
+     */
+    protected readonly syncChains: Map<string, Promise<void>>;
+    protected readonly pendingSync: Map<string, string>;
+    /**
+     * Workspace-level readiness gate. Resolves when the framework has
+     * finished its first workspace build cycle and the `ModelService`
+     * methods will behave predictably: per-URI waits resolve, queries
+     * return current snapshots, and the build pipeline is driving
+     * documents through phases.
+     *
+     * The default delegates to
+     * `services.workspace.WorkspaceManager.workspaceInitialized`, NOT to
+     * Langium's `WorkspaceManager.ready`. The difference is load-bearing:
+     * Langium resolves `ready` inside `performStartup`, once the workspace
+     * documents have been created but BEFORE `documentBuilder.build` runs, so
+     * `ready` does not mean "the first build cycle finished". A caller that
+     * gated a write on it could land that write mid-initial-build, where two
+     * things go wrong at once — the write's `WorkspaceLock.write` cancels the
+     * initial build, and the cancelled build's non-validating options are then
+     * inherited by the write's own build (see
+     * `HydraniumDocumentBuilder.prepareBuild`), so cross-document dependents
+     * are silently never validated. `workspaceInitialized` resolves after
+     * `initializeWorkspace` completes, build included, which is what this
+     * gate has always claimed to mean.
+     *
+     * Adopters that need a stricter gate (post-warm-load, AI model
+     * initialised, plugin warm-up) rebind the slot with a subclass and replace
+     * this field with a Promise that awaits both the workspace and the extra
+     * concern.
+     *
+     * Property (not method) — matches `ProjectManager.ready` and Langium's
+     * `WorkspaceManager.ready` conventions; the shape difference signals
+     * "in-process readiness" vs the wire-side `DataServer.waitForReady()`
+     * method (RPC operation).
+     */
+    readonly ready: Promise<void>;
+    constructor(services: ServerSharedServices, options?: ModelServiceOptions);
+    /**
+     * Wait for the document at `uri` to reach `state`. Pure wait — does
+     * not trigger a build. If `uri` is not yet in the document registry
+     * the call will hang until something else drives it through the
+     * pipeline; for the cold-start case use {@link rebuild} instead.
+     *
+     * Wrapped in a debug-level timing log via {@link Tracer.time} so
+     * slow per-URI waits surface in build telemetry; the URI is
+     * attached via {@link Tracer.withUri} for callsite attribution.
+     */
+    waitForDocumentState(uri: string, state: DocumentState, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Wait for the document at `uri` to reach the integrity-settled landmark
+     * ({@link IntegrityService.SettledState}) — the earliest phase at which the
+     * AST + serialised text are stable post-integrity. Convenience wrapper over
+     * {@link waitForDocumentState} for the common "wait until content is stable"
+     * case (e.g. settling a save). Pure wait — does not trigger a build.
+     */
+    waitForDocumentSettled(uri: string, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Internal wait core operating on an already-{@link CanonicalUri canonical}
+     * URI. The public string doors ({@link waitForDocumentState} /
+     * {@link waitForDocumentSettled}) and the build/ensure cores
+     * ({@link rebuildCanonical} / {@link ensureDocumentStateCanonical}) canonicalize
+     * once at entry and thread the result here, so a single high-level op resolves
+     * the identity once instead of re-running the (filesystem-touching) `realpath`
+     * at every wait. The `CanonicalUri` parameter type enforces that — a raw
+     * `string` cannot be passed without minting through the URI policy.
+     */
+    protected waitForDocumentStateCanonical(uri: CanonicalUri, state: DocumentState, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Wait for the document builder to reach `state` across its currently-
+     * queued documents. Pure wait — does not trigger a build. Used by
+     * shutdown / cascade-rebuild observers / tests; per-URI callers
+     * should use {@link waitForDocumentState} instead.
+     *
+     * Timing log fires on the unattributed logger (no URI scope, since
+     * the wait spans the whole build queue).
+     */
+    waitForBuilderState(state: DocumentState, cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Force a fresh build of the document at `uri` and wait for it to
+     * reach `state` (or the integrity-settled landmark
+     * {@link IntegrityService.SettledState} if omitted).
+     * Always triggers `DocumentBuilder.update([uri], [])` regardless of
+     * whether the document is already in the registry — call this when
+     * you want to re-process from scratch.
+     *
+     * The facade is responsible for firing `DocumentBuilder.update`
+     * directly because Langium's `DefaultDocumentUpdateHandler.didChangeContent`
+     * (the standard text-document → builder bridge) only runs under an
+     * LSP `Connection`. Running headless the bridge never fires; the
+     * facade stands in for it on its own update path.
+     *
+     * Coexistence with an LSP head running on the same `DocumentBuilder` is
+     * fine, but not because the builder merges the two: Langium does NOT
+     * coalesce concurrent builds of the same URI. The LSP head fires `update`
+     * from the LSP-driven event and the facade fires it from its own RPC-driven
+     * event — both legitimate — so this method takes the workspace WRITE lock,
+     * the same one Langium's own text-change bridge builds under, to serialise
+     * them. Two unserialised builds of one URI each run a full validation pass
+     * and Langium appends the second set onto the first, duplicating every
+     * diagnostic. Opt out via
+     * {@link ModelServiceOptions.serializeBuilds} — see there for the
+     * non-reentrancy hazard that is the reason the opt-out exists.
+     *
+     * Returns an empty `{ root, diagnostics }` envelope when the document
+     * cannot be loaded; adopters that want to throw override this method
+     * on their subclass.
+     *
+     * Consumers wanting "give me this doc at state X, building only if
+     * needed" — use the per-state methods ({@link parsed} / {@link linked}
+     * / {@link settled} / {@link indexed} / {@link validated}) instead.
+     */
+    rebuild(uri: string, state?: DocumentState, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Internal build core operating on an already-{@link CanonicalUri canonical}
+     * URI — the build counterpart to {@link waitForDocumentStateCanonical}. Drives
+     * `DocumentBuilder.update` then waits via the canonical wait core, so the
+     * identity is resolved once at the public door and neither sink re-runs the
+     * `realpath`. (`DocumentBuilder.update` still resolves each URI internally for
+     * directory flattening — that is the build's own existence-aware resolution,
+     * not a redundant identity canonicalisation.)
+     */
+    protected rebuildCanonical(uri: CanonicalUri, state?: DocumentState, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Per-state typed convenience methods. Each ensures the document at
+     * `uri` reaches the named phase and returns the AST envelope with
+     * the narrowest accurate diagnostics type for that phase. Smart
+     * dispatch internally: warm path (URI already in the document
+     * registry) just waits via {@link waitForDocumentState}; cold path
+     * triggers a build via {@link rebuild}. Consumers do not need to
+     * know which path was taken.
+     *
+     * Phase invariants encoded in the return type:
+     * - `parsed` / `linked` / `settled` / `indexed` return
+     *   `AstDocument<TAst, never>` — diagnostics array is empty by phase
+     *   contract.
+     * - `validated` returns `AstDocument<TAst, TDiagnostic>` — diagnostics
+     *   are populated.
+     *
+     * `settled` is the integrity-overlay name for "all integrity rules
+     * have fired"; it maps to {@link IntegrityService.SettledState} (which
+     * equals `DocumentState.IndexedReferences`), but the dedicated method
+     * exists so consumers track the semantic stability even if the landmark
+     * ever moves.
+     */
+    parsed(uri: string, cancelToken?: CancellationToken): Promise<AstDocument<TAst, never>>;
+    linked(uri: string, cancelToken?: CancellationToken): Promise<AstDocument<TAst, never>>;
+    settled(uri: string, cancelToken?: CancellationToken): Promise<AstDocument<TAst, never>>;
+    indexed(uri: string, cancelToken?: CancellationToken): Promise<AstDocument<TAst, never>>;
+    validated(uri: string, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Ensure the document at `uri` reaches `state` (or the integrity-settled
+     * landmark {@link IntegrityService.SettledState} if omitted) and return its
+     * AST envelope. Smart
+     * dispatch: warm path (URI already in `LangiumDocuments`) just waits
+     * via {@link waitForDocumentState}; cold path forces a build via
+     * {@link rebuild}.
+     *
+     * Pairs with {@link rebuild} — same default phase, but `rebuild`
+     * always builds while this skips the build for an already-loaded
+     * document. Also pairs with {@link waitForDocumentState} — the verb
+     * difference (`ensure` vs `waitFor`) signals the side-effect
+     * difference. The per-state convenience methods (`parsed` / `linked`
+     * / `settled` / `indexed` / `validated`) all delegate here with an
+     * explicit phase.
+     */
+    ensureDocumentState(uri: string, state?: DocumentState, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Internal smart-dispatch core operating on an already-{@link CanonicalUri canonical}
+     * URI. The `hasDocument` probe keys `LangiumDocuments` directly with the
+     * canonical URI — no re-canonicalisation — which is the reason the parameter is
+     * typed `CanonicalUri` rather than `string`. The warm path waits via the
+     * canonical wait core ({@link waitForDocumentStateCanonical}); the cold path
+     * dispatches through the public {@link rebuild} (which re-canonicalizes once,
+     * idempotently) so an adopter `rebuild` override stays in the build path — the
+     * one customization seam this chain deliberately preserves.
+     */
+    protected ensureDocumentStateCanonical(uri: CanonicalUri, state?: DocumentState, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Apply an update for `uri`. The structured-or-textual `model` payload
+     * is serialised (via {@link serialize} after {@link rewriteModel} when
+     * structured), pushed into the multi-client text-document store with
+     * a fresh version, drives a build to the target phase, and returns
+     * the post-build AST snapshot.
+     *
+     * **Read-latest supersession**: concurrent callers on the same URI
+     * all see the same post-build state once `waitUntil` resolves; none
+     * deadlock waiting for a specific version's settled event. The
+     * framework emits a post-resolution `debug` log line distinguishing
+     * "vN ready" from "vN ready at vM (superseded)" so callers can
+     * observe when their write was overtaken by a newer one before
+     * settling — purely observability, doesn't change resolution
+     * semantics. Adopters wanting version-matched resolution (resolve
+     * with vN's specific settled snapshot, intermediate-phase
+     * observability, slow-warn / hard-timeout behaviour) override this
+     * method.
+     */
+    update(args: TransferUpdateArgs<TTransfer>, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Persist `uri` to disk. Same content-change + settled-phase flow as
+     * {@link update}, then writes via the
+     * `WritableFileSystemProvider` and notifies the multi-client
+     * text-document store of the save (so any open LSP-side editor sees
+     * the `onDidSave` event regardless of who originated the persist).
+     *
+     * Returns the post-save AST snapshot.
+     */
+    save(args: TransferSaveArgs<TTransfer>, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Wait for the document at `uri` to reach the integrity-settled landmark and
+     * drain any in-flight write-path applyEdit sync chain (see {@link syncChains})
+     * so every language client reflects the latest content before a save returns.
+     * No-op tail for headless adopters — `syncChains` is empty without an LSP
+     * client. Bounded by {@link SAVE_SETTLE_TIMEOUT_MS} so a hung build, or an
+     * applyEdit reverse-RPC deadlock, can't freeze the caller; on timeout it logs
+     * a warning and returns rather than throwing.
+     *
+     * Adopters with a save flow that must converge editor + disk before returning
+     * (e.g. a dual form/code editor that would otherwise show a content-conflict
+     * dialog on rapid save) call this after their `save`.
+     */
+    protected settleSave(uri: string, cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Open the document at `args.uri` on behalf of `args.clientId`.
+     * Multi-client: each (uri, clientId) pair is tracked as one
+     * registration; the underlying document stays open until the last
+     * client closes it. If `args.text` is omitted the document content
+     * is read from the `FileSystemProvider`.
+     *
+     * Returns a {@link Disposable} that closes the registration when
+     * disposed — useful for `using` blocks and shutdown cleanup.
+     *
+     * Delegates to the framework-bound
+     * `services.workspace.AstDocumentManager`. Adopter subclasses with
+     * extra open-time behaviour (logging, sync-chain bootstrapping)
+     * override on their `ModelService` subclass and call `super.open`.
+     *
+     * The open path does not thread cancellation: `AstDocumentManager.open`
+     * and the filesystem read behind it take no token, so a cancelled caller
+     * still completes the open.
+     */
+    open(args: OpenModelArgs): Promise<Disposable>;
+    /**
+     * Close the document at `args.uri` for `args.clientId`. Counterpart
+     * to {@link open}; the underlying document stays open until every
+     * registered client has closed.
+     */
+    close(args: CloseModelArgs): Promise<void>;
+    /**
+     * True when the document at `uri` is currently open for at least one
+     * client. Pure read; no side effects.
+     */
+    isOpen(uri: string): boolean;
+    /**
+     * The built {@link LangiumDocument} for `uri`, looked up by canonical identity —
+     * the synchronous, phase-agnostic sibling of {@link ensureDocumentState} /
+     * {@link waitForDocumentState} (which await a build state). The single
+     * canonicalizing door for callers that need the live document without reaching
+     * into `LangiumDocuments` directly: a symlinked / `..` / case-divergent URI
+     * still resolves to the one document the build keys by its real path. Returns
+     * `undefined` if no document is registered for `uri`.
+     */
+    getDocument(uri: string): LangiumDocument | undefined;
+    /**
+     * Mirror a server-side change of `document` back to the LSP textual language
+     * client, run per document as it reaches the post-integrity settled phase.
+     * The single framework caller of
+     * `HydraniumTextDocuments.applyEditToLanguageClient` and
+     * `HydraniumTextDocuments.stagePendingContent`.
+     *
+     * Routes to one of two mechanisms by language-client registration, because
+     * an open and a closed document answer different questions:
+     *
+     * - **Open in the language client** → {@link syncOpenDocument}: mirror the
+     *   settled text via a coalesced `applyEditToLanguageClient`, routed purely by
+     *   **content**.
+     * - **Closed in the language client** → {@link stageClosedDocument}: stage the
+     *   text for the eventual first `didOpen`, gated by **provenance**
+     *   ({@link isNonLanguageClientEdit}).
+     *
+     * The decision is **re-derived from the current settled state every time** (it
+     * is not a one-shot enrolment), which is what makes it self-healing: a doc
+     * that still needs syncing on a later settle — a re-open refresh, a recovery
+     * build after cancellation — is caught even though an earlier settle already
+     * synced it.
+     */
+    protected syncToLanguageClient(document: LangiumDocument): void;
+    /**
+     * Mirror the settled text of a document open in the language client via a
+     * coalesced `applyEditToLanguageClient`. `uri` is the document's CANONICAL identity
+     * (the chain key); the egress (`applyEditToLanguageClient`) translates it to the
+     * recorded language-client URI(s). Routed purely by **content**: the shadow
+     * no-ops the RPC when Monaco already matches, so a Monaco echo (the client's
+     * own edit coming back) and a cascade-affected doc whose serialized text is
+     * unchanged both cost nothing — a string compare, no RPC. Author is
+     * irrelevant here: the shadow suppresses the echo precisely, so no
+     * author-based skip is needed.
+     */
+    protected syncOpenDocument(uri: string, text: string): void;
+    /**
+     * Stage the settled text of a document closed in the language client so the
+     * eventual first `didOpen` sees this in-memory text instead of stale disk —
+     * but only for a {@link isNonLanguageClientEdit genuine non-language-client edit}.
+     * A document rebuilt by an internal build is skipped, leaving disk authoritative
+     * on the next open.
+     */
+    protected stageClosedDocument(document: LangiumDocument): void;
+    /**
+     * Whether `document`'s settled state is a genuine edit by a client *other than
+     * the language client* — a write a form / GLSP / integrity client actually made.
+     * Excludes two non-edits: the **language client** itself (the LSP/Monaco text
+     * client — it already holds its own edits, and the staging here exists to feed
+     * it) and an **internal build** (workspace startup, a cascade relink, a
+     * `didClose`-reload). This is the gate for {@link stageClosedDocument}: staging
+     * an internal build would
+     * (a) pre-stage every file on boot and (b) re-stage discarded content after
+     * close (e.g. a disposing GLSP session's debounced submit firing after close),
+     * which then shadows clean disk on the next open.
+     *
+     * The signal is "a known client other than the language client authored this
+     * version **and** the URI was in the last build's changed set
+     * (`isDirectChange`)". A framework-internal rebuild reports no author
+     * (`getAuthor` → `undefined`), so it fails `hasKnownAuthor` without comparing
+     * against a sentinel. This is NOT redundant with content/registration — it
+     * distinguishes "client edited" from "framework rebuilt", which neither the
+     * shadow nor `isDirectChange` alone can.
+     */
+    protected isNonLanguageClientEdit(document: LangiumDocument): boolean;
+    /**
+     * Enqueue a sync to the language client. The pending slot per URI holds only
+     * the latest text: if a newer settle fires while the current RPC is in
+     * flight, the intermediate text is dropped and the chain picks up the latest
+     * on its next iteration. Coalescing guarantees a single in-flight applyEdit
+     * per URI so the shadow never drifts from Monaco.
+     */
+    protected queueSync(uri: string, text: string): void;
+    protected drainSyncQueue(uri: string): Promise<void>;
+    /**
+     * Subscribe to AST-snapshot updates for `uri`. Fires after each
+     * rebuild that reaches the target phase. Delegates to the
+     * `HydraniumTextDocuments` — single listener registration shared with
+     * any direct `HydraniumTextDocuments.onUpdate` subscriber, so the same
+     * underlying `DocumentBuilder.onDocumentPhase` listener serves both
+     * call paths. `sourceClientId` is resolved from the multi-client
+     * author history; reason discrimination follows the manager's own
+     * `lastUpdate` snapshot (see `AstDocumentManager.onUpdate`).
+     */
+    onModelUpdated(uri: string, listener: (event: AstDocumentUpdatedEvent<TAst, TDiagnostic>) => void): Disposable;
+    /**
+     * Subscribe to save events for `uri`. Fires on every persist through
+     * the multi-client text-document store — including saves originated
+     * by other heads (LSP editor `Ctrl+S`, the data-server `save`, etc.)
+     * so subscribers see one consistent stream regardless of who wrote
+     * the file. Delegates to the manager — single listener registration
+     * shared with any direct `HydraniumTextDocuments.onSave` subscriber.
+     */
+    onModelSaved(uri: string, listener: (event: AstDocumentSavedEvent<TAst, TDiagnostic>) => void): Disposable;
+    /**
+     * Subscribe to the `(uri, clientId)` close event. Delegates to the
+     * manager so the listener registry is shared with any direct
+     * `HydraniumTextDocuments.onClientClosed` subscriber.
+     */
+    onClientClosed(uri: string, clientId: string, listener: () => void): Disposable;
+    /**
+     * Serialise a transfer-model root via the language-specific
+     * `Serializer` bound at `services.serializer.Serializer`,
+     * resolved per-URI through `services.ServiceRegistry.getServices(uri)`
+     * so multi-grammar workspaces route to the right serializer per file.
+     * Adopters bind their own per-language; the framework default
+     * `UnboundSerializer` throws if none is bound.
+     *
+     * Adopters whose serializer call shape differs (custom service
+     * names, generator-driven YAML pretty printers, etc.) override this
+     * method. Routes through `Serializer.serializeTransfer` because
+     * `ModelService.update` / `ModelService.save` always receive a
+     * transfer-model shape (cross-references as plain strings) from
+     * adopter callers — the AST-shape entry point is `serializeAst`.
+     *
+     * Returns {@link MaybePromise} so adopter `Serializer` overrides can be
+     * async (remote schema lookup, external canonical-value resolution); the
+     * single caller ({@link modelToText} → {@link update}) is already `async`,
+     * so a naive `await` covers both branches without extra ceremony.
+     */
+    protected serialize(uri: string, root: TTransfer): MaybePromise<string>;
+    /**
+     * Convert a structured-or-textual `model` payload to its textual form.
+     *
+     * Textual payloads (LSP / pre-serialised callers) pass through untouched.
+     * Structured payloads run the per-language `UpdateRewriteService` chain
+     * (transfer-model transforms; diff-aware rewrites see the previous AST root),
+     * then serialise. The chain is the single transfer-model-transform seam — a
+     * unary normalisation is just a rewrite that ignores `previous`, as
+     * `NormalizeEmptyStringsContribution` does. The chain is empty by
+     * default, so this is a no-op for adopters that register none.
+     */
+    protected modelToText(uri: string, model: TTransfer | string, cancelToken?: CancellationToken): Promise<string>;
+    /**
+     * Run the per-language transfer-model rewrite chain. Resolves the
+     * `UpdateRewriteService` per-URI (like {@link serialize}) and threads
+     * in the previous AST root — `document.parseResult.value`, or `undefined`
+     * for a not-yet-built document — so diff-based rewrites can distinguish a
+     * real user change from a stale echo.
+     */
+    protected rewriteModel(uri: string, model: TTransfer, cancelToken?: CancellationToken): Promise<TTransfer>;
+    /**
+     * Build an {@link AstDocument} envelope from the current
+     * {@link LangiumDocument} state via the shared {@link AstDocument.from}
+     * projection. Returns an empty envelope (built via
+     * {@link AstDocument.create}) when the document is absent from the
+     * registry — adopters that prefer to throw override on their subclass.
+     */
+    protected toAstDocument(uri: URI): AstDocument<TAst, TDiagnostic>;
+}
+//# sourceMappingURL=model-service.d.ts.map

package/lib/langium/model-service/model-service.d.ts.map

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