@hydranium/core 1.0.0-next.10

package/lib/testing/stub-ast-document-manager.d.ts

@@ -0,0 +1,82 @@
+/********************************************************************************
+ * 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 AstNode } from '@hydranium/langium';
+import { type AstDocumentManager, type AstDocumentUpdatedEvent, type WritableFileSystemProvider } from '../documents/ast-document-manager.js';
+import type { StubHydraniumTextDocuments } from './stub-hydranium-text-documents.js';
+import type { StubLangiumDocuments } from './stub-langium-documents.js';
+/**
+ * Minimal stub of {@link AstDocumentManager} for use in test
+ * harnesses. Implements just the methods the framework's
+ * `ModelService` calls (`open` / `close` / `update` / `save` /
+ * `isOpen` / `getDocument`); `onSave` / `onClientClosed` forward to the
+ * underlying stub text-document manager, `onUpdate` is driven explicitly
+ * through {@link StubAstDocumentManager.emitUpdate} because the stub tree runs
+ * no build phases to emit from, and the remaining read helpers
+ * (`isDirectChange`, `getAuthor`, `readFile`) throw if invoked — tests that
+ * need them should wire a richer stub or use the real
+ * {@link AstDocumentManager}.
+ *
+ * Open state is tracked per URI as the set of holding client ids, so a
+ * document stays open until its last client closes. The stub forwards
+ * content-change / save notifications to the supplied
+ * {@link StubHydraniumTextDocuments} so assertions on its `changes` /
+ * `saves` arrays see the same traffic the real manager would produce.
+ *
+ * # Stub-vs-real surface
+ *
+ * Picks the methods the stub claims to implement from
+ * {@link AstDocumentManager} — the compiler enforces each signature
+ * stays aligned with the real class. Methods that throw `notSupported`
+ * are still picked so signature drift on them produces a compile
+ * error rather than silent divergence.
+ */
+export interface StubAstDocumentManager<TAst extends AstNode, TDiagnostic = unknown> extends Pick<AstDocumentManager<TAst, TDiagnostic>, 'open' | 'close' | 'isOpen' | 'update' | 'save' | 'onUpdate' | 'onSave' | 'onClientClosed' | 'getAuthor' | 'getDocument' | 'isDirectChange' | 'readFile'> {
+    readonly openClients: Map<string, Set<string>>;
+    /**
+     * Deliver an update event to every live {@link StubAstDocumentManager.onUpdate}
+     * subscriber for `uri`. Returns how many listeners received it.
+     *
+     * **This exists because `onUpdate` cannot fire on its own, and that is a
+     * trap without a driver.** The real manager emits from a
+     * `DocumentBuilder.onDocumentPhase(Validated)` hook; a `makeTestServices`
+     * tree has a stub builder that runs no phases, so a subscription made
+     * through the stub would never be called. A test written as
+     * `onUpdate(uri, …); await tick(); expect(events).toHaveLength(0)` therefore
+     * passes for the wrong reason — the listener was never wired to anything —
+     * and reads as coverage of a suppression path it never reached. Driving the
+     * event explicitly is what lets such a test first prove delivery works, so
+     * the negative assertion means something.
+     *
+     * **The return value is the point, not a convenience.** `0` says no
+     * subscriber for that URI was registered, which is the state a negative
+     * assertion cannot distinguish from correct suppression. Assert it is
+     * non-zero before believing an empty event list.
+     *
+     * Two alternatives were rejected. Making `onUpdate` THROW would fence the
+     * hazard at zero API cost, but this harness ships (`files: ["lib", "src"]`)
+     * and an adopter subclass or test that subscribes and legitimately ignores
+     * the event would start failing on a stub it never asked to fire. Wiring the
+     * stub to the text-document store's change notifications — the way `onSave`
+     * is wired — would make it fire on its own, which moves the pass reason of
+     * every existing suite on a `makeTestServices` tree and asserts a phase
+     * semantics (`Validated`, with the real manager's author lookup and
+     * `changed`/`deleted`/`rebuilt` classification) that no stub tree has.
+     */
+    emitUpdate(uri: string, event: AstDocumentUpdatedEvent<TAst, TDiagnostic>): number;
+    /**
+     * How many live {@link StubAstDocumentManager.onUpdate} subscribers `uri`
+     * has, or the total across every URI when called with no argument.
+     *
+     * Read from outside — it is what a test asserts to show a subscription was
+     * actually established, and what makes {@link emitUpdate}'s `0` legible.
+     */
+    updateSubscriptions(uri?: string): number;
+}
+export declare function makeStubAstDocumentManager<TAst extends AstNode, TDiagnostic = unknown>(textDocuments: StubHydraniumTextDocuments, fileSystem: Pick<WritableFileSystemProvider, 'writeFile'>, documents?: StubLangiumDocuments<TAst, TDiagnostic>): StubAstDocumentManager<TAst, TDiagnostic>;
+//# sourceMappingURL=stub-ast-document-manager.d.ts.map

package/lib/testing/stub-ast-document-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-ast-document-manager.d.ts","sourceRoot":"","sources":["../../src/testing/stub-ast-document-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,OAAO,EAAkC,MAAM,oBAAoB,CAAC;AAElF,OAAO,EAEJ,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EACjC,MAAM,sCAAsC,CAAC;AAE9C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,sBAAsB,CAAC,IAAI,SAAS,OAAO,EAAE,WAAW,GAAG,OAAO,CAAE,SAAQ,IAAI,CAC9F,kBAAkB,CAAC,IAAI,EAAE,WAAW,CAAC,EACnC,MAAM,GACN,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,UAAU,GACV,QAAQ,GACR,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,gBAAgB,GAChB,UAAU,CACd;IACE,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,CAAC,IAAI,EAAE,WAAW,CAAC,GAAG,MAAM,CAAC;IAEnF;;;;;;OAMG;IACH,mBAAmB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5C;AAED,wBAAgB,0BAA0B,CAAC,IAAI,SAAS,OAAO,EAAE,WAAW,GAAG,OAAO,EACnF,aAAa,EAAE,0BAA0B,EACzC,UAAU,EAAE,IAAI,CAAC,0BAA0B,EAAE,WAAW,CAAC,EACzD,SAAS,CAAC,EAAE,oBAAoB,CAAC,IAAI,EAAE,WAAW,CAAC,GACnD,sBAAsB,CAAC,IAAI,EAAE,WAAW,CAAC,CAiH3C"}

package/lib/testing/stub-ast-document-manager.js

@@ -0,0 +1,125 @@
+/********************************************************************************
+ * 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 { UriUtils } from '@hydranium/langium';
+import { Disposable } from 'vscode-languageserver';
+export function makeStubAstDocumentManager(textDocuments, fileSystem, documents) {
+    const openClients = new Map();
+    // Keyed by the URI as given, not canonicalized: the stub has no URI policy,
+    // and `getDocument` below looks documents up by their given URI for the same
+    // reason, so both halves agree on identity.
+    const updateListeners = new Map();
+    const notSupported = (method) => {
+        throw new Error(`StubAstDocumentManager.${method} is not implemented; wire the real AstDocumentManager if your test needs it.`);
+    };
+    const close = async (args) => {
+        const clients = openClients.get(args.uri);
+        clients?.delete(args.clientId);
+        if (clients && clients.size === 0) {
+            openClients.delete(args.uri);
+        }
+    };
+    return {
+        openClients,
+        async open(args) {
+            const clients = openClients.get(args.uri) ?? new Set();
+            clients.add(args.clientId);
+            openClients.set(args.uri, clients);
+            // The real `open` materialises the synced document (from the payload
+            // text or the filesystem); mirror that so a subsequent `update` finds
+            // an open document to apply its content change to.
+            if (!textDocuments.get(args.uri)) {
+                textDocuments.seedOpen(args.uri, args.text ?? '', args.clientId);
+            }
+            return Disposable.create(() => close({ uri: args.uri, clientId: args.clientId }));
+        },
+        close,
+        isOpen(uri) {
+            return openClients.has(uri);
+        },
+        async update(uri, text, clientId) {
+            // Mirrors the real manager: the store assigns the shared version
+            // (step iff the content changed) — no fabricated version numbers.
+            return textDocuments.applyContentChange(uri, text, clientId);
+        },
+        async save(uri, clientId) {
+            const text = textDocuments.get(uri)?.getText() ?? '';
+            await fileSystem.writeFile(UriUtils.toUri(uri), text);
+            textDocuments.notifyDidSaveTextDocument({ textDocument: { uri }, text }, clientId);
+        },
+        // Registers the listener but never calls it by itself — the real manager
+        // emits from a `DocumentBuilder.onDocumentPhase(Validated)` hook and the
+        // stub tree runs no phases. `emitUpdate` is the only thing that fires it;
+        // see its declaration for why that is a driver rather than a throw or an
+        // autonomous wiring.
+        onUpdate(uri, listener) {
+            const listeners = updateListeners.get(uri) ?? new Set();
+            listeners.add(listener);
+            updateListeners.set(uri, listeners);
+            return Disposable.create(() => {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    updateListeners.delete(uri);
+                }
+            });
+        },
+        emitUpdate(uri, event) {
+            // Snapshot before iterating: a listener that disposes itself on first
+            // delivery would otherwise mutate the set mid-iteration.
+            const listeners = [...(updateListeners.get(uri) ?? [])];
+            for (const listener of listeners) {
+                listener(event);
+            }
+            return listeners.length;
+        },
+        updateSubscriptions(uri) {
+            if (uri !== undefined) {
+                return updateListeners.get(uri)?.size ?? 0;
+            }
+            let total = 0;
+            for (const listeners of updateListeners.values()) {
+                total += listeners.size;
+            }
+            return total;
+        },
+        onSave(uri, listener) {
+            return textDocuments.onDidSave(event => {
+                if (event.document.uri !== uri) {
+                    return;
+                }
+                listener({
+                    document: { uri, version: textDocuments.version(uri), root: undefined, diagnostics: [] },
+                    sourceClientId: event.clientId
+                });
+            });
+        },
+        onClientClosed(uri, clientId, listener) {
+            return textDocuments.onDidClose(event => {
+                if (event.clientId === clientId && event.document.uri === uri) {
+                    listener();
+                }
+            });
+        },
+        getAuthor() {
+            return notSupported('getAuthor');
+        },
+        // Canonicalizing document gateway. The stub has no canonicalizer, so it looks
+        // the document up in the seeded `StubLangiumDocuments` by its given URI (tests
+        // that need real symlink canonicalization wire the real AstDocumentManager).
+        getDocument(uri) {
+            return documents?.getDocument(UriUtils.toUri(uri));
+        },
+        isDirectChange() {
+            return notSupported('isDirectChange');
+        },
+        async readFile(uri) {
+            return notSupported(`readFile(${uri})`);
+        }
+    };
+}
+//# sourceMappingURL=stub-ast-document-manager.js.map

package/lib/testing/stub-ast-document-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-ast-document-manager.js","sourceRoot":"","sources":["../../src/testing/stub-ast-document-manager.ts"],"names":[],"mappings":"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"}

package/lib/testing/stub-document-builder.d.ts

@@ -0,0 +1,99 @@
+/********************************************************************************
+ * 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 DocumentBuilder, type DocumentState, type LangiumDocument, type URI } from '@hydranium/langium';
+import { type CancellationToken } from 'vscode-languageserver';
+/** Recorded call to a stubbed {@link DocumentBuilder} method. */
+export interface RecordedBuilderCall<TArgs extends unknown[]> {
+    readonly args: TArgs;
+}
+/**
+ * Handle over one held {@link StubDocumentBuilder.waitUntil} call.
+ *
+ * **Consumption is observable on purpose**: a handle whose `resolve()` silently
+ * did nothing would let "the gate released the wait" and "the subject never
+ * reached the wait" produce identical, green runs.
+ */
+export interface StubWaitUntilGate {
+    /**
+     * Release the held call.
+     *
+     * **Throws if no `waitUntil` ever took this gate**, and drops the gate from
+     * the queue on the way out — an unconsumed gate is FIFO-handed to the next
+     * `waitUntil`, which may belong to an unrelated later test, where it parks a
+     * call nobody meant to hold.
+     */
+    resolve(): void;
+    /** Whether a {@link StubDocumentBuilder.waitUntil} call has taken this gate. */
+    readonly consumed: boolean;
+}
+/**
+ * Stub for Langium's {@link DocumentBuilder}. Implements the slice production
+ * code reads from on the framework's test paths (`update` / `waitUntil` /
+ * `onDocumentPhase` / `onUpdate`) plus test-only helpers:
+ *
+ * - {@link firePhase} — synchronously dispatch the registered phase
+ *   listener(s) for a document, simulating a build completing.
+ * - {@link fireOnUpdate} — invoke `onUpdate` subscribers with synthetic
+ *   changed / deleted URI lists, simulating Langium's update fan-out.
+ * - {@link gateNextWaitUntil} — defer the next {@link waitUntil} resolution
+ *   until the returned `resolve()` is called, simulating a long-running
+ *   build that lets a caller observe the in-flight state.
+ *
+ * Recorded `updateCalls` / `waitUntilCalls` allow assertions on the
+ * arguments the consumer passed.
+ *
+ * # Stub-vs-real surface
+ *
+ * Picks the methods the framework reads from {@link DocumentBuilder} on
+ * the slot path — the compiler enforces those signatures stay aligned.
+ * `update`, `onDocumentPhase`, `onUpdate`, and `waitUntil` carry stubbed
+ * implementations; `build`, `onBuildPhase`, and `resetToState` are
+ * implemented as loud-failing `notSupported` throwers so production code
+ * that goes through the cast at the bind site (i.e. accesses methods the
+ * stub claims but doesn't meaningfully implement) fails with a clear
+ * message instead of "undefined is not a function".
+ */
+export interface StubDocumentBuilder extends Pick<DocumentBuilder, 'update' | 'onDocumentPhase' | 'onUpdate' | 'build' | 'onBuildPhase' | 'resetToState'> {
+    /**
+     * Single-overload stub of {@link DocumentBuilder.waitUntil}. Real has
+     * two overloads (`(state, cancelToken?): Promise<void>` and
+     * `(state, uri?, cancelToken?): Promise<URI | undefined>`) that can't
+     * be expressed as a single object-literal method type, so the stub
+     * declares only the more general second form. Tests pass cancelToken
+     * by name if needed (the stub ignores it).
+     */
+    waitUntil(state: DocumentState, uri?: URI): Promise<URI | undefined>;
+    readonly updateCalls: ReadonlyArray<RecordedBuilderCall<[URI[], URI[]]>>;
+    readonly waitUntilCalls: ReadonlyArray<RecordedBuilderCall<[DocumentState, URI | undefined]>>;
+    /**
+     * Synchronously fire the phase listener(s) registered for `state` with
+     * `document`. `cancelToken` defaults to a non-cancelled token; pass a
+     * cancelled token to simulate a build preempted by a concurrent write
+     * lock.
+     */
+    firePhase(state: DocumentState, document: LangiumDocument, cancelToken?: CancellationToken): void;
+    /** Synchronously fire every registered `onUpdate` listener. */
+    fireOnUpdate(changed: URI[], deleted: URI[]): void;
+    /**
+     * Hold the next {@link waitUntil} call. The returned handle releases it;
+     * the call's return value resolves on the next tick after `resolve` runs.
+     */
+    gateNextWaitUntil(): StubWaitUntilGate;
+    /** Drop recorded state and gates. Useful for `beforeEach`-style resets. */
+    reset(): void;
+}
+/**
+ * Build a {@link StubDocumentBuilder}. The stub is grammar-free and never
+ * actually parses; the `update` method only records its args. Tests that
+ * want to observe rebuilt state should `set` the new root on the document
+ * registry and then call `firePhase` to trigger the framework's post-build
+ * read path.
+ */
+export declare function makeStubDocumentBuilder(): StubDocumentBuilder;
+//# sourceMappingURL=stub-document-builder.d.ts.map

package/lib/testing/stub-document-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-document-builder.d.ts","sourceRoot":"","sources":["../../src/testing/stub-document-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,eAAe,EAEpB,KAAK,aAAa,EAElB,KAAK,eAAe,EACpB,KAAK,GAAG,EACV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,uBAAuB,CAAC;AAE3E,iEAAiE;AACjE,MAAM,WAAW,mBAAmB,CAAC,KAAK,SAAS,OAAO,EAAE;IACzD,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAC/B;;;;;;;OAOG;IACH,OAAO,IAAI,IAAI,CAAC;IAChB,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAC9C,eAAe,EACf,QAAQ,GAAG,iBAAiB,GAAG,UAAU,GAAG,OAAO,GAAG,cAAc,GAAG,cAAc,CACvF;IACE;;;;;;;OAOG;IACH,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,GAAG,SAAS,CAAC,CAAC;IACrE,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACzE,QAAQ,CAAC,cAAc,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC,aAAa,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IAC9F;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,eAAe,EAAE,WAAW,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAClG,+DAA+D;IAC/D,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IACnD;;;OAGG;IACH,iBAAiB,IAAI,iBAAiB,CAAC;IACvC,2EAA2E;IAC3E,KAAK,IAAI,IAAI,CAAC;CAChB;AAqBD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,mBAAmB,CA8G7D"}

package/lib/testing/stub-document-builder.js

@@ -0,0 +1,142 @@
+/********************************************************************************
+ * 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 { Disposable } from 'vscode-languageserver';
+/**
+ * Re-raise a listener's asynchronous failure instead of discarding it.
+ *
+ * These dispatchers are synchronous, so a listener's promise cannot be awaited
+ * and `void` on it drops the rejection entirely — a phase listener that fails
+ * asynchronously leaves the test green while the code under test threw. Raising
+ * it as an uncaught exception is the only channel a `void`-returning dispatcher
+ * has, and is what every runner already reports. A test that legitimately
+ * expects a listener to reject must assert on it directly rather than firing a
+ * phase and ignoring the result.
+ */
+function reraise(result) {
+    void Promise.resolve(result).catch((error) => {
+        queueMicrotask(() => {
+            throw error;
+        });
+    });
+}
+/**
+ * Build a {@link StubDocumentBuilder}. The stub is grammar-free and never
+ * actually parses; the `update` method only records its args. Tests that
+ * want to observe rebuilt state should `set` the new root on the document
+ * registry and then call `firePhase` to trigger the framework's post-build
+ * read path.
+ */
+export function makeStubDocumentBuilder() {
+    const phaseListeners = new Map();
+    const onUpdateListeners = [];
+    const gates = [];
+    const updateCalls = [];
+    const waitUntilCalls = [];
+    const notSupported = (method) => {
+        throw new Error(`StubDocumentBuilder.${method} is not implemented; wire a real DocumentBuilder if your test needs it.`);
+    };
+    const stub = {
+        get updateCalls() {
+            return updateCalls;
+        },
+        get waitUntilCalls() {
+            return waitUntilCalls;
+        },
+        async update(changed, deleted) {
+            updateCalls.push({ args: [changed, deleted] });
+        },
+        async waitUntil(state, uri) {
+            waitUntilCalls.push({ args: [state, uri] });
+            const gate = gates.shift();
+            if (gate) {
+                await new Promise(resolve => gate.take(resolve));
+            }
+            return uri;
+        },
+        onDocumentPhase(state, listener) {
+            const list = phaseListeners.get(state) ?? [];
+            list.push(listener);
+            phaseListeners.set(state, list);
+            return Disposable.create(() => {
+                const idx = list.indexOf(listener);
+                if (idx >= 0) {
+                    list.splice(idx, 1);
+                }
+            });
+        },
+        onUpdate(listener) {
+            onUpdateListeners.push(listener);
+            return Disposable.create(() => {
+                const idx = onUpdateListeners.indexOf(listener);
+                if (idx >= 0) {
+                    onUpdateListeners.splice(idx, 1);
+                }
+            });
+        },
+        firePhase(state, document, cancelToken) {
+            const token = cancelToken ??
+                {
+                    isCancellationRequested: false,
+                    onCancellationRequested: () => Disposable.create(() => undefined)
+                };
+            const listeners = phaseListeners.get(state) ?? [];
+            for (const listener of listeners) {
+                reraise(listener(document, token));
+            }
+        },
+        fireOnUpdate(changed, deleted) {
+            for (const listener of onUpdateListeners.slice()) {
+                reraise(listener(changed, deleted));
+            }
+        },
+        gateNextWaitUntil() {
+            let release;
+            const entry = {
+                take(resolve) {
+                    release = resolve;
+                }
+            };
+            gates.push(entry);
+            return {
+                get consumed() {
+                    return release !== undefined;
+                },
+                resolve() {
+                    if (!release) {
+                        const queued = gates.indexOf(entry);
+                        if (queued >= 0) {
+                            gates.splice(queued, 1);
+                        }
+                        throw new Error('StubDocumentBuilder: gateNextWaitUntil().resolve() ran before any waitUntil took the gate. ' +
+                            'Nothing was held, so releasing it proves nothing — wait until `waitUntilCalls` records the call first.');
+                    }
+                    release();
+                }
+            };
+        },
+        build() {
+            return notSupported('build');
+        },
+        onBuildPhase() {
+            return notSupported('onBuildPhase');
+        },
+        resetToState() {
+            return notSupported('resetToState');
+        },
+        reset() {
+            phaseListeners.clear();
+            onUpdateListeners.length = 0;
+            gates.length = 0;
+            updateCalls.length = 0;
+            waitUntilCalls.length = 0;
+        }
+    };
+    return stub;
+}
+//# sourceMappingURL=stub-document-builder.js.map

package/lib/testing/stub-document-builder.js.map

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

package/lib/testing/stub-hydranium-text-documents.d.ts

@@ -0,0 +1,125 @@
+/********************************************************************************
+ * 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 { ApplyWorkspaceEditResult } from 'vscode-languageserver';
+import { Disposable } from 'vscode-languageserver';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type { ClientTextDocumentChangeEvent, HydraniumTextDocuments } from '../documents/hydranium-text-documents.js';
+/** Snapshot of an open document tracked by the stub. */
+export interface StubTextDocumentEntry {
+    uri: string;
+    version: number;
+    text: string;
+    clientId: string;
+}
+/**
+ * Stub for {@link HydraniumTextDocuments}. Implements the slice production code
+ * reads from on test paths — the content channel
+ * (`notifyDidChangeTextDocument` / `applyContentChange` / `version` /
+ * `getAuthor`), the open-state probes (`isOpenInLanguageClient` /
+ * `isOpenInAnyClient` / `openDocuments`), the push channel to the language
+ * client (`applyEditToLanguageClient` / `stagePendingContent`) and the
+ * save / close notifications — plus test-only helpers:
+ *
+ * - {@link seedOpen} — pre-populate an open document without firing change
+ *   events. Use to set up a baseline version before exercising an `update`.
+ * - {@link fireClose} — synchronously deliver `onDidClose` to subscribers.
+ *   The `ModelService.onClientClosed` pass-through depends on this.
+ * - {@link changes} / {@link saves} — replay arrays for assertion.
+ *
+ * # Stub-vs-real surface
+ *
+ * Picked methods are bound structurally to {@link HydraniumTextDocuments} via
+ * `Pick<...>` so the compiler enforces that each picked signature stays in
+ * lockstep with the real class. A standalone interface with no structural tie
+ * lets the stub drift silently when the real manager grows a method: the
+ * failure then surfaces only when a test calls the missing method at runtime.
+ *
+ * `get(uri)` is deliberately NOT picked — real returns the full
+ * vscode-languageserver `TextDocument` (with `lineCount`, `positionAt`,
+ * etc.); the stub returns just `{ version, getText }` which is the only
+ * shape framework callers (`AstDocumentManager.save`) read on the test
+ * paths. Promote to a Pick when a test needs the full document surface.
+ *
+ * Versions: {@link notifyDidChangeTextDocument} drops payloads whose version
+ * is `<=` the current version (matches the real `HydraniumTextDocuments`
+ * staleness fallback for clients with no didOpen baseline) so
+ * concurrent-update test patterns observe the same supersession behaviour.
+ * {@link applyContentChange} mirrors the real server-assigned write path:
+ * the version steps iff the text differs from the current content.
+ */
+export interface StubHydraniumTextDocuments extends Pick<HydraniumTextDocuments<TextDocument>, 'version' | 'notifyDidChangeTextDocument' | 'applyContentChange' | 'getAuthor' | 'isOpenInLanguageClient' | 'isOpenInAnyClient' | 'applyEditToLanguageClient' | 'stagePendingContent' | 'openDocuments'> {
+    /**
+     * Stub-tailored read accessor. Returns just the surface the framework's
+     * save path reads (`version` + `getText()`), rather than the real `get`'s
+     * full `TextDocument`.
+     */
+    get(uri: string): {
+        version: number;
+        getText(): string;
+    } | undefined;
+    /**
+     * Stub-tailored save notification. Real signature accepts
+     * `DidSaveTextDocumentParams` with optional `text`; the stub takes the
+     * same shape but with `clientId` required (tests always supply it
+     * explicitly).
+     */
+    notifyDidSaveTextDocument(event: {
+        textDocument: {
+            uri: string;
+        };
+        text?: string;
+    }, clientId: string): void;
+    /** Stub-friendly save subscription — listener gets `{ document: { uri }, clientId }`. */
+    onDidSave(listener: (event: {
+        document: {
+            uri: string;
+        };
+        clientId: string;
+    }) => void): Disposable;
+    /** Real-shaped close subscription — listener gets {@link ClientTextDocumentChangeEvent}. */
+    onDidClose(listener: (event: ClientTextDocumentChangeEvent<TextDocument>) => void): Disposable;
+    /** Pre-populate an open document without firing change events. */
+    seedOpen(uri: string, text: string, clientId: string): void;
+    /** Mark `uri` as open in the LSP textual language client (drives {@link isOpenInLanguageClient}). */
+    seedOpenInLanguageClient(uri: string): void;
+    /** Synchronously deliver `onDidClose` to subscribers. */
+    fireClose(uri: string, clientId: string): void;
+    /** Drop recorded state. Useful for `beforeEach` resets. */
+    reset(): void;
+    readonly changes: readonly StubTextDocumentEntry[];
+    readonly saves: readonly {
+        uri: string;
+        clientId: string;
+    }[];
+    /**
+     * Decide what {@link applyEditToLanguageClient} answers, so a suite can drive
+     * the rejection path (`{ applied: false }`) the real client takes when its
+     * buffer has outrun the version the push was addressed at. The call is still
+     * recorded in {@link appliedEdits} either way. Defaults to accepting.
+     *
+     * The handler runs INSIDE the call, which is also the only place a suite can
+     * simulate something happening while the push is in flight — a newer settle,
+     * a concurrent client edit.
+     */
+    setApplyEditHandler(handler: (uri: string, text: string) => ApplyWorkspaceEditResult | undefined): void;
+    /** Replay of every {@link applyEditToLanguageClient} call (the text channel to Monaco). */
+    readonly appliedEdits: readonly {
+        uri: string;
+        text: string;
+        label?: string;
+    }[];
+    /** Replay of every {@link stagePendingContent} call (the not-yet-open staging path). */
+    readonly staged: readonly {
+        uri: string;
+        text: string;
+    }[];
+}
+/** Build a {@link StubHydraniumTextDocuments}. */
+export declare function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments;
+//# sourceMappingURL=stub-hydranium-text-documents.d.ts.map

package/lib/testing/stub-hydranium-text-documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-hydranium-text-documents.d.ts","sourceRoot":"","sources":["../../src/testing/stub-hydranium-text-documents.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAEvE,OAAO,KAAK,EAAE,6BAA6B,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAEtH,wDAAwD;AACxD,MAAM,WAAW,qBAAqB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,0BAA2B,SAAQ,IAAI,CACrD,sBAAsB,CAAC,YAAY,CAAC,EAClC,SAAS,GACT,6BAA6B,GAC7B,oBAAoB,GACpB,WAAW,GACX,wBAAwB,GACxB,mBAAmB,GACnB,2BAA2B,GAC3B,qBAAqB,GACrB,eAAe,CACnB;IACE;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,IAAI,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IACrE;;;;;OAKG;IACH,yBAAyB,CAAC,KAAK,EAAE;QAAE,YAAY,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3G,yFAAyF;IACzF,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,UAAU,CAAC;IAClG,4FAA4F;IAC5F,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,6BAA6B,CAAC,YAAY,CAAC,KAAK,IAAI,GAAG,UAAU,CAAC;IAC/F,kEAAkE;IAClE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5D,qGAAqG;IACrG,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,yDAAyD;IACzD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,2DAA2D;IAC3D,KAAK,IAAI,IAAI,CAAC;IACd,QAAQ,CAAC,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,SAAS;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC7D;;;;;;;;;OASG;IACH,mBAAmB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,wBAAwB,GAAG,SAAS,GAAG,IAAI,CAAC;IACxG,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,EAAE,SAAS;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAChF,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC5D;AAED,kDAAkD;AAClD,wBAAgB,8BAA8B,IAAI,0BAA0B,CAwJ3E"}