@hydranium/core 1.0.0-next.39 → 1.0.0-next.390

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

@@ -6,17 +6,36 @@
  *
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
-import { type Clock, type LogThreshold, type MaybeObservableValue, ObservableValue, type Tracer } from '@hydranium/protocol';
-import { type AstNode, type BuildOptions, DefaultDocumentBuilder, type DocumentPhaseListener, DocumentState, type LangiumDocument, type URI } from '@hydranium/langium';
-import { CancellationToken } from 'vscode-languageserver-protocol';
+import { type Clock, Deferred, type Stopwatch, type LogThreshold, type MaybeObservableValue, ObservableValue, type Tracer } from '@hydranium/protocol';
+import { type AstNode, type BuildOptions, DefaultDocumentBuilder, type DocumentPhaseListener, DocumentState, type LangiumDocument, MultiMap, URI, type WorkspaceLock } from '@hydranium/langium';
+import { CancellationToken, Disposable } from 'vscode-languageserver-protocol';
+import { type ModelLedger } from '../../documents/model-ledger.js';
+import { type VersionSyncService } from '../../documents/version-sync-service.js';
 import { type LogNameOptions } from '../diagnostics/logger.js';
 import type { MessageRenderer } from '../../messages/renderer.js';
+import { type CstResidencyService } from '../residency/cst-residency-service.js';
 import { type ExtendedServiceRegistry } from '../service-registry.js';
 import { type ServerSharedServicesMinimal } from '../shared-services.js';
 import { type DocumentUriPolicy } from '../workspace/document-uri-policy.js';
 import { BuildSession, type BuildSessionContext } from './build-session.js';
 /** Document states a phase-reached line is emitted for by default — every built phase. */
 export declare const DEFAULT_LOGGED_PHASES: DocumentState[];
+/**
+ * The build reasons the framework stages through
+ * {@link HydraniumDocumentBuilder.markNextReason}: the LSP events the update
+ * handler dispatches on, `didRelease` for the builds the
+ * `DocumentReleaseHandler` runs once the text store has released a document,
+ * and `memberRelink` for the follow-up builds a project manager queues to
+ * relink a changed project's members. Exposed so a subclass layering reasons
+ * of its own keeps the names the framework emits.
+ */
+export declare const HYDRANIUM_BUILD_REASONS: Readonly<{
+    readonly didOpen: 'didOpen';
+    readonly didChangeContent: 'didChangeContent';
+    readonly didChangeWatchedFiles: 'didChangeWatchedFiles';
+    readonly didRelease: 'didRelease';
+    readonly memberRelink: 'memberRelink';
+}>;
 /** Constructor options for {@link HydraniumDocumentBuilder}. */
 export interface DocumentBuilderOptions extends LogNameOptions {
     /**
@@ -72,14 +91,69 @@ export interface DocumentBuilderOptions extends LogNameOptions {
      */
     readonly refreshCrossDocumentComputedScopes?: boolean;
 }
+/** Options for a {@link HydraniumDocumentBuilder.waitUntil} wait on one document. */
+export interface WaitUntilOptions {
+    /**
+     * Reject once the builder gives up carrying the document to the target
+     * state. Without it, such a wait stays pending until its token is cancelled.
+     */
+    readonly rejectWhenStuck?: boolean;
+}
+/** What {@link HydraniumDocumentBuilder.onBuildEnded} tells a listener. */
+export interface BuildEndedEvent {
+    /**
+     * `true` once a build ran every phase, validating or not; `false` once the
+     * lock has drained after builds that threw, cancelled or failed, which
+     * share one event.
+     */
+    readonly completed: boolean;
+}
+/** Registered through {@link HydraniumDocumentBuilder.onBuildEnded}. */
+export type BuildEndedListener = (event: BuildEndedEvent) => void;
+/** Registered through {@link HydraniumDocumentBuilder.onDocumentPhaseDelivered}. */
+export type DocumentPhaseDeliveredListener = (document: LangiumDocument, version: number) => void;
+/** A wait {@link HydraniumDocumentBuilder.awaitBuilderState} holds until the builder reaches its state. */
+export interface BuilderStateWait {
+    readonly state: DocumentState;
+    /** Settles the wait and stops holding it. */
+    readonly resolve: () => void;
+}
+/**
+ * One locked build {@link HydraniumDocumentBuilder.scheduleUpdate} queued,
+ * which later requests merge into while it waits and join while it runs.
+ */
+export interface ScheduledUpdate {
+    /** URIs to build, by URI string. Merged requests change it while the write is queued; fixed once it runs. */
+    readonly changed: Map<string, URI>;
+    /** URIs to delete, by URI string, under the same rule as {@link changed}. */
+    readonly deleted: Map<string, URI>;
+    /** The latest build reason any merged request gave; staged through {@link HydraniumDocumentBuilder.markNextReason} when the write runs. */
+    reason?: string;
+    /** The lock's {@link HydraniumWorkspaceLock.writeCancellations} right after this write was queued. */
+    readonly cancellations: number;
+    /**
+     * Set when the write starts to run, so its presence marks a running build:
+     * the text version of each changed URI the text store holds at that point.
+     */
+    takenVersions?: Map<string, number>;
+    /** Set with {@link takenVersions}: the clients holding each changed URI in the text store at that point. */
+    takenClients?: Map<string, readonly string[]>;
+    /** The lock's promise for this write: settles when the build completes or is cancelled. */
+    readonly promise: Promise<void>;
+}
 /**
  * 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
+ *   the default rejects (re-queuing, under the workspace lock, a document no
+ *   build will carry), an {@link awaitBuilderState} that resolves once a
+ *   phase ends, whether armed during its notification or on a phase no
+ *   document reached, 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.
+ * - **Shared locked builds** ({@link scheduleUpdate}): build requests that
+ *   coincide share one locked build instead of cancelling each other.
  * - **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}.
@@ -122,12 +196,17 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
     protected readonly uriPolicy: DocumentUriPolicy;
     protected readonly clock: Clock;
     protected readonly messageRenderer: MessageRenderer;
+    /** The lock {@link scheduleUpdate} builds under. */
+    protected readonly workspaceLock: WorkspaceLock;
+    /** The latest write {@link scheduleUpdate} queued, until it ends; see {@link ScheduledUpdate}. */
+    protected scheduledUpdate?: ScheduledUpdate;
     /** 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;
+    /** Running since the last phase was reached, or since the active build started. */
+    protected sinceLastPhase?: Stopwatch;
     /** Resolved from {@link DocumentBuilderOptions.refreshCrossDocumentComputedScopes}. */
     protected readonly refreshCrossDocumentComputedScopes: boolean;
     /** LSP event name (e.g. `'didChangeWatchedFiles'`) staged for the next `update()` call. */
@@ -142,17 +221,36 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * construction.
      */
     protected activeSession?: BuildSession;
+    /** Set while an explicit {@link build} calls the `onUpdate` listeners, see {@link isInsideBuildUpdate}. */
+    protected insideBuildUpdate: boolean;
+    /** How many builds have started and not ended. */
+    protected runningBuilds: number;
+    /** Resolved once {@link runningBuilds} drops back to zero. Set while it is above. */
+    protected runningBuildsEnded?: Deferred<void>;
     /**
      * `traceId` of the last build that ended in cancellation, for the successor's
      * "cancels #N" tag. Held here rather than on a session because the session
      * that carries it is already gone by the time its successor is opened.
      */
     protected lastCancelledTraceId?: number;
+    /** Registered through {@link onDocumentPhaseDelivered}, by phase. */
+    protected readonly documentPhaseDeliveredListeners: MultiMap<DocumentState, DocumentPhaseDeliveredListener>;
+    /** Registered through {@link onBuildEnded}. */
+    protected readonly buildEndedListeners: Set<BuildEndedListener>;
+    /** Held by {@link awaitBuilderState} until {@link runCancelable} sees their state reached. */
+    protected readonly builderStateWaits: Set<BuilderStateWait>;
+    /** Set while the lock read {@link checkWaitsOnceDrained} queued has not run. */
+    protected drainCheckQueued: boolean;
+    /** A thunk: a version-sync service whose constructor reads the builder would otherwise be a cycle. */
+    protected readonly versionSyncService: () => VersionSyncService;
+    /** A thunk: a residency service whose constructor reads the builder would otherwise be a cycle. */
+    protected readonly cstResidency: () => CstResidencyService;
+    protected readonly modelLedger: ModelLedger;
     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 update fires; `HydraniumDocumentUpdateHandler` does it for the LSP
+     * events, and the release handler for the builds that follow a release.
      *
      * The framework stages the value and never reads it back. The consumer is a
      * subclass overriding the build logging, which takes
@@ -161,6 +259,55 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * with no read — that is the seam working, not a dead field.
      */
     markNextReason(reason: string | undefined): void;
+    /**
+     * Call `listener` with a document once every {@link onDocumentPhase}
+     * listener of `state` ran for it and none was skipped by cancellation, and
+     * with the text version the phase listeners were called at. A write during
+     * them moves the document's own version on, past what they saw.
+     *
+     * Only here is it known what the phase listeners delivered. Langium sets the
+     * document's state before it notifies, and a cancel between two listeners
+     * skips the rest, leaving the document at the phase with those listeners
+     * never run and nothing to run them later. A build-phase listener comes too
+     * late: a cancel after this document but before the batch ends skips it,
+     * although every listener of this document ran.
+     */
+    onDocumentPhaseDelivered(state: DocumentState, listener: DocumentPhaseDeliveredListener): Disposable;
+    /**
+     * Call `listener` when a build ends: once it has run every phase, which
+     * Langium's `onBuildPhase` cannot tell for a build that validates nothing,
+     * and once the lock has drained after builds that threw. Builds that throw
+     * before that drain share one call, so this does not count builds.
+     *
+     * A listener runs synchronously, inside the build or inside the lock read
+     * that waits for the drain, so it must not wait on a build. One that
+     * throws is logged and skipped; the build and the other listeners go on.
+     */
+    onBuildEnded(listener: BuildEndedListener): Disposable;
+    /** Tell every {@link buildEndedListeners} entry, each in isolation. */
+    protected notifyBuildEnded(event: BuildEndedEvent): void;
+    /**
+     * Whether an explicit {@link build}, rather than {@link update}, is calling
+     * the `onUpdate` listeners. Langium calls them from both. A listener reads
+     * this before its first await, since it is set only while `build` runs
+     * synchronously, which reaches the listeners. That makes it exact while
+     * builds overlap, where no record of the running builds could tell which
+     * one is calling.
+     */
+    isInsideBuildUpdate(): boolean;
+    /**
+     * Whether the build calling the `onUpdate` listeners overlaps another build
+     * that still runs, such as an update outside the lock while a locked build
+     * runs. A listener reads this before its first await.
+     */
+    overlapsRunningBuild(): boolean;
+    /**
+     * Resolves once no build is in progress, however each ended, and never
+     * rejects. It is `undefined` between builds. During a lock read no locked
+     * build runs, so a build seen there runs outside the lock. Builds that
+     * overlap count until the last of them ends.
+     */
+    get activeBuild(): Promise<void> | undefined;
     /**
      * Diagnostic snapshot for use in timeout/error messages around document
      * state.
@@ -172,8 +319,33 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * duplicate what this already knows.
      */
     formatBuildStatus(uri: URI): string;
+    /**
+     * The last phase a rebuild reaches under {@link updateBuildOptions}:
+     * `Validated`, or {@link IntegrityService.SettledState} when rebuilds do
+     * not validate, since no build then reaches `Validated` and a wait for it
+     * would never end. A document a `shouldValidate` override skips stops
+     * short of it; waiting on it is this builder's to resolve. An override that
+     * returns a phase rebuilds never reach makes every wait for it hang, the
+     * session writes that answer at it included.
+     */
+    finalBuildState(): DocumentState;
+    /**
+     * Whether the build that carries `document` validates it, as Langium's
+     * protected `shouldValidate` decides. One it does not validate ends that
+     * build at `IndexedReferences`. Answers for the running build once its
+     * first phase has started, and before that for the build that last
+     * carried `document`.
+     */
+    shouldValidateDocument(document: LangiumDocument): boolean;
     /** Render a session for a status line. `undefined` — no build in progress — reads as `none`. */
     protected formatSession(session: BuildSession | undefined): string;
+    /**
+     * Resolve once the document at `uri` reaches `state`, or without `uri`, once
+     * the workspace does. A wait on `uri` re-queues a document no build is
+     * carrying, as {@link awaitDocumentState} describes.
+     */
+    waitUntil(state: DocumentState, cancelToken?: CancellationToken): Promise<void>;
+    waitUntil(state: DocumentState, uri?: URI, cancelToken?: CancellationToken, options?: WaitUntilOptions): Promise<URI>;
     /**
      * Two edge cases the default Langium implementation rejects on:
      * - Document below target state with no build active (newly-created file):
@@ -188,15 +360,43 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      *
      * 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
+     * going to reach `state`. So the wait re-queues the document whenever
+     * {@link isOrphaned} holds: once when it is armed, and again after every
+     * build that completes (see {@link buildDocuments}). The second check is
+     * the one a wait armed during a build needs, since only the build's end
+     * shows whether it left the document behind; Langium's `onBuildPhase` for
+     * `Validated` cannot serve, as it stays silent for a build that validates
+     * nothing, such as the workspace's initial one. A build that throws is
+     * checked once the lock drains instead (see {@link checkWaitsOnceDrained}):
+     * whatever cancelled it may build nothing. 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.
+     * plus a warning rather than an endless build loop. With `rejectWhenStuck`,
+     * the wait rejects instead, both then and once
+     * `VersionSyncService.requestRecoveryBuild` gives up a re-queued build.
+     *
+     * A wait for `Validated` on a document that a validating build skips
+     * resolves once that build has indexed its references, without diagnostics:
+     * see {@link skipsValidation}. Waiting on would never end, and re-queuing
+     * would skip it again.
+     *
+     * A re-queued build takes the {@link WorkspaceLock} (see
+     * {@link requeueOrphaned}), so a caller that awaits this wait while it holds
+     * the lock, inside a read or write action, deadlocks on a document that needs
+     * a re-queue: the build waits for that action to end. Await it outside the
+     * lock.
+     */
+    protected awaitDocumentState(state: DocumentState, uri: URI, cancelToken: CancellationToken, { rejectWhenStuck }?: WaitUntilOptions): Promise<URI>;
+    /**
+     * Whether the build that carries or last carried `document` has indexed its
+     * references, asks for validation, and still skips it, which is an override
+     * of `shouldValidate` excluding it. A build that does not ask for
+     * validation, such as the workspace's initial one, is not a skip: the next
+     * validating build validates the document. Nor is a document below
+     * `IndexedReferences`: the build writes its options before the first phase,
+     * so the document would pass for skipped before it is even parsed.
      */
-    protected awaitDocumentState(state: DocumentState, uri: URI, cancelToken: CancellationToken): Promise<URI>;
+    protected skipsValidation(document: LangiumDocument): boolean;
     /**
      * Whether no build will advance `document` to `state`, so a wait on it can
      * only be resolved by starting one.
@@ -214,17 +414,151 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * `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.
+     * here. A read that arrives while that build still runs finds `currentState`
+     * below `state`, so this holds for it only once the build has ended, which
+     * is why {@link awaitDocumentState} asks again then.
      */
     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;
+     * Resolve once `currentState` reaches `state`, which {@link runCancelable}
+     * checks after every phase.
+     *
+     * Langium's waits for `onBuildPhase(state)`, which never fires for a wait
+     * armed while that phase notifies its listeners: the notification calls a
+     * copy of the listener list taken before it yields to the event loop, and
+     * `currentState` is raised only after it. Nor does it fire for a phase no
+     * document reached. Either way the wait never ends, and neither does the
+     * request Langium holds on it.
+     */
+    protected awaitBuilderState(state: DocumentState, cancelToken: CancellationToken): Promise<void>;
+    protected runCancelable(documents: LangiumDocument[], targetState: DocumentState, cancelToken: CancellationToken, callback: (document: LangiumDocument) => unknown): Promise<void>;
+    /**
+     * Schedule a build for a document no in-flight build will advance, through
+     * `VersionSyncService.requestRecoveryBuild`: from a {@link WorkspaceLock} read, so
+     * the build neither runs beside a locked one nor cancels the build a
+     * re-queue is fired from, and skipped if a write that ran meanwhile carried
+     * the document to `state`. The waiter resolves off the resulting phase
+     * notification; the promise only tells it whether the build was given up.
+     */
+    protected requeueOrphaned(document: LangiumDocument, state: DocumentState, reason: string): Promise<void>;
+    /**
+     * Build `changed` and `deleted` under the {@link WorkspaceLock}, as
+     * `workspaceLock.write(token => update(changed, deleted, token))` would,
+     * except where the build this method queued last already carries the
+     * request. The promise settles when the build that carries the request
+     * ends, completed or cancelled, as the lock's own promise does.
+     *
+     * Without it, requests that coincide cancel each other: each lock write
+     * cancels the one before it, after Langium's `update` has already reset the
+     * documents, scanned the workspace for relinking and called every
+     * `onUpdate` listener.
+     *
+     * - **Queued, not yet running:** the request merges into it, so nothing is
+     *   cancelled. The later of a change and a deletion of one URI wins, so
+     *   each URI reaches `update` in one list only: a file deleted and written
+     *   again before the build starts is a change.
+     * - **Running:** the request joins it only when {@link canJoinRunningUpdate}
+     *   holds, which keeps an edit made while it runs cancelling it.
+     * - **Otherwise,** or when anything else has cancelled that write since it
+     *   was queued, a new write, which cancels the running build as any lock
+     *   write does.
+     *
+     * `reason` is staged through {@link markNextReason} when the write runs. The
+     * latest reason of a merged request wins, as it does in the update
+     * handler's own debounced burst; a joining request's reason is dropped, since
+     * the build it joins has already started. A request without one leaves a
+     * reason staged by the caller in place.
+     *
+     * A caller that must run code of its own inside the write action takes the
+     * lock itself, and forgoes the sharing. A lock that is not a
+     * {@link HydraniumWorkspaceLock} cannot report a cancelled queued write, so
+     * every request then takes its own write.
+     */
+    scheduleUpdate(changed: URI[], deleted: URI[], reason?: string): Promise<void>;
+    /**
+     * Whether a request for `changed` and `deleted` is carried by the running
+     * `scheduled` build, whose write nothing has cancelled: the request deletes
+     * nothing, and each changed URI is one the build took, held by the text
+     * store at the version it had when the build started.
+     *
+     * Each condition keeps a request from joining a build that would miss its
+     * change. Text that moved since the start may be newer than what the build
+     * parsed; a URI the text store does not hold is read from its file, which
+     * may have changed after the build read it; and a deletion may concern a
+     * document the build has already built. A joined request is also absent
+     * from the running `update`'s `onUpdate` call, which reported the store as
+     * it was when the build started; at an unchanged version that is the store
+     * the request sees.
+     *
+     * The clients holding each URI must be unchanged too. Phase listeners that
+     * ask who holds a document, such as the push to an editor, may already have
+     * run for it, so a client that attached since would get no build that sees it.
+     */
+    protected canJoinRunningUpdate(scheduled: ScheduledUpdate, changed: URI[], deleted: URI[]): boolean;
+    /** The clients holding `uri` in the text store, or none when the store does not track them. */
+    protected clientsHolding(uri: URI): readonly string[];
+    /**
+     * The write action of a {@link scheduleUpdate}: freeze the request, record
+     * what it takes, stage its reason and run `update`. Releases
+     * {@link scheduledUpdate} inside the lock, whatever throws, so a request
+     * arriving after the build ends starts a write of its own rather than
+     * joining a build that is over.
+     */
+    protected runScheduledUpdate(request: ScheduledUpdate, token: CancellationToken): Promise<void>;
+    /**
+     * Tell the {@link buildEndedListeners} once every phase has run, which is
+     * the one point where a build that skipped a waited-on document can be seen
+     * to have ended. Langium's `onBuildPhase` for `Validated` is not: it stays
+     * silent when no document reached that phase, which is every build that
+     * validates nothing, the workspace's initial one among them.
+     *
+     * A build that throws, whether cancelled or failed, tells none of them
+     * here: `currentState` is then below `Validated`, so {@link isOrphaned}
+     * could hold for no wait. {@link checkWaitsOnceDrained} tells them instead.
+     */
+    protected buildDocuments(documents: LangiumDocument[], options: BuildOptions, cancelToken: CancellationToken): Promise<void>;
+    /**
+     * Graft the CST back onto every shed document the build advances, keeping
+     * its AST nodes so dependents outside the build stay linked to them.
+     * Indexing a document's references without its CST drops them from the
+     * reference index, so it would no longer be relinked when its targets
+     * change. Runs before Langium prepares the build, one document at a time
+     * with a cancellation check between, as the parse phase does. A refused or
+     * diverged graft resets the document to `Changed`, so this build re-parses
+     * it, and asks for a build after this one, whose relink selection reaches
+     * its dependents as those of a changed document. A document without a CST
+     * or a text to graft one from is reset the same way when it can be re-read.
+     */
+    protected rehydrateShedDocuments(documents: LangiumDocument[], cancelToken: CancellationToken): Promise<void>;
+    /**
+     * Whether `document` has an AST but no CST and no text to graft one from,
+     * as a `fromModel` document without a serializer has. Such a document is
+     * re-read when {@link hasReadableText}, so its references are indexed.
+     * Synchronous, so a build awaits nothing for a document with a CST.
+     */
+    protected hasNoCstToGraft(document: LangiumDocument): boolean;
+    /** Whether the store or a file holds the text of `document`. Without either, reading it would fail. */
+    protected hasReadableText(document: LangiumDocument): Promise<boolean>;
+    /**
+     * Unlink every document of the build that is below `Linked` but lists
+     * references, so the link phase resolves and indexes them. Such a document
+     * is mostly a code-built one, which holds the targets its code set until
+     * its first build. Any other document had references resolved before its
+     * link phase, by a cancelled build or a lazy read, and they are resolved
+     * again.
+     */
+    protected unlinkPrelinkedReferences(documents: LangiumDocument[]): void;
+    /**
+     * After a build that threw, tell the {@link buildEndedListeners}, with
+     * `completed` false, from a {@link WorkspaceLock} read: it runs once no write
+     * runs or is queued, so no locked build is left that could still carry a
+     * waited-on document. A cancelled build is usually followed by its
+     * canceller's, but a write that builds nothing, such as a release build
+     * that finds its document reopened, leaves a wait armed during the build
+     * with nothing to resolve it, and so does a build that fails. One read
+     * serves every build that throws before it runs.
+     */
+    protected checkWaitsOnceDrained(): void;
     /**
      * Don't let a cancelled non-validating build suppress validation forever.
      *
@@ -269,8 +603,11 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * 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.
+     *
+     * Public so a service that requests a build can skip one that would relink
+     * nothing.
      */
-    protected shouldRelink(document: LangiumDocument, changedUris: Set<string>): boolean;
+    shouldRelink(document: LangiumDocument, changedUris: Set<string>): boolean;
     update(changed: URI[], deleted: URI[], cancelToken?: CancellationToken): Promise<void>;
     /**
      * The workspace-initialization entry point, bracketed by a session like
@@ -339,6 +676,10 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * 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.
+     *
+     * Only this document is relinked. The documents that reference it still
+     * hold nodes a re-parse replaced, or names a mutation changed, so the
+     * caller has to relink them in a later build.
      */
     reparseAndRelink(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
     /**
@@ -368,9 +709,16 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * 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.
+     * load identity, and a symlink resolves to its real path so the built
+     * documents key the same way every other layer does.
+     *
+     * A URI with no on-disk content is dropped rather than read, unless the text
+     * store or the document registry holds it, under its canonical URI, the key
+     * both hold it by. A document created and not yet saved has text but no
+     * file, and a policy that checks the disk reports it absent. A registered
+     * document whose file has gone is kept too: its rebuild then fails on the
+     * read, which is how the release handler learns to remove it rather
+     * than leave it holding its last client's text.
      */
     protected flattenAndAdaptURI(uri: URI): URI[];
     /** Recurse `uri` through the `FileSystemProvider`, gathering registered
@@ -399,19 +747,20 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * readable by the time Langium's `update` consults `shouldRelink`.
      *
      * Teardown is preemption-correct, which is the reason this is framework code
-     * rather than a recipe. Langium's write mutex cancels an in-flight build when
-     * a later one arrives, so two sessions overlap: the successor installs itself
-     * as {@link activeSession} while the predecessor is still unwinding, and the
-     * predecessor's `finally` runs LAST. Clearing unconditionally there would
-     * discard the winner's state mid-build. Only the session that is still
-     * current clears — and the check is reference equality on the session object,
+     * rather than a recipe. A build outside the workspace lock overlaps another:
+     * the later one installs itself as {@link activeSession} while the earlier
+     * one is still running, and the earlier one's `finally` runs LAST. Clearing
+     * unconditionally there would discard the later build's state mid-build.
+     * Only the session that is still current clears — and the check is
+     * reference equality on the session object,
      * not on {@link BuildSession.traceId}, which is `undefined` for every build
      * whenever the timing level is suppressed and would compare equal to itself
      * across two different builds.
      *
-     * Re-entrancy is not hypothetical even without an adopter: {@link
-     * requeueOrphaned} calls `update` from inside a wait, while a build may be
-     * running.
+     * Builds outside the lock are not hypothetical even without an adopter: the
+     * model service under `allowReentrantBuilds` starts one. Two locked builds
+     * never overlap, since the lock starts a write only once the write it
+     * cancelled has unwound.
      */
     protected runInSession(context: BuildSessionContext, label: string, body: () => Promise<void>): Promise<void>;
     /**
@@ -479,8 +828,8 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * 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.
+     * The write lock prevents that at the source; this is the net for builds
+     * that skip it, as `ModelServiceOptions.allowReentrantBuilds` lets one do.
      *
      * 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
@@ -521,10 +870,11 @@ export declare class HydraniumDocumentBuilder extends DefaultDocumentBuilder {
      * **It inherits {@link dedupeDiagnostics}'s window, and therefore the same
      * precondition.** A build settling inside the listener window appends
      * diagnostics this pass never saw, and the publisher of the build that
-     * rendered sends them — unrendered. `ModelServiceOptions.serializeBuilds`
-     * closes it and defaults to `true`, so "every diagnostic is rendered" holds
-     * by default and is an opt-out rather than a guarantee. Opting out accepts
-     * unrendered diagnostics on exactly the terms it already accepts duplicates.
+     * rendered sends them — unrendered. The write lock closes it, so "every
+     * diagnostic is rendered" holds while
+     * `ModelServiceOptions.allowReentrantBuilds` is `false`, its default.
+     * Turning it on accepts unrendered diagnostics on exactly the terms it
+     * already accepts duplicates.
      *
      * Entries are REPLACED rather than mutated: `sendDiagnostics` passes the
      * array by reference and serialises later, so an in-place message mutation

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

@@ -1 +1 @@
-{"version":3,"file":"document-builder.d.ts","sourceRoot":"","sources":["../../../src/langium/document-builder/document-builder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"document-builder.d.ts","sourceRoot":"","sources":["../../../src/langium/document-builder/document-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,KAAK,EACV,QAAQ,EACR,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,eAAe,EACf,KAAK,MAAM,EAEb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACJ,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,aAAa,EACb,KAAK,eAAe,EACpB,QAAQ,EAER,GAAG,EAEH,KAAK,aAAa,EAGpB,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,iBAAiB,EAAc,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAE3F,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAA+B,KAAK,mBAAmB,EAAa,MAAM,uCAAuC,CAAC;AACzH,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAE7E,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG5E,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,EAAE,aAAa,EAOhD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;sBACxB,SAAS;+BACA,kBAAkB;oCACb,uBAAuB;yBAClC,YAAY;2BACV,cAAc;EACpB,CAAC;AAWZ,gEAAgE;AAChE,MAAM,WAAW,sBAAuB,SAAQ,cAAc;IAC3D;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,EAAE,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACpD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACvD;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACpD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACtD;;;;;;;;;OASG;IACH,QAAQ,CAAC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CACxD;AAED,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAC9B;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC9B;AAED,wEAAwE;AACxE,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAElE,oFAAoF;AACpF,MAAM,MAAM,8BAA8B,GAAG,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAElG,2GAA2G;AAC3G,MAAM,WAAW,gBAAgB;IAC9B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC7B,6GAA6G;IAC7G,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnC,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnC,2IAA2I;IAC3I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sGAAsG;IACtG,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,4GAA4G;IAC5G,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;IAC9C,2FAA2F;IAC3F,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,wBAAyB,SAAQ,sBAAsB;IACjE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAClC,6EAA6E;IAC7E,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAC1C,6EAA6E;IAC7E,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,aAAa,EAAE,CAAC;IACjD,gEAAgE;IAChE,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IACxD,4DAA4D;IAC5D,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAC3D,sEAAsE;IACtE,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IACxD,6FAA6F;IAC7F,SAAS,CAAC,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAC1D,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;IAChD,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAChC,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IACpD,oDAAoD;IACpD,SAAS,CAAC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IAChD,kGAAkG;IAClG,SAAS,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC;IAC5C,kIAAkI;IAClI,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,uBAAuB,CAAC;IAC7D,SAAS,CAAC,sBAAsB,EAAE,MAAM,EAAE,CAAM;IAChD,yHAAyH;IACzH,SAAS,CAAC,mBAAmB,SAAM;IACnC,mFAAmF;IACnF,SAAS,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC;IACrC,uFAAuF;IACvF,SAAS,CAAC,QAAQ,CAAC,kCAAkC,EAAE,OAAO,CAAC;IAC/D,2FAA2F;IAC3F,SAAS,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACvC;;;;;;;;OAQG;IACH,SAAS,CAAC,aAAa,CAAC,EAAE,YAAY,CAAC;IACvC,2GAA2G;IAC3G,SAAS,CAAC,iBAAiB,UAAS;IACpC,kDAAkD;IAClD,SAAS,CAAC,aAAa,SAAK;IAC5B,qFAAqF;IACrF,SAAS,CAAC,kBAAkB,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC9C;;;;OAIG;IACH,SAAS,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACxC,qEAAqE;IACrE,SAAS,CAAC,QAAQ,CAAC,+BAA+B,0DAAiE;IACnH,+CAA+C;IAC/C,SAAS,CAAC,QAAQ,CAAC,mBAAmB,0BAAiC;IACvE,8FAA8F;IAC9F,SAAS,CAAC,QAAQ,CAAC,iBAAiB,wBAA+B;IACnE,gFAAgF;IAChF,SAAS,CAAC,gBAAgB,UAAS;IACnC,sGAAsG;IACtG,SAAS,CAAC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;IAChE,mGAAmG;IACnG,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,mBAAmB,CAAC;IAC3D,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAE5C,YAAY,QAAQ,EAAE,2BAA2B,EAAE,OAAO,GAAE,sBAA2B,EAqBtF;IAMD;;;;;;;;;;OAUG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAE/C;IAED;;;;;;;;;;;;OAYG;IACH,wBAAwB,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,8BAA8B,GAAG,UAAU,CAGnG;IAED;;;;;;;;;OASG;IACH,YAAY,CAAC,QAAQ,EAAE,kBAAkB,GAAG,UAAU,CAGrD;IAED,uEAAuE;IACvE,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAQvD;IAED;;;;;;;OAOG;IACH,mBAAmB,IAAI,OAAO,CAE7B;IAED;;;;OAIG;IACH,oBAAoB,IAAI,OAAO,CAE9B;IAED;;;;;OAKG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAE3C;IAED;;;;;;;;;OASG;IACH,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAQlC;IAED;;;;;;;;OAQG;IACH,eAAe,IAAI,aAAa,CAE/B;IAED;;;;;;OAMG;IACH,sBAAsB,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAEzD;IAED,gGAAgG;IAChG,SAAS,CAAC,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,GAAG,MAAM,CAMjE;IAMD;;;;OAIG;IACM,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,WAAW,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAY/H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,UAAmB,kBAAkB,CAClC,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,iBAAiB,EAC9B,EAAE,eAAuB,EAAE,GAAE,gBAAqB,GAClD,OAAO,CAAC,GAAG,CAAC,CAwHd;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAM5D;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,CAAC,UAAU,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAE7E;IAED;;;;;;;;;;OAUG;IACH,UAAmB,iBAAiB,CAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBxG;IAED,UAAyB,aAAa,CACnC,SAAS,EAAE,eAAe,EAAE,EAC5B,WAAW,EAAE,aAAa,EAC1B,WAAW,EAAE,iBAAiB,EAC9B,QAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,GAChD,OAAO,CAAC,IAAI,CAAC,CAOf;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASxG;IAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,cAAc,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAuC7E;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CAAC,oBAAoB,CAAC,SAAS,EAAE,eAAe,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,OAAO,CAYlG;IAED,+FAA+F;IAC/F,SAAS,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,MAAM,EAAE,CAGpD;IAED;;;;;;OAMG;IACH,UAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBpG;IAED;;;;;;;;;;OAUG;IACH,UAAyB,cAAc,CACpC,SAAS,EAAE,eAAe,EAAE,EAC5B,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,iBAAiB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAKf;IAED;;;;;;;;;;;OAWG;IACH,UAAgB,sBAAsB,CAAC,SAAS,EAAE,eAAe,EAAE,EAAE,WAAW,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBlH;IAED;;;;;OAKG;IACH,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAQ5D;IAED,uGAAuG;IACvG,UAAgB,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAE3E;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,yBAAyB,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,IAAI,CAMtE;IAED;;;;;;;;;OASG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI,CAStC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAAmB,YAAY,CAAC,SAAS,EAAE,eAAe,EAAE,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI,CAazF;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACM,YAAY,CAAC,QAAQ,EAAE,eAAe,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAKlF;IAMQ,MAAM,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,WAAW,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAe9F;IAED;;;;OAIG;IACM,KAAK,CAAC,CAAC,SAAS,OAAO,EAC7B,SAAS,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACpC,OAAO,CAAC,EAAE,YAAY,EACtB,WAAW,CAAC,EAAE,iBAAiB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAaf;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACM,YAAY,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CAI3E;IAED;;;;;;;;;;OAUG;IACG,OAAO,CAAC,QAAQ,EAAE,eAAe,EAAE,WAAW,GAAE,iBAA0C,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/G;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,gBAAgB,CAAC,QAAQ,EAAE,eAAe,EAAE,WAAW,GAAE,iBAA0C,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBxH;IAED;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,4BAA4B,IAAI,IAAI,CAM7C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,CAQ5C;IAED;;mEAE+D;IAC/D,SAAS,CAAC,oBAAoB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,CAU9C;IAED;;mCAE+B;IAC/B,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAMvC;IAED,qFAAqF;IACrF,SAAS,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAE1C;IAED;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,CAW5C;IAMD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA0D5G;IAED;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAEvE;IAED;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAQhD;IAED;;;;OAIG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAOlD;IAED,yEAAyE;IACzE,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,MAAM,CAW7D;IAED,kHAAkH;IAClH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,MAAM,CAWlE;IAMD,SAAS,CAAC,sBAAsB,IAAI,IAAI,CAIvC;IAED,+FAA+F;IAC/F,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,IAAI,CASjF;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAaxG;IAMc,mBAAmB,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmDjI;IAED;;;;;;;;;;OAUG;IACH,SAAS,CAAC,0BAA0B,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK9H;IAED,8EAA8E;IAC9E,SAAS,CAAC,qBAAqB,CAC5B,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,qBAAqB,EAAE,EAClC,aAAa,EAAE,MAAM,EAAE,EACvB,OAAO,EAAE,MAAM,GACf,MAAM,CAQR;IAMc,gBAAgB,CAAC,SAAS,EAAE,eAAe,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAYjI;IAED,uEAAuE;IACvE,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/H;IAMD,iHAAiH;IACjH,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAEpC;IAED,uGAAuG;IACvG,SAAS,CAAC,cAAc,CAAC,QAAQ,EAAE,qBAAqB,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG/E;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,SAAS,CAAC,iBAAiB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAiC3D;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,SAAS,CAAC,iBAAiB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CA2B3D;IAMD;;;;;;;;OAQG;IACH,SAAS,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAOnC;IAED,uGAAuG;IACvG,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEpC;CACH"}