@hydranium/core 1.0.0-next.10

package/lib/langium/residency/cst-residency-service.js

@@ -0,0 +1,349 @@
+/********************************************************************************
+ * 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 { asMutable, Debouncer, Format } from '@hydranium/protocol';
+import { AstUtils, DocumentState, URI } from '@hydranium/langium';
+/**
+ * Default priority of the CST-residency pass. Deliberately very high so it runs
+ * *last* among `Validated` build-phase passes (the registry iterates priority
+ * ascending): every other reaction to the build — an adopter's own derived-state
+ * pass included — settles while the CST is still guaranteed resident, before the
+ * residency policy arms the shed.
+ */
+export const CST_RESIDENCY_PASS_PRIORITY = 1_000_000;
+/**
+ * The build state a shed document must be reset to so the next build re-parses it
+ * and rebuilds its CST — and every `reference.$refNode` — before it is relinked or
+ * re-indexed (rehydration). It is `DocumentState.Changed` by necessity: the only
+ * state below `Parsed`, hence the only one that forces a re-parse rather than an
+ * in-place relink. Exposed as a named landmark of the residency feature (cf.
+ * `IntegrityService.SettledState`) so the document builder references the feature's
+ * declared recovery contract instead of a bare enum value.
+ */
+export const CST_REHYDRATION_RESET_STATE = DocumentState.Changed;
+/**
+ * Whether `document`'s CST has been shed by a residency policy: the AST root is
+ * resident but its `$cstNode` was nulled. The built-state and present-root guards
+ * exclude the `fromModel` INVALID placeholder and not-yet-parsed documents, which
+ * legitimately have no CST. The single definition of "shed", shared by
+ * {@link CstResidencyService} and the document builder's rehydrate-on-re-entry
+ * seam so the two cannot drift.
+ */
+export function isCstShed(document) {
+    return (document.state >= DocumentState.Parsed &&
+        document.parseResult?.value !== undefined &&
+        document.parseResult.value.$cstNode === undefined);
+}
+/**
+ * Reattach a CST to a shed document **on demand**, without a rebuild — the
+ * read-side counterpart of the build-side rehydrate-on-re-entry seam. Re-parses
+ * the document's retained text into a throwaway document, then **grafts** the
+ * fresh CST onto the already-built, resident AST nodes — preserving AST node
+ * identity, so every cross-reference *into* this document (resolved to a resident
+ * node) keeps pointing at the same object. The duplicate AST is discarded.
+ *
+ * Why this is needed: a read-only LSP request (go-to-definition / declaration /
+ * implementation / type-definition, call/type hierarchy) reads the *target's*
+ * live CST for its range and does **not** run a build, so the build-side
+ * rehydrate never fires. Into a currently-closed (shed) file those features would
+ * otherwise return "no definition". This restores the real CST so every CST
+ * reader works unchanged — it is not a per-feature patch.
+ *
+ * **Synchronous.** Closed-document text is in memory (Langium's
+ * `createTextDocumentGetter` closes over the original string), and
+ * {@link LangiumDocumentFactory.fromString} without a `CancellationToken` takes
+ * the synchronous `create()` path. That lets the sync `getNameNode` chokepoint
+ * drive it.
+ *
+ * **Identity-preserving graft.** For each AST node (paired by pre-order index
+ * with the fresh parse) the fresh `$cstNode` is moved onto the resident node and
+ * its CST→AST back-pointer (`cstNode.astNode`) is repointed to the resident node,
+ * so CST→AST readers (`findDeclarationNodeAtOffset(root.$cstNode, …).astNode`)
+ * reach the real, linked node rather than the throwaway parse. Each
+ * `reference.$refNode` is restored the same way (paired over
+ * {@link AstUtils.streamReferences}).
+ *
+ * **Safe degrade.** If the re-parse diverges structurally from the resident AST
+ * (different node count — should not happen for unchanged text, but a guard
+ * against drift) the graft is abandoned and the document stays shed; the caller
+ * degrades exactly as it did before (no wrong attachment).
+ *
+ * **Module-private mechanism.** The public entry points are
+ * {@link CstResidencyService.rehydrateNode} / {@link CstResidencyService.rehydrate},
+ * which resolve the factory themselves and are where a future read-side residency
+ * hook lands (see their note). The graft invariants live here, unopinionated
+ * about policy — and deliberately not exported, so they cannot be invoked (or
+ * partially overridden) outside the service.
+ *
+ * @returns `true` if the document now has a resident CST (already-resident is a
+ * no-op `true`); `false` if the text is unrecoverable or the re-parse diverged.
+ */
+function rehydrateCst(document, factory) {
+    const root = document.parseResult?.value;
+    if (root === undefined) {
+        return false;
+    }
+    if (root.$cstNode !== undefined) {
+        return true; // already resident — idempotent
+    }
+    const text = document.textDocument?.getText();
+    if (text === undefined) {
+        return false;
+    }
+    // No CancellationToken (3rd arg) → synchronous create() path.
+    const fresh = factory.fromString(text, document.uri);
+    const existingNodes = [...AstUtils.streamAst(root)];
+    const freshNodes = [...AstUtils.streamAst(fresh.parseResult.value)];
+    if (existingNodes.length !== freshNodes.length) {
+        return false; // structural divergence — stay shed rather than mis-attach
+    }
+    for (let index = 0; index < existingNodes.length; index++) {
+        const residentNode = existingNodes[index];
+        const freshNode = freshNodes[index];
+        const freshCst = freshNode.$cstNode;
+        asMutable(residentNode).$cstNode = freshCst;
+        if (freshCst) {
+            // The fresh composite CST node's `astNode` points at the throwaway parse;
+            // repoint it (and thus the leaf nodes that inherit via `container.astNode`)
+            // at the resident node so CST→AST navigation reaches the linked AST.
+            asMutable(freshCst).astNode = residentNode;
+        }
+        // Restore each reference's `$refNode` from the fresh parse. `streamReferences`
+        // yields a node's *own* cross-references only (not its descendants'), so this
+        // must run per node — paired by the stable key/array order a re-parse of the
+        // same text reproduces. The resolved `.ref` link is untouched (still resident).
+        const residentRefs = [...AstUtils.streamReferences(residentNode)];
+        const freshRefs = [...AstUtils.streamReferences(freshNode)];
+        if (residentRefs.length === freshRefs.length) {
+            for (let refIndex = 0; refIndex < residentRefs.length; refIndex++) {
+                asMutable(residentRefs[refIndex].reference).$refNode = freshRefs[refIndex].reference.$refNode;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Residency policy that reclaims memory by shedding the concrete syntax tree
+ * (CST) of closed documents while keeping their AST resident. Each build refreshes
+ * the idle window of the documents in its batch; when a closed, sheddable
+ * document's window elapses, every AST node's `$cstNode` and every reference's
+ * `$refNode` are nulled, and the CST root, `Range`s and `Position`s become
+ * unreachable and are collected.
+ *
+ * **Terminology.** *Residency* is the state axis (is the CST in memory? —
+ * `resident` vs `shed`); *shed* is both the act and the policy vocabulary (drop
+ * the CST and every `$refNode`, the document itself survives with its AST,
+ * links, and identity intact — deliberately NOT "evict", which would suggest the
+ * whole document leaves); *rehydrate* is the restore (re-derive the CST from the
+ * retained source text and graft it back, identity-preserving — deliberately not
+ * "reload", which would suggest bytes coming back unchanged).
+ *
+ * **Re-entry is safe.** A shed document that later re-enters a build (because it
+ * is relinked as an affected dependent, re-validated, or edited) is re-parsed
+ * first by `HydraniumDocumentBuilder.resetToState`
+ * ("rehydrate-on-re-entry"), which rebuilds the CST and every `$refNode`. That
+ * matters because Langium derives the reference index — and thus
+ * `IndexManager.isAffected` and the `segment` used by rename / find-references —
+ * from `$refNode`; without rehydration a re-index would silently drop the
+ * document's cross-references and its dependents would stop being relinked.
+ *
+ * Constructed with `(services, options)` and self-registers a `Validated`
+ * `BuildPhasePass`, which
+ * is why the framework constructs it eagerly — the pass must be registered before
+ * the first build. Shedding itself is opt-in: the bound default strategy is
+ * `always-keep`, so the pass runs and sheds nothing until an adopter rebinds the
+ * slot with a shedding strategy.
+ *
+ * **Read-side navigation under a shedding strategy.** Read-only LSP requests do
+ * not run a build, so they do not trigger the build-side rehydrate. Features that
+ * only read the document under the cursor (completion, symbols, formatting, …)
+ * see an open document, never a shed one, and index-based cross-file features
+ * (find-references, rename, workspace symbols) read the reference index — both
+ * unaffected. What does reach a shed document is anything reading a cross-file
+ * *target*: target-range navigation (go-to-definition / declaration /
+ * implementation / type & call hierarchy) reads the target's live CST for its
+ * range, and hover/completion documentation reads the target's preceding comment
+ * out of the same CST. Into a currently-closed (shed) file the CST is restored on
+ * demand by the identity-preserving graft of {@link rehydrateNode} /
+ * {@link rehydrate}, driven transparently from the framework
+ * `NameProvider.getNameNode` chokepoint, the comment provider, and
+ * `AbstractHydraniumLangiumDocuments.getOrCreateDocument`.
+ */
+export class CstResidencyService {
+    services;
+    strategy;
+    /** Bytes-per-node for the optional reclaim estimate in traces; `0` disables it. */
+    estimatedBytesPerShedNode;
+    clock;
+    tracer;
+    textDocuments;
+    langiumDocs;
+    /**
+     * Per-document idle timers (`shed-closed-when-idle` only). Each is a
+     * {@link Debouncer}: re-`schedule()`d every time the document is used (rides
+     * in a build batch), it fires once the document has been idle for `idleMs` and
+     * sheds it. Lazily created, keyed by URI string, reused across shed/rehydrate
+     * cycles, and all cancelled by {@link dispose}.
+     */
+    idleTimers = new Map();
+    shedTotal = 0;
+    constructor(services, options = {}) {
+        this.services = services;
+        this.strategy = options.strategy ?? { kind: 'always-keep' };
+        this.estimatedBytesPerShedNode = options.estimatedBytesPerShedNode ?? 0;
+        this.clock = services.Clock;
+        this.tracer = services.Tracer.for(options.logName ?? 'CstResidency').trace('instantiated');
+        this.textDocuments = services.workspace.TextDocuments;
+        this.langiumDocs = services.workspace.LangiumDocuments;
+        services.workspace.BuildPhasePassService.register({
+            id: 'framework:cst-residency:shed',
+            state: DocumentState.Validated,
+            priority: options.priority ?? CST_RESIDENCY_PASS_PRIORITY,
+            run: documents => this.onBuild(documents)
+        });
+    }
+    /**
+     * Restore `document`'s shed CST on demand — the ergonomic entry point over
+     * {@link rehydrateCst} (resolves the document factory itself). No-op `true`
+     * when the CST is resident, so read-side seams call it unconditionally.
+     *
+     * **Residency note (deliberate).** Rehydration does NOT count as a "use" for
+     * the `shed-closed-when-idle` idle timer (which is refreshed only by build
+     * inclusion). Consequence: a browse-heavy but never-rebuilt closed document
+     * keeps re-grafting on each navigation rather than staying resident. This is
+     * a chosen trade-off — build-recency covers the churn motivation, and a
+     * read-side residency hook (refresh the timer / count re-grafts) is deferred
+     * until navigation latency on shed files is actually observed to hurt. This
+     * method is where that hook goes.
+     */
+    rehydrate(document) {
+        return rehydrateCst(document, this.services.workspace.LangiumDocumentFactory);
+    }
+    /**
+     * Node-level convenience over {@link rehydrate}: a resident node (its
+     * `$cstNode` is set — true for every node of a non-shed document) returns
+     * `true` without even resolving the document, so hot read paths
+     * (`getNameNode`, comment lookup) call this unconditionally.
+     */
+    rehydrateNode(node) {
+        if (node.$cstNode !== undefined) {
+            return true;
+        }
+        return this.rehydrate(AstUtils.getDocument(node));
+    }
+    /**
+     * After each build, refresh the idle timer of every document in the batch: an
+     * open document keeps its CST (its timer is cancelled — formatting, hover and
+     * incremental edits need the CST), while a closed, sheddable document (re)arms
+     * its idle timer. Being relinked as a hot dependent therefore keeps a document
+     * resident, and a genuinely idle one sheds once `idleMs` elapses. No-op under
+     * `always-keep`. "Use" is build inclusion only; read-side navigation
+     * ({@link rehydrate}) deliberately does not count — see its note.
+     */
+    onBuild(documents) {
+        if (this.strategy.kind === 'always-keep') {
+            return;
+        }
+        for (const document of documents) {
+            const uri = document.uri.toString();
+            if (this.textDocuments.isOpenInAnyClient(uri)) {
+                this.idleTimers.get(uri)?.cancel();
+                continue;
+            }
+            if (!this.isSheddable(document)) {
+                continue;
+            }
+            this.idleTimerFor(uri).schedule();
+        }
+    }
+    /**
+     * The lazily-created idle {@link Debouncer} for `uri`. `idleMs` is read once at
+     * creation from the (necessarily `shed-closed-when-idle`) strategy; the fire
+     * handler re-resolves the live document so a shed/rehydrate cycle that replaced
+     * the document object still sheds the current one.
+     */
+    idleTimerFor(uri) {
+        let timer = this.idleTimers.get(uri);
+        if (timer === undefined) {
+            const idleMs = this.strategy.kind === 'shed-closed-when-idle' ? this.strategy.idleMs : 0;
+            timer = new Debouncer(this.clock, () => this.onIdle(uri), { delayMs: idleMs });
+            this.idleTimers.set(uri, timer);
+        }
+        return timer;
+    }
+    /**
+     * Idle-timer fire: shed the document's CST if it is still closed and resident.
+     * Re-checks open-state (a reopen within the window cancels the timer, but guard
+     * anyway) and resolves the current document by URI (it may have been deleted,
+     * or its object replaced by a rebuild).
+     */
+    onIdle(uri) {
+        if (this.textDocuments.isOpenInAnyClient(uri)) {
+            return;
+        }
+        const document = this.langiumDocs.getDocument(URI.parse(uri));
+        if (document === undefined) {
+            return;
+        }
+        this.shedTotal += this.shed(document);
+    }
+    /** Cancel and drop every idle timer — for clean shutdown and deterministic tests. */
+    dispose() {
+        for (const timer of this.idleTimers.values()) {
+            timer.dispose();
+        }
+        this.idleTimers.clear();
+    }
+    /**
+     * Whether a closed document may have its CST shed. Only documents whose text
+     * a re-parse on re-entry can recover are sheddable; the default admits
+     * `file`-scheme documents (re-read from disk) and excludes synthetic / in-memory
+     * documents — e.g. built-in definitions registered under a custom URI scheme —
+     * whose text lives only in the CST and would be lost irrecoverably (a later
+     * relink would `readFile` a non-existent path). Adopters override to refine.
+     */
+    isSheddable(document) {
+        return document.uri.scheme === 'file';
+    }
+    /**
+     * Shed one document's CST: null every AST node's `$cstNode` and every
+     * reference's `$refNode`. Returns the number of `$cstNode`s cleared (0 if the
+     * document is unparsed or already shed).
+     */
+    shed(document) {
+        const root = document.parseResult?.value;
+        if (root === undefined || root.$cstNode === undefined) {
+            return 0;
+        }
+        let cleared = 0;
+        for (const node of AstUtils.streamAst(root)) {
+            if (node.$cstNode) {
+                node.$cstNode = undefined;
+                cleared++;
+            }
+        }
+        for (const reference of document.references ?? []) {
+            if (reference.$refNode) {
+                reference.$refNode = undefined;
+            }
+        }
+        if (cleared > 0) {
+            this.tracer.debug(`shed CST of ${document.uri.toString()}: ${cleared} nodes${this.estimateSuffix(cleared)}`);
+        }
+        return cleared;
+    }
+    /**
+     * ` (~<bytes> reclaimed est.)` when {@link estimatedBytesPerShedNode} is set,
+     * else the empty string — so the exact node count is always logged and the
+     * (grammar-specific, opt-in) byte estimate is appended only when configured.
+     */
+    estimateSuffix(nodeCount) {
+        return this.estimatedBytesPerShedNode > 0 ? ` (~${Format.bytes(nodeCount * this.estimatedBytesPerShedNode)} reclaimed est.)` : '';
+    }
+}
+//# sourceMappingURL=cst-residency-service.js.map

package/lib/langium/residency/cst-residency-service.js.map

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

package/lib/langium/residency/index.d.ts

@@ -0,0 +1,10 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+export * from './cst-residency-service.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/langium/residency/index.d.ts.map

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

package/lib/langium/residency/index.js

@@ -0,0 +1,10 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+export * from './cst-residency-service.js';
+//# sourceMappingURL=index.js.map

package/lib/langium/residency/index.js.map

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

package/lib/langium/scope/ast-node-description-provider.d.ts

@@ -0,0 +1,122 @@
+/********************************************************************************
+ * 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 Tracer } from '@hydranium/protocol';
+import { type AstNode, type AstNodeDescription, DefaultAstNodeDescriptionProvider, type LangiumDocument } from '@hydranium/langium';
+import type { LogNameOptions } from '../diagnostics/logger.js';
+import type { HydraniumLanguageServices } from '../language-module.js';
+import { type DescriptionTier, type TieredAstNodeDescription } from './scoped-ast-node-description.js';
+/**
+ * Framework `AstNodeDescriptionProvider` extension. Adds four typed
+ * factory methods aligned with the {@link TieredAstNodeDescription} four-
+ * tier visibility model:
+ *
+ * - {@link createLocal}     — `tier: 'local'`; document-only (not in global index).
+ * - {@link createProject}   — `tier: 'project'`; owning project only (equality filter).
+ * - {@link createPublic}    — `tier: 'public'`; dependent projects only (own-project filter + closure).
+ * - {@link createUniversal} — `tier: 'universal'`; visible everywhere unconditionally.
+ *
+ * # Synthetic AST contributions
+ *
+ * Every factory requires a `LangiumDocument`. In-memory AST content with no
+ * file behind it reaches them by wrapping its root node in a virtual
+ * document through Langium's `LangiumDocumentFactory.fromModel`; see
+ * `virtualUri` for the URI-construction helper.
+ */
+export declare class HydraniumAstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
+    protected readonly tracer: Tracer;
+    constructor(services: HydraniumLanguageServices, options?: LogNameOptions);
+    /**
+     * Overrides the Langium base to stamp `tier: 'local'` on every plain
+     * description so no un-tiered descriptions escape into the framework
+     * filter pipeline. Callers that need a different tier must use
+     * {@link createProject}, {@link createPublic}, or {@link createUniversal}.
+     *
+     * The named factory methods bypass this override by calling
+     * `super.createDescription` to get a plain base before stamping the
+     * correct tier — so there is no create-then-overwrite cost.
+     */
+    createDescription(node: AstNode, name: string, document: LangiumDocument): TieredAstNodeDescription;
+    /**
+     * Build a {@link TieredAstNodeDescription} for a symbol visible only
+     * inside its document. Goes into the per-document local-symbols map
+     * via `ScopeComputation.collectLocalSymbols`; not exported into
+     * the workspace index.
+     *
+     * Local descriptions never carry `projectId` — the project filter
+     * never sees them, so a project tag would be unused.
+     */
+    createLocal(options: {
+        readonly node: AstNode;
+        readonly name: string;
+        readonly document: LangiumDocument;
+    }): TieredAstNodeDescription;
+    /**
+     * Build a {@link TieredAstNodeDescription} for a symbol visible inside
+     * its owning project only — the filter compares `projectId` against the
+     * source's project for equality, not for membership of the dependency
+     * closure. Cross-project access goes through the `'public'`-tier sibling
+     * that {@link createPublic} builds.
+     *
+     * `projectId` is required — the framework filter reads it directly to
+     * decide visibility instead of doing a URI → project lookup per
+     * description on the hot path. Pass the id of the project that owns
+     * `document`; the typical exporter sources it from
+     * `ProjectManager.getProject(document.uri)?.id` once per document.
+     */
+    createProject(options: {
+        readonly node: AstNode;
+        readonly name: string;
+        readonly document: LangiumDocument;
+        readonly projectId: string;
+    }): TieredAstNodeDescription;
+    /**
+     * Build a {@link TieredAstNodeDescription} at `tier: 'public'` — the
+     * public-tier sibling of a multi-tier emission. Visible to other
+     * projects in the source's dependency closure; suppressed inside its
+     * owning project (where the `'project'`-tier sibling under a shorter
+     * name is the canonical entry).
+     *
+     * `projectId` is REQUIRED. It identifies the owning project; the
+     * framework filter reads it directly to enforce the own-project
+     * canonical filter + closure membership without a URI-to-project
+     * lookup on the hot path.
+     *
+     * Use when exporting a node under two names — a short project-internal
+     * one and a workspace-qualified one.
+     */
+    createPublic(options: {
+        readonly node: AstNode;
+        readonly name: string;
+        readonly document: LangiumDocument;
+        readonly projectId: string;
+    }): TieredAstNodeDescription;
+    /**
+     * Build a {@link TieredAstNodeDescription} at `tier: 'universal'` —
+     * visible everywhere unconditionally. Used for synthetic / library /
+     * stdlib content with no project ownership.
+     *
+     * `projectId` is forbidden by the type signature; universal
+     * descriptions have no owning project. If the node DOES have an
+     * owning project and should participate in multi-tier emission, use
+     * {@link createPublic} instead.
+     */
+    createUniversal(options: {
+        readonly node: AstNode;
+        readonly name: string;
+        readonly document: LangiumDocument;
+    }): TieredAstNodeDescription;
+    /**
+     * Attach `tier` + `projectId` fields to a plain {@link AstNodeDescription}
+     * in place, narrowing the static type to {@link TieredAstNodeDescription}.
+     * Mutates `base` rather than copying — the input is treated as
+     * just-constructed and not aliased elsewhere.
+     */
+    protected toTiered(base: AstNodeDescription, tier: DescriptionTier, projectId?: string): TieredAstNodeDescription;
+}
+//# sourceMappingURL=ast-node-description-provider.d.ts.map

package/lib/langium/scope/ast-node-description-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-node-description-provider.d.ts","sourceRoot":"","sources":["../../../src/langium/scope/ast-node-description-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,kBAAkB,EAAE,iCAAiC,EAAE,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACpI,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEvG;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,mCAAoC,SAAQ,iCAAiC;IACvF,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEtB,QAAQ,EAAE,yBAAyB,EAAE,OAAO,GAAE,cAAmB;IAK7E;;;;;;;;;OASG;IACM,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,wBAAwB;IAI5G;;;;;;;;OAQG;IACH,WAAW,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;KAAE,GAAG,wBAAwB;IAIrI;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,OAAO,EAAE;QACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;QACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC7B,GAAG,wBAAwB;IAI5B;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,OAAO,EAAE;QACnB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;QACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC7B,GAAG,wBAAwB;IAI5B;;;;;;;;;OASG;IACH,eAAe,CAAC,OAAO,EAAE;QACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;KACrC,GAAG,wBAAwB;IAI5B;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,wBAAwB;CAGnH"}

package/lib/langium/scope/ast-node-description-provider.js

@@ -0,0 +1,115 @@
+/********************************************************************************
+ * 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 { DefaultAstNodeDescriptionProvider } from '@hydranium/langium';
+/**
+ * Framework `AstNodeDescriptionProvider` extension. Adds four typed
+ * factory methods aligned with the {@link TieredAstNodeDescription} four-
+ * tier visibility model:
+ *
+ * - {@link createLocal}     — `tier: 'local'`; document-only (not in global index).
+ * - {@link createProject}   — `tier: 'project'`; owning project only (equality filter).
+ * - {@link createPublic}    — `tier: 'public'`; dependent projects only (own-project filter + closure).
+ * - {@link createUniversal} — `tier: 'universal'`; visible everywhere unconditionally.
+ *
+ * # Synthetic AST contributions
+ *
+ * Every factory requires a `LangiumDocument`. In-memory AST content with no
+ * file behind it reaches them by wrapping its root node in a virtual
+ * document through Langium's `LangiumDocumentFactory.fromModel`; see
+ * `virtualUri` for the URI-construction helper.
+ */
+export class HydraniumAstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
+    tracer;
+    constructor(services, options = {}) {
+        super(services);
+        this.tracer = services.shared.Tracer.for(options.logName ?? 'AstNodeDescriptionProvider').trace('instantiated');
+    }
+    /**
+     * Overrides the Langium base to stamp `tier: 'local'` on every plain
+     * description so no un-tiered descriptions escape into the framework
+     * filter pipeline. Callers that need a different tier must use
+     * {@link createProject}, {@link createPublic}, or {@link createUniversal}.
+     *
+     * The named factory methods bypass this override by calling
+     * `super.createDescription` to get a plain base before stamping the
+     * correct tier — so there is no create-then-overwrite cost.
+     */
+    createDescription(node, name, document) {
+        return this.toTiered(super.createDescription(node, name, document), 'local');
+    }
+    /**
+     * Build a {@link TieredAstNodeDescription} for a symbol visible only
+     * inside its document. Goes into the per-document local-symbols map
+     * via `ScopeComputation.collectLocalSymbols`; not exported into
+     * the workspace index.
+     *
+     * Local descriptions never carry `projectId` — the project filter
+     * never sees them, so a project tag would be unused.
+     */
+    createLocal(options) {
+        return this.toTiered(super.createDescription(options.node, options.name, options.document), 'local');
+    }
+    /**
+     * Build a {@link TieredAstNodeDescription} for a symbol visible inside
+     * its owning project only — the filter compares `projectId` against the
+     * source's project for equality, not for membership of the dependency
+     * closure. Cross-project access goes through the `'public'`-tier sibling
+     * that {@link createPublic} builds.
+     *
+     * `projectId` is required — the framework filter reads it directly to
+     * decide visibility instead of doing a URI → project lookup per
+     * description on the hot path. Pass the id of the project that owns
+     * `document`; the typical exporter sources it from
+     * `ProjectManager.getProject(document.uri)?.id` once per document.
+     */
+    createProject(options) {
+        return this.toTiered(super.createDescription(options.node, options.name, options.document), 'project', options.projectId);
+    }
+    /**
+     * Build a {@link TieredAstNodeDescription} at `tier: 'public'` — the
+     * public-tier sibling of a multi-tier emission. Visible to other
+     * projects in the source's dependency closure; suppressed inside its
+     * owning project (where the `'project'`-tier sibling under a shorter
+     * name is the canonical entry).
+     *
+     * `projectId` is REQUIRED. It identifies the owning project; the
+     * framework filter reads it directly to enforce the own-project
+     * canonical filter + closure membership without a URI-to-project
+     * lookup on the hot path.
+     *
+     * Use when exporting a node under two names — a short project-internal
+     * one and a workspace-qualified one.
+     */
+    createPublic(options) {
+        return this.toTiered(super.createDescription(options.node, options.name, options.document), 'public', options.projectId);
+    }
+    /**
+     * Build a {@link TieredAstNodeDescription} at `tier: 'universal'` —
+     * visible everywhere unconditionally. Used for synthetic / library /
+     * stdlib content with no project ownership.
+     *
+     * `projectId` is forbidden by the type signature; universal
+     * descriptions have no owning project. If the node DOES have an
+     * owning project and should participate in multi-tier emission, use
+     * {@link createPublic} instead.
+     */
+    createUniversal(options) {
+        return this.toTiered(super.createDescription(options.node, options.name, options.document), 'universal');
+    }
+    /**
+     * Attach `tier` + `projectId` fields to a plain {@link AstNodeDescription}
+     * in place, narrowing the static type to {@link TieredAstNodeDescription}.
+     * Mutates `base` rather than copying — the input is treated as
+     * just-constructed and not aliased elsewhere.
+     */
+    toTiered(base, tier, projectId) {
+        return Object.assign(base, { tier, projectId });
+    }
+}
+//# sourceMappingURL=ast-node-description-provider.js.map

package/lib/langium/scope/ast-node-description-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-node-description-provider.js","sourceRoot":"","sources":["../../../src/langium/scope/ast-node-description-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,EAAyC,iCAAiC,EAAwB,MAAM,oBAAoB,CAAC;AAKpI;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,mCAAoC,SAAQ,iCAAiC;IACpE,MAAM,CAAS;IAElC,YAAY,QAAmC,EAAE,UAA0B,EAAE;QAC1E,KAAK,CAAC,QAAQ,CAAC,CAAC;QAChB,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,4BAA4B,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IACnH,CAAC;IAED;;;;;;;;;OASG;IACM,iBAAiB,CAAC,IAAa,EAAE,IAAY,EAAE,QAAyB;QAC9E,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC;IAChF,CAAC;IAED;;;;;;;;OAQG;IACH,WAAW,CAAC,OAA8F;QACvG,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC;IACxG,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,OAKb;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC7H,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,OAKZ;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5H,CAAC;IAED;;;;;;;;;OASG;IACH,eAAe,CAAC,OAIf;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,CAAC;IAC5G,CAAC;IAED;;;;;OAKG;IACO,QAAQ,CAAC,IAAwB,EAAE,IAAqB,EAAE,SAAkB;QACnF,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAA6B,CAAC;IAC/E,CAAC;CACH"}