@hydranium/core 1.0.0-next.10

package/lib/langium/document-builder/document-builder.d.ts

@@ -0,0 +1,405 @@
+/********************************************************************************
+ * 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 Clock, type LogThreshold, type MaybeObservableValue, ObservableValue, type Tracer } from '@hydranium/protocol';
+import { type BuildOptions, DefaultDocumentBuilder, type DocumentPhaseListener, DocumentState, type LangiumDocument, type URI } from '@hydranium/langium';
+import { CancellationToken } from 'vscode-languageserver-protocol';
+import { type LogNameOptions } from '../diagnostics/logger.js';
+import { type ExtendedServiceRegistry } from '../service-registry.js';
+import { type ServerSharedServicesMinimal } from '../shared-services.js';
+import { type DocumentUriPolicy } from '../workspace/document-uri-policy.js';
+/** Document states a phase-reached line is emitted for by default — every built phase. */
+export declare const DEFAULT_LOGGED_PHASES: DocumentState[];
+/** Constructor options for {@link HydraniumDocumentBuilder}. */
+export interface DocumentBuilderOptions extends LogNameOptions {
+    /**
+     * Level at which framework-side log lines are emitted, or `'off'` to
+     * suppress every framework log line entirely. Default: `'debug'`. Read once
+     * at construction to gate phase-listener registration, so it is a plain
+     * value — a live change could not register or dispose listeners.
+     */
+    readonly logLevel?: LogThreshold;
+    /**
+     * Document states for which a phase-reached line is emitted. Default: every
+     * built phase. Read once at construction (it drives listener registration),
+     * so it is a plain value.
+     */
+    readonly loggedPhases?: DocumentState[];
+    /**
+     * `notifyDocumentPhase` total ms at or above which a per-listener breakdown
+     * is logged. Default: `25`. Read per phase, so it accepts a
+     * {@link MaybeObservableValue} — pass a constant or bind it to a user setting.
+     */
+    readonly slowPhaseMs?: MaybeObservableValue<number>;
+    /**
+     * Per-listener ms at or above which a listener appears in the breakdown.
+     * Default: `5`. Read per phase; accepts a {@link MaybeObservableValue}.
+     */
+    readonly slowListenerMs?: MaybeObservableValue<number>;
+    /**
+     * `notifyBuildPhase` total ms at or above which the listener-count line is
+     * logged. Default: `25`. Read per phase; accepts a {@link MaybeObservableValue}.
+     */
+    readonly slowBuildMs?: MaybeObservableValue<number>;
+    /**
+     * Refresh cross-document `ComputedScopes` derivations when a referencing
+     * document is cascade-rebuilt (see
+     * {@link HydraniumDocumentBuilder.resetToState}). An `AstExtension` at
+     * `ComputedScopes` that reads a cross-document reference and caches a
+     * projection of the target keeps a STALE projection otherwise. Default
+     * `false` (Langium's standard reset — no extra work). Adopters whose
+     * `ComputedScopes` extensions derive from other documents set `true`, at the
+     * cost of one extra `collectLocalSymbols` per cascade-affected document.
+     */
+    readonly refreshCrossDocumentComputedScopes?: boolean;
+}
+/**
+ * Extends Langium's {@link DefaultDocumentBuilder} with:
+ *
+ * - **Bug-fixes** (always on): an {@link awaitDocumentState} that waits where
+ *   the default rejects, a {@link prepareBuild} that keeps a cancelled
+ *   non-validating build from suppressing validation, and a
+ *   {@link shouldRelink} that never judges a document unaffected on an index
+ *   that does not describe it.
+ * - **URI handling** (always on): directory-aware flattening and cascade
+ *   deletes in {@link update}, plus the CST-rehydration and cross-document
+ *   refresh resets in {@link resetToState}.
+ * - **In-place rebuild helpers** — {@link reparse} and
+ *   {@link reparseAndRelink} — for a build-phase listener that mutated a
+ *   document's AST and must reconcile it within the same build.
+ * - **Diagnostic dedupe** at `Validated` ({@link dedupeDiagnostics}).
+ * - **Logging instrumentation** (default on, opt-out via `logLevel: 'off'`):
+ *   phase-reached lines, slow-listener breakdowns on `notifyDocumentPhase`,
+ *   and slow-build-phase totals on `notifyBuildPhase`.
+ *
+ * Adopters extend this class — the configuration knobs cover what most
+ * adopters need; the `format*Line` methods, `formatUri`, and
+ * `collectDeletedURIs` are protected so subclasses can customise wording or
+ * domain-aware cascades without re-implementing surrounding logic.
+ */
+export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
+    protected readonly tracer: Tracer;
+    /** Plain — read once at construction to gate phase-listener registration. */
+    protected readonly logLevel: LogThreshold;
+    /** Plain — read once at construction; drives which phases get a listener. */
+    protected readonly loggedPhases: DocumentState[];
+    /** Live slow-phase-total threshold; read `.value` per phase. */
+    protected readonly slowPhaseMs: ObservableValue<number>;
+    /** Live per-listener threshold; read `.value` per phase. */
+    protected readonly slowListenerMs: ObservableValue<number>;
+    /** Live slow-build-phase-total threshold; read `.value` per phase. */
+    protected readonly slowBuildMs: ObservableValue<number>;
+    protected readonly uriPolicy: DocumentUriPolicy;
+    protected readonly clock: Clock;
+    /** Narrower handle on the same registry as the inherited `serviceRegistry`, for {@link ExtendedServiceRegistry.registrations}. */
+    protected readonly languageRegistry: ExtendedServiceRegistry;
+    protected languageFileExtensions: string[];
+    /** {@link ExtendedServiceRegistry.registrations} {@link languageFileExtensions} was built at; `-1` until first built. */
+    protected cachedRegistrations: number;
+    protected lastPhaseMs: number;
+    /** Resolved from {@link DocumentBuilderOptions.refreshCrossDocumentComputedScopes}. */
+    protected readonly refreshCrossDocumentComputedScopes: boolean;
+    /** LSP event name (e.g. `'didChangeWatchedFiles'`) staged for the next `update()` call. */
+    protected pendingUpdateReason?: string;
+    constructor(services: ServerSharedServicesMinimal, options?: DocumentBuilderOptions);
+    /**
+     * Stage an LSP event name for the next `update()` call. Adopters call before
+     * the update fires; `HydraniumDocumentUpdateHandler` does it for the
+     * four LSP events.
+     *
+     * The framework stages the value and never reads it back. The consumer is a
+     * subclass overriding the build logging, which takes
+     * {@link pendingUpdateReason}, clears it, and tags its build line with the
+     * event that caused the build. So a grep of this repo alone shows a write
+     * with no read — that is the seam working, not a dead field.
+     */
+    markNextReason(reason: string | undefined): void;
+    /**
+     * Diagnostic snapshot for use in timeout/error messages around document
+     * state.
+     *
+     * Public rather than `protected`, against the default for a `format*`
+     * helper: the GLSP head reads it off the shared services tree to build its
+     * own diagnostics, and a cross-package caller cannot reach a `protected`
+     * member. Narrowing it would move that formatting into the caller and
+     * duplicate what this already knows.
+     */
+    formatBuildStatus(uri: URI): string;
+    /**
+     * Two edge cases the default Langium implementation rejects on:
+     * - Document below target state with no build active (newly-created file):
+     *   wait for the next build instead of rejecting with "workspace state
+     *   already Validated".
+     * - Document at target state but build active and state may regress: wait
+     *   for phase notification instead of resolving immediately on stale state.
+     *
+     * When the document is already at target state and no regression is in
+     * progress, resolves immediately — avoids deadlocks where callers inside
+     * `onDocumentPhase` callbacks would block the active build otherwise.
+     *
+     * Replacing Langium's rejection with a wait makes the wait's liveness this
+     * class's responsibility: a listener can only fire if some build is still
+     * going to reach `state`. Both re-queue sites below exist for that, and they
+     * differ only in when the orphaning is observed — {@link isOrphaned} at
+     * registration time, the `onBuildPhase` branch for a build cancelled after
+     * the wait was already armed. Re-queuing stops after
+     * {@link MAX_STALLED_REQUEUES} builds that fail to advance the document, so a
+     * document the builder will never carry to `state` degrades to a pending wait
+     * plus a warning rather than an endless build loop.
+     */
+    protected awaitDocumentState(state: DocumentState, uri: URI, cancelToken: CancellationToken): Promise<URI>;
+    /**
+     * Whether no build will advance `document` to `state`, so a wait on it can
+     * only be resolved by starting one.
+     *
+     * `currentState` is the target phase the builder last *completed*, and both
+     * `build` and `update` reset it to `Changed` before stepping the phases — so
+     * `currentState >= state` means the workspace has already passed `state`
+     * without carrying this document along, rather than being on its way there.
+     * That is precisely the condition Langium's `awaitDocumentState` rejects on;
+     * this class waits instead, and therefore has to schedule the build itself.
+     *
+     * The common cause is benign: workspace initialization builds with Langium's
+     * default `initialBuildOptions`, whose `validation` is unset, which
+     * leaves every document at `IndexedReferences` while the builder's own
+     * `currentState` still advances to `Validated` (the validation phase runs
+     * over an empty document list). Any first read that wants diagnostics — a
+     * one-shot data-head read, a CLI query, `ModelService.validated` — lands
+     * here.
+     */
+    protected isOrphaned(document: LangiumDocument, state: DocumentState): boolean;
+    /**
+     * Schedule a build for a document no in-flight build will advance. Deliberately
+     * fire-and-forget: the caller is a waiter that resolves off the resulting phase
+     * notification, so awaiting here would invert the dependency. A rejection is
+     * logged rather than swallowed — it leaves the waiter pending until its own
+     * cancellation token fires, which is worth a line in the log.
+     */
+    protected requeueOrphaned(document: LangiumDocument, state: DocumentState, reason: string): void;
+    /**
+     * Don't let a cancelled non-validating build suppress validation forever.
+     *
+     * Langium's `prepareBuild` deliberately RETAINS the previous build options
+     * for a document whose previous build did not complete, so a cancelled
+     * build resumes with the options it started under. That is right in
+     * general and wrong for exactly one case: the initial workspace build runs
+     * with `initialBuildOptions` (`{}` — validation OFF), so if it is cancelled
+     * partway, every document it had not yet finished keeps `validation: false`.
+     * The next build inherits that, `shouldValidate` returns false, and
+     * `buildDocuments` marks those documents COMPLETED without ever validating
+     * them — no diagnostics computed, none published, and nothing in the log.
+     *
+     * A write arriving during workspace startup is enough to trigger it, since
+     * `WorkspaceLock.write` cancels the in-flight initial build. Measured: the
+     * cross-grammar dependents of an edited document silently never publish.
+     *
+     * So when the incoming build asks for validation and a retained, incomplete
+     * state does not, upgrade that state's validation option. Resuming
+     * behaviour is otherwise untouched — the retained state, its phase and its
+     * prior result all still stand.
+     */
+    protected prepareBuild(documents: LangiumDocument[], options: BuildOptions): void;
+    /**
+     * Never judge a document unaffected on an index that does not describe it.
+     *
+     * Langium's `shouldRelink` asks `IndexManager.isAffected`, which reads the
+     * REFERENCE index — populated at `DocumentState.IndexedReferences`. A
+     * document that has not reached that phase has no entries there, so
+     * `isAffected` returns false for every change: not "unaffected", merely
+     * unknown. It is then left at `Linked`, and because `runCancelable` only
+     * processes documents whose state is BELOW its target, the next build does
+     * not re-link it either — it advances to `Validated` carrying links resolved
+     * against the OLD content, and validates clean.
+     *
+     * An interrupted initial build is enough to produce that state: the workspace
+     * build is a `WorkspaceLock.write` action, so any write arriving during
+     * startup cancels it, typically between `Linked` and `IndexedReferences`.
+     * Measured: the edited document's cross-grammar dependents keep stale,
+     * successfully-resolved references and report no diagnostics at all.
+     *
+     * Treating an un-indexed document as affected is the conservative reading and
+     * costs nothing in steady state — documents sit at `Validated` there, so this
+     * branch is only taken for documents an interrupted build left behind.
+     */
+    protected shouldRelink(document: LangiumDocument, changedUris: Set<string>): boolean;
+    update(changed: URI[], deleted: URI[], cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Refresh cross-document `ComputedScopes` derivations on cascade, when
+     * {@link refreshCrossDocumentComputedScopes} is set (default off).
+     *
+     * An `AstExtension` registered at `ComputedScopes` whose `compute` resolves
+     * a cross-document reference and reads the target's data depends on another
+     * document's content. Langium resets a
+     * cascade-affected (referencing) document TO `ComputedScopes` and rebuilds it
+     * from `Linked` — so the `ComputedScopes` phase is never re-emitted for it and
+     * those derivations keep a stale projection of the referenced document. The
+     * symptom: a document whose computed projection of the referenced document
+     * — the projection that feeds its scope during `Linked` — does not pick up a
+     * member added there until the referencing document is re-parsed.
+     *
+     * When enabled, reset such documents one phase lower, to `IndexedContent`, so `ComputedScopes`
+     * (and its AST-extension pass) re-executes before the document's own link.
+     * `IndexedContent` — not `Parsed` — is the minimal reset: the document is left
+     * AT `IndexedContent`, so the build's `IndexedContent` pass skips it (no
+     * redundant own-symbol re-index) while the `ComputedScopes` pass re-runs
+     * `collectLocalSymbols` + the extension refresh. `ComputedScopes` is passed here
+     * only for the relink set (changed documents reset to `Changed`,
+     * supersession resets to `IndexedReferences`), so this is scoped to exactly the
+     * cascade-affected documents. Cost: one extra `collectLocalSymbols` per affected
+     * document per cascade.
+     */
+    resetToState(document: LangiumDocument, state: DocumentState): void;
+    /**
+     * Re-parse a single document in place from its *current text* (the synced
+     * store, else disk), advancing it to `Parsed`. A thin wrapper over Langium's
+     * document factory so a caller already holding the write lock — e.g. the
+     * integrity service, which updated the document text after mutating its AST —
+     * can re-derive a fresh, consistent CST/AST without a full `update()` cycle.
+     *
+     * Reads the canonical source the build itself parses (not a passed-in
+     * string), so the CST cannot drift from the synced text; callers must update
+     * the text before calling.
+     */
+    reparse(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Re-run the parse → index-content → local-scopes → link phases (0–3) for a
+     * single already-built document, in place — re-firing the per-document phase
+     * notifications (`onDocumentPhase`, e.g. AST-extension refresh) but NOT the
+     * batch `onBuildPhase` notifications.
+     *
+     * For a build-phase listener (e.g. the integrity service) that mutated a
+     * document's AST *after* it was linked — and updated its text to match — and
+     * must reconcile the document within the SAME build. A bare AST mutation
+     * leaves the CST stale, which makes Langium's re-parse gate
+     * (`DefaultLangiumDocumentFactory.update`, keyed on the CST's `fullText`)
+     * skip the re-parse on a later build and strand the mutated AST (a corrected
+     * edge never returns on reopen). Re-running the document through
+     * {@link buildDocuments} would re-fire `onBuildPhase` and re-enter the
+     * listener (recursion), so this mirrors {@link runCancelable}'s per-document
+     * progression (op → set state → `notifyDocumentPhase`) for phases 0–3 while
+     * deliberately omitting `notifyBuildPhase`.
+     *
+     * Re-firing `onDocumentPhase` matters: per-document derivations such as
+     * AST-extension computed properties are wired there, and the freshly
+     * re-parsed AST would otherwise lack them. The caller
+     * runs inside the `Linked` build phase; the build carries the document
+     * through IndexedReferences + Validation (and their `onDocumentPhase`) next.
+     */
+    reparseAndRelink(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Cached on first access — language registration completes after
+     * construction — and refreshed on every registration since.
+     *
+     * The refresh matters because the cache is otherwise held for the process
+     * lifetime: a language registered after the first directory expansion would
+     * be silently excluded from it, so files of that language would never build
+     * on a watched-directory change.
+     *
+     * Keyed on the registry's monotonic `registrations` counter, not on
+     * `all.length`: `register` writes into a map keyed by language id, so
+     * REPLACING a registered id leaves the length unchanged and a
+     * count-keyed cache would keep the replaced language's extensions. One
+     * integer comparison per call, and the "registration must be finished
+     * before the first expansion" precondition is gone rather than narrowed.
+     */
+    protected ensureLanguageFileExtensions(): void;
+    /**
+     * Expand a changed URI to the registered-language files it covers, keyed
+     * canonically. A file resolves to itself (when its extension is registered);
+     * a directory expands to every registered language file beneath it.
+     *
+     * The expansion goes through the `FileSystemProvider` so it is
+     * platform-agnostic and discovers on-disk files that are *not yet loaded as
+     * documents*: the Node provider walks the real filesystem (a freshly added
+     * directory or never-opened file still builds), while a browser / empty
+     * provider yields nothing. `uriPolicy.loadUri` first maps the URI to its
+     * load identity — `undefined` (no on-disk content) short-circuits to `[]`
+     * rather than a doomed read, and a symlink resolves to its real path so the
+     * built documents key the same way every other layer does.
+     */
+    protected flattenAndAdaptURI(uri: URI): URI[];
+    /** Recurse `uri` through the `FileSystemProvider`, gathering registered
+     *  language files. A directory's entries carry their own `isDirectory`, so
+     *  the walk stats each node once (via `readDirectorySync`). */
+    protected collectLanguageFiles(uri: URI): URI[];
+    /** A path the provider cannot stat as a directory (missing / unreadable / a
+     *  plain file) is treated as a non-directory; `collectLanguageFiles` then
+     *  filters it by extension. */
+    protected isDirectory(uri: URI): boolean;
+    /** True when `uri`'s extension matches one of the registered language extensions. */
+    protected isLanguageFile(uri: URI): boolean;
+    /**
+     * Collect URIs to delete when `uri` is deleted. Default: if `uri` is a
+     * file, return `[uri]`; if it's a directory, return all documents under
+     * that path. Override for domain-aware cascades (e.g. when deleting a
+     * project descriptor should cascade to all its members).
+     */
+    protected collectDeletedURIs(uri: URI): URI[];
+    protected registerPhaseListeners(): void;
+    /** Called once per phase-reached event. Override to add custom side-effects beyond logging. */
+    protected onPhaseReached(state: DocumentState, documents: LangiumDocument[]): void;
+    /** Format the phase-reached log line. Override to customise wording. */
+    protected phaseReachedLine(state: DocumentState, documents: LangiumDocument[], elapsedMs: number): string;
+    notifyDocumentPhase(document: LangiumDocument, state: DocumentState, cancelToken: CancellationToken): Promise<void>;
+    /**
+     * Format the skipped-listener line.
+     *
+     * Worth `info` rather than `debug` because of what the skip costs: Langium's
+     * `runCancelable` assigns `document.state = targetState` BEFORE calling
+     * `notifyDocumentPhase`, so a token that cancels here leaves the document AT
+     * the phase with its listeners never run — and the next build's
+     * `document.state < targetState` guard then skips it, so nothing re-notifies.
+     * At `DocumentState.Validated` the skipped listener is Langium's diagnostics
+     * publisher, so the client silently never receives those diagnostics.
+     */
+    protected cancelledDocumentPhaseLine(document: LangiumDocument, state: DocumentState, cancelled: number, total: number): string;
+    /** Format the slow-listener breakdown line. Override to customise wording. */
+    protected slowDocumentPhaseLine(document: LangiumDocument, state: DocumentState, listeners: DocumentPhaseListener[], perListenerMs: number[], totalMs: number): string;
+    notifyBuildPhase(documents: LangiumDocument[], state: DocumentState, cancelToken: CancellationToken): Promise<void>;
+    /** Format the slow build-phase line. Override to customise wording. */
+    protected slowBuildPhaseLine(state: DocumentState, listenerCount: number, documents: LangiumDocument[], totalMs: number): string;
+    /** Format a URI for inclusion in log lines. Default: `uri.toString()`. Override for workspace-relative paths. */
+    protected formatUri(uri: URI): string;
+    /** Get a human-readable identifier for a phase listener. Falls back to `function.name` or `#index`. */
+    protected formatListener(listener: DocumentPhaseListener, index: number): string;
+    /**
+     * Collapse byte-identical duplicate diagnostics on `document`, in place.
+     *
+     * Two unserialised validation passes over one document report everything
+     * twice: Langium's validate appends to `document.diagnostics` when they are
+     * already set — deliberately, so a category-partitioned pass keeps the earlier
+     * category's findings — and a repeated FULL pass therefore doubles the list.
+     * `ModelServiceOptions.serializeBuilds` prevents that at the source; this is
+     * the net for configurations that allow concurrent builds anyway.
+     *
+     * Clearing the list before a pass is NOT an alternative: the append happens at
+     * pass completion, so two interleaved passes both clear, both finish, and the
+     * second still appends onto the first.
+     *
+     * **Equality is structural over the WHOLE diagnostic**, not a chosen subset of
+     * fields. That matters: `Diagnostic` carries `data` (which drives quick fixes),
+     * `relatedInformation`, `tags` and `source` besides the obvious range/message,
+     * so keying on a subset could collapse two findings that differ only in a
+     * code action. Duplicates produced by re-running the same checks over the same
+     * AST are identical in every field, so full structural equality removes
+     * exactly those. The one behavioural difference from a single pass: if a
+     * single pass ever emitted two byte-identical diagnostics, the count drops to
+     * one — indistinguishable to any consumer, since nothing can tell the two
+     * apart.
+     *
+     * Cost is kept off the common path. Each diagnostic contributes one short
+     * range key; a diagnostic is serialised ONLY when something else already
+     * occupies its range, so a document whose diagnostics are all at distinct
+     * ranges — every document, whenever builds are serialised — is walked without
+     * serialising anything.
+     */
+    protected dedupeDiagnostics(document: LangiumDocument): void;
+    /** Dispatch a log line at the configured log level; a no-op when `logLevel === 'off'`. */
+    protected log(message: string): void;
+}
+//# sourceMappingURL=document-builder.d.ts.map

package/lib/langium/document-builder/document-builder.d.ts.map

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