@hydranium/core 1.0.0-next.10

package/lib/langium/scope/hydranium-scope-provider.js

@@ -0,0 +1,543 @@
+/********************************************************************************
+ * 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 { isDocumentSource, isElementSource, isReferenceContext, isSyntheticSource } from '@hydranium/protocol';
+import { AstUtils, DefaultScopeProvider, MapScope, StreamScope, UriUtils, WorkspaceCache, stream } from '@hydranium/langium';
+import { isTieredDescription } from './scoped-ast-node-description.js';
+/**
+ * Per-language scope provider that owns the full scope chain in ONE
+ * class. Bridges the protocol-layer {@link ReferenceContext} to
+ * Langium's {@link ReferenceInfo}, layers per-context scope-extension
+ * contributions ({@link ScopeExtensionService}) at their declared tier,
+ * and composes the cached project-tier chain (own-project → dependency
+ * → universal) on top of Langium's unfiltered global index.
+ *
+ * ## Scope chain (high → low, inner shadows outer)
+ *
+ * ```
+ *   document-local (Langium precomputed)        [DefaultScopeProvider.getScope]
+ *     extension:local                           [layerLocalExtension, per-context]
+ *       own-project → dependency → universal-index   [createGlobalScope default, CACHED per ${project}::${refType}]
+ *         extension:universal                   [layerUniversalExtension, per-context, outermost]
+ * ```
+ *
+ * Implementation: Langium's `getScope` layers document-local on top of
+ * whatever `getGlobalScope` returns. The framework owns `getGlobalScope`
+ * and uses it to assemble everything *below* document-local, with the
+ * adopter-overridable {@link createGlobalScope} in the middle.
+ *
+ * ## Adopter override surface
+ *
+ * - **{@link createGlobalScope}** — the SINGLE level adopters override
+ *   to change the per-context global/project scope. Because extension
+ *   layering lives in framework-owned `getGlobalScope` outside
+ *   `createGlobalScope`, an adopter's bypass cannot hide the extension
+ *   layers.
+ * - Tier-walk hooks ({@link makeScopeContext}, {@link bucketFor},
+ *   {@link createOwnProjectScope}, {@link createDependencyScope},
+ *   {@link createUniversalScope}, {@link chainScopes},
+ *   {@link getProjectIdForDescription}) — override an individual tier
+ *   without re-implementing the whole project-tier walk.
+ * - Source-resolution hooks ({@link resolveSyntheticSource},
+ *   {@link resolveRootElement}, {@link resolveElementByName}) — override
+ *   individual cases of the `ReferenceSource` switch.
+ * - **{@link createScopeForNodes}** — inherited from Langium and re-keyed by
+ *   the framework to bare own-names, so it is the helper a `getScope`
+ *   override uses to resolve a dotted member reference against a container
+ *   the reference chain cannot reach.
+ *
+ * **Do NOT override `getGlobalScope` itself** — that is the framework's
+ * extension-assembly seam. Overriding it would hide the scope-extension
+ * layers behind your override.
+ *
+ * **Owns scope construction and reference resolution.** The complementary
+ * candidate-side pipeline (filter / sort / dedupe / build wire DTO) lives
+ * on `ReferenceCandidateProvider` in the sibling
+ * `reference-candidate-provider.ts` module.
+ */
+export class HydraniumScopeProvider extends DefaultScopeProvider {
+    services;
+    langiumDocuments;
+    astNodeLocator;
+    scopeExtensionService;
+    options;
+    /**
+     * Cache keyed by `${sourceProjectId}::${referenceType}`. Result is
+     * the chained `project → public → universal` scope built from one
+     * single-pass partition over the global index. Evicted by
+     * Langium's `DocumentBuilder.onUpdate` (the `WorkspaceCache` default)
+     * so any index change rebuilds.
+     *
+     * Per-language by design — the cache key already includes `refType`,
+     * which is language-specific, so nothing is shared across languages
+     * even though the `WorkspaceCache(services.shared)` instance evicts on
+     * the workspace-global `DocumentBuilder.onUpdate`.
+     */
+    scopeCache;
+    tracer;
+    constructor(services, options = {}) {
+        super(services);
+        this.services = services;
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        this.astNodeLocator = services.workspace.AstNodeLocator;
+        this.scopeExtensionService = services.references.ScopeExtensionService;
+        this.options = options;
+        this.scopeCache = new WorkspaceCache(services.shared);
+        this.tracer = services.shared.Tracer.for(options.logName ?? 'ScopeProvider').trace('instantiated');
+    }
+    /**
+     * Framework-owned assembly seam. **Adopters do NOT override this** —
+     * override {@link createGlobalScope} instead. This method layers the
+     * scope-extension tiers around the adopter-overridable global scope.
+     *
+     * Langium's `DefaultScopeProvider.getScope` then layers document-local
+     * on top of this result, yielding the full chain documented on the
+     * class.
+     */
+    getGlobalScope(referenceType, context) {
+        const projectChain = this.createGlobalScope(referenceType, context);
+        const withUniversal = this.layerUniversalExtension(referenceType, context, projectChain);
+        return this.layerLocalExtension(referenceType, context, withUniversal);
+    }
+    /**
+     * The SINGLE adopter-overridable level of the project/global scope.
+     * Adopters override to change the per-context global scope for
+     * specific reference contexts — e.g. return `EMPTY_SCOPE` to suppress
+     * the global scope entirely (so only document-local + extension:local
+     * remain), or return a raw unfiltered scope to bypass the project-tier
+     * filter for specific reference types.
+     *
+     * Default: builds the cached project-tier chain (own-project →
+     * dependency → universal) on top of Langium's unfiltered global index,
+     * keyed `${sourceProjectId}::${refType}` and evicted on workspace
+     * update. Returns the input scope unchanged when:
+     * - The source URI has no owning project (URIs outside any registered
+     *   project folder).
+     * - `ProjectManager.isSingleProject` reports `true` — the project
+     *   filter would be a no-op in a single-project workspace (the
+     *   synthetic workspace project owns everything, every tier is the
+     *   source's own tier).
+     *
+     * Adopters bypassing the tier filter should call
+     * {@link getAllElementsGlobalScope} to obtain the complete global
+     * scope (every element of the requested type, regardless of tier
+     * visibility), or `super.getGlobalScope` directly when even the
+     * helper is too much indirection.
+     */
+    createGlobalScope(referenceType, context) {
+        const langiumGlobal = super.getGlobalScope(referenceType, context);
+        const sourceUri = AstUtils.getDocument(context.container).uri;
+        return this.getProjectScope(sourceUri, langiumGlobal, referenceType);
+    }
+    /**
+     * Layer scope-extension `local`-tier descriptions on top of `inner`.
+     * Returns `inner` unchanged when no extension contributes for the
+     * reference type (zero-cost common path).
+     */
+    layerLocalExtension(referenceType, context, inner) {
+        return this.scopeExtensionService.getLocalExtensionScope(referenceType, context.container, inner);
+    }
+    /**
+     * Layer scope-extension `universal`-tier descriptions BELOW `inner`
+     * (extensions appear last in the chain, shadowed by inner). Returns
+     * `inner` unchanged when no extension contributes for the reference
+     * type.
+     */
+    layerUniversalExtension(referenceType, context, inner) {
+        return this.scopeExtensionService.getUniversalExtensionScope(referenceType, context.container, inner);
+    }
+    /**
+     * Project-tier scope filter. Given a source URI and a global scope,
+     * returns the subset of descriptions whose owning project is visible
+     * from the URI's owning project — the project-dependency visibility
+     * model. Cached per `${sourceProjectId}::${referenceType}`.
+     *
+     * `referenceType` is part of the cache key — separate scopes per
+     * cross-reference type so name collisions across types don't shadow
+     * each other in the chain.
+     *
+     * Public for adopter consumption: code outside the scope chain that
+     * wants to apply the same project-tier filter to a custom scope (e.g.
+     * a candidate provider's introspection mode) calls this method.
+     */
+    getProjectScope(sourceUri, globalScope, referenceType) {
+        const projectManager = this.services.shared.workspace.ProjectManager;
+        const sourceProjectId = projectManager.getProject(sourceUri)?.id;
+        if (!sourceProjectId) {
+            return globalScope;
+        }
+        if (projectManager.isSingleProject()) {
+            return globalScope;
+        }
+        const cacheKey = `${sourceProjectId}::${referenceType}`;
+        return this.scopeCache.get(cacheKey, () => this.buildProjectScope(sourceProjectId, globalScope));
+    }
+    /**
+     * The complete global scope — every element of the requested
+     * reference type that the workspace knows about, with no tier
+     * filtering and no extension-layer composition. Use from inside a
+     * {@link createGlobalScope} override when a specific context needs
+     * to bypass the framework's project-tier visibility filter (e.g.
+     * a self-referential cross-reference that must see all candidate
+     * projects, including those outside the source's visibility
+     * closure).
+     *
+     * Contrast {@link getGlobalScope}, which applies the framework's
+     * tier filter to this set, and `getScope` (Langium default), which
+     * additionally merges in the local scope.
+     */
+    getAllElementsGlobalScope(referenceType, context) {
+        return super.getGlobalScope(referenceType, context);
+    }
+    /**
+     * Build the chained project scope from three tier sub-scopes. The
+     * single scope walk happens once in {@link makeScopeContext}; the
+     * sub-scope hooks classify the materialised array via {@link bucketFor}
+     * (cheap in-memory filtering, no extra scope/index walk). Chained
+     * inner-first so a more specific tier shadows a less specific one of
+     * the same name: own-project → dependency-projects → universal.
+     */
+    buildProjectScope(sourceProjectId, globalScope) {
+        const context = this.makeScopeContext(sourceProjectId, globalScope);
+        const ownScope = this.createOwnProjectScope(context);
+        const dependencyScope = this.createDependencyScope(context);
+        const universalScope = this.createUniversalScope(context);
+        return this.chainScopes(ownScope, dependencyScope, universalScope);
+    }
+    /**
+     * Build the per-query {@link ScopeContext}. Walks `globalScope` exactly
+     * once (the one scope walk per cache miss) and partitions it into
+     * per-tier buckets via a single pass over {@link bucketFor}, so the
+     * untagged URI-lookup fallback runs at most once per description.
+     */
+    makeScopeContext(sourceProjectId, globalScope) {
+        const visibleProjectIds = new Set(this.services.shared.workspace.ProjectManager.getVisibleProjects(sourceProjectId));
+        const descriptions = globalScope.getAllElements().toArray();
+        const ownProjectEntries = [];
+        const dependencyEntries = [];
+        const universalEntries = [];
+        for (const description of descriptions) {
+            switch (this.bucketFor(description, sourceProjectId, visibleProjectIds)) {
+                case 'project':
+                    ownProjectEntries.push(description);
+                    break;
+                case 'public':
+                    dependencyEntries.push(description);
+                    break;
+                case 'universal':
+                    universalEntries.push(description);
+                    break;
+                case 'hidden':
+                    break;
+            }
+        }
+        return { sourceProjectId, visibleProjectIds, descriptions, ownProjectEntries, dependencyEntries, universalEntries };
+    }
+    /**
+     * Own-project sub-scope — descriptions in the source's own project.
+     * Includes own-project `'public'`-tier descriptions when
+     * {@link HydraniumScopeProviderOptions.includeOwnProjectPublic} is set
+     * (routed to the own-project bucket by {@link bucketFor}). Returns a
+     * {@link StreamScope} (not {@link MapScope}) so same-name siblings are
+     * preserved rather than collapsed.
+     */
+    createOwnProjectScope(context) {
+        return new StreamScope(stream(context.ownProjectEntries));
+    }
+    /**
+     * Dependency-projects sub-scope — `'public'`-tier descriptions whose
+     * owning project is reachable through the source's dependency closure
+     * (own-project canonical filter applied by {@link bucketFor}).
+     */
+    createDependencyScope(context) {
+        return new StreamScope(stream(context.dependencyEntries));
+    }
+    /**
+     * Universal sub-scope — descriptions with no project association,
+     * visible everywhere unconditionally.
+     */
+    createUniversalScope(context) {
+        return new MapScope(context.universalEntries);
+    }
+    /**
+     * Chain three tier sub-scopes inner-first. The `outerScope` argument
+     * of {@link StreamScope} is consulted only when the inner stream has
+     * no match, so a more specific tier shadows a less specific one of
+     * the same name.
+     */
+    chainScopes(ownScope, dependencyScope, universalScope) {
+        return new StreamScope(ownScope.getAllElements(), new StreamScope(dependencyScope.getAllElements(), universalScope));
+    }
+    /**
+     * Classify a description into one of three sub-scope buckets, or
+     * `'hidden'` when it should not appear in the project-scope chain.
+     *
+     * Typed path (description carries `tier`):
+     * - `'local'` → hidden (defensive — locals belong to per-document map)
+     * - `'project'` → `'project'` iff `projectId === sourceProjectId`,
+     *   else hidden (equality check)
+     * - `'public'` → `'public'` iff `projectId !== sourceProjectId` AND
+     *   `projectId` in source's visibility closure; own-project public is
+     *   routed to `'project'` when
+     *   {@link HydraniumScopeProviderOptions.includeOwnProjectPublic} is
+     *   set, else hidden (own-project canonical filter + closure
+     *   membership)
+     * - `'universal'` → `'universal'` unconditionally
+     *
+     * Untagged path (no `tier` field) — preserved for backward-compat with
+     * third-party Langium services emitting plain descriptions: URI →
+     * project lookup via {@link getProjectIdForDescription}, then the same
+     * bucketing rule.
+     */
+    bucketFor(description, sourceProjectId, visibleProjectIds) {
+        if (isTieredDescription(description)) {
+            switch (description.tier) {
+                case 'local':
+                    return 'hidden';
+                case 'project':
+                    return description.projectId === sourceProjectId ? 'project' : 'hidden';
+                case 'public':
+                    if (description.projectId === sourceProjectId) {
+                        return this.options.includeOwnProjectPublic ? 'project' : 'hidden';
+                    }
+                    return description.projectId !== undefined && visibleProjectIds.has(description.projectId) ? 'public' : 'hidden';
+                case 'universal':
+                    return 'universal';
+            }
+        }
+        const projectId = this.getProjectIdForDescription(description);
+        if (projectId === undefined) {
+            return 'universal';
+        }
+        if (projectId === sourceProjectId) {
+            return 'project';
+        }
+        if (visibleProjectIds.has(projectId)) {
+            return 'public';
+        }
+        return 'hidden';
+    }
+    /**
+     * Map a description to its owning project's id. Default: look up via
+     * `ProjectManager.getProject(description.documentUri)`. A pure fallback
+     * path — consulted only for descriptions carrying no `tier` field.
+     */
+    getProjectIdForDescription(description) {
+        return this.services.shared.workspace.ProjectManager.getProject(description.documentUri)?.id;
+    }
+    /**
+     * Keys the scope by {@link NameProvider.getOwnName} instead of Langium's
+     * `getName`. Same correction `HydraniumScopeComputation.addLocalSymbol`
+     * makes to the local-symbols pass, for the same reason: `getName` defaults
+     * to the project-qualified form here, so the base would key a member scope
+     * by the fully qualified `Container.member` while the reference text after
+     * the dot is the bare `member` — and nothing reports the mismatch, because
+     * the scope is non-empty and only the lookup misses.
+     *
+     * Callers building a member scope should leave `outerScope` unset: a
+     * reference to a member the container does not have must fail rather than
+     * fall through to a same-named member on an unrelated type.
+     */
+    createScopeForNodes(elements, outerScope, options) {
+        const descriptions = stream(elements)
+            .map(node => {
+            const name = this.nameProvider.getOwnName(node);
+            // The framework's description provider stamps `tier: 'local'`, which
+            // is correct here — these are constructed, never indexed.
+            return name ? this.descriptions.createDescription(node, name, AstUtils.getDocument(node)) : undefined;
+        })
+            .nonNullable();
+        return new StreamScope(descriptions, outerScope, options);
+    }
+    /**
+     * Convert a protocol-layer {@link ReferenceContext} into a Langium
+     * {@link ReferenceInfo} the rest of the scope/linking machinery accepts.
+     *
+     * Walks `syntheticPath` by FABRICATING a type-only stub per step, so a
+     * scope can be queried for an element that does not exist yet — which is
+     * what synthetic paths are for. The stubs carry no children, so a caller
+     * that needs to read a collection off the leaf wants
+     * {@link resolveReferenceSource} instead, which walks the same path into
+     * the real tree.
+     *
+     * Throws if the context references an unresolvable source; callers
+     * that prefer a soft failure should catch and fall back to
+     * `EMPTY_SCOPE`.
+     */
+    referenceContextToInfo(ctx) {
+        let container = this.resolveReferenceSource(ctx.source);
+        if (!container) {
+            throw new Error('Invalid reference source');
+        }
+        for (const step of ctx.syntheticPath ?? []) {
+            container = {
+                $container: container,
+                $containerProperty: step.containerProperty,
+                // Part of Langium's own container contract, so a stub that omits it
+                // is an under-specified node: anything reading position off the
+                // chain (a key provider, an adopter scope extension) sees
+                // `undefined` where the caller named a slot.
+                $containerIndex: step.index,
+                $type: step.type
+            };
+        }
+        return {
+            reference: { $refText: '', ref: undefined },
+            container,
+            property: ctx.property
+        };
+    }
+    /**
+     * Resolve a protocol-layer {@link ReferenceRequest} via the scope built for
+     * its context. Returns `undefined` if the scope has no matching element or
+     * if the description can't be resolved to a node.
+     */
+    resolveReference(reference) {
+        try {
+            const referenceInfo = this.referenceContextToInfo(reference);
+            const description = this.getScope(referenceInfo).getElement(reference.value);
+            if (!description) {
+                return undefined;
+            }
+            if (description.node) {
+                return description.node;
+            }
+            const document = this.langiumDocuments.getDocument(description.documentUri);
+            if (!document) {
+                return undefined;
+            }
+            return this.astNodeLocator.getAstNode(document.parseResult.value, description.path);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Resolve the SOURCE side of a reference — the element a query is asked
+     * *from* — to a real node. Given a bare {@link ReferenceSource} it resolves
+     * the anchor; given a whole {@link ReferenceContext} it continues along
+     * `syntheticPath`, descending into the anchor's real children, and answers
+     * the leaf.
+     *
+     * The counterpart to {@link resolveReference}, which resolves the other end:
+     * that one answers what a reference POINTS AT, this one what the reference
+     * is written ON. Distinct again from {@link referenceContextToInfo}, which
+     * walks the same path but FABRICATES a type-only stub per step — the right
+     * shape for a scope query, the wrong one for reading a collection off the
+     * leaf, because a fabricated node has no children.
+     *
+     * A step addressing an array slot must carry `index`; without one the walk
+     * stops rather than descending into the array itself, since an array is not
+     * an `AstNode` and continuing would fail later somewhere unrelated. A step's
+     * `type` is NOT verified against the child that was found — it names what
+     * the caller expects, and narrowing on it would reject trees a permissive
+     * adopter grammar allows.
+     *
+     * Answers `undefined` as soon as any step is missing.
+     */
+    resolveReferenceSource(source) {
+        if (isReferenceContext(source)) {
+            return this.resolveContextLeaf(source);
+        }
+        if (isSyntheticSource(source)) {
+            return this.resolveSyntheticSource(source);
+        }
+        if (isDocumentSource(source)) {
+            return this.resolveRootElement(UriUtils.toUri(source.uri));
+        }
+        if (isElementSource(source)) {
+            return this.resolveElementByName(source.name, source.type);
+        }
+        return undefined;
+    }
+    /** Walk `syntheticPath` from the resolved anchor into real children. */
+    resolveContextLeaf(ctx) {
+        let node = this.resolveReferenceSource(ctx.source);
+        for (const step of ctx.syntheticPath ?? []) {
+            if (!node) {
+                return undefined;
+            }
+            const slot = node[step.containerProperty];
+            node = Array.isArray(slot)
+                ? step.index === undefined
+                    ? undefined
+                    : slot[step.index]
+                : slot;
+        }
+        return node ?? undefined;
+    }
+    /**
+     * Build a transient AST-node stub for a {@link SyntheticSource} request.
+     * Default: looks up the document via `LangiumDocuments` and uses its parse
+     * root as the container; returns `undefined` if the document isn't loaded.
+     * Consumers that need to materialise an empty document on demand (e.g.
+     * to query the scope before a file exists) override this.
+     */
+    resolveSyntheticSource(source) {
+        const document = this.langiumDocuments.getDocument(UriUtils.toUri(source.uri));
+        if (!document) {
+            return undefined;
+        }
+        return { $type: source.type, $container: document.parseResult.value };
+    }
+    /**
+     * Resolve the semantic root node of the document at `uri`. Default: looks
+     * up the document via `LangiumDocuments` and returns its parse-result root.
+     * Consumers with a custom "semantic root" notion (i.e. an inner element
+     * that is the meaningful root inside a wrapper grammar) override this.
+     */
+    resolveRootElement(uri) {
+        return this.langiumDocuments.getDocument(uri)?.parseResult.value;
+    }
+    /**
+     * Resolve a node by **name**, given an optional reference type for
+     * disambiguation.
+     *
+     * The contract on `name`:
+     *
+     * - It is a **qualified name** — the form a source-text writer would type,
+     *   normally `NameProvider.getProjectQualifiedName`. Not a bare own-name,
+     *   unless the adopter's naming scheme makes the two coincide.
+     * - It is **not rename-stable.** Renaming the element changes its name and
+     *   therefore this address. Callers holding an address across an edit must
+     *   re-derive it.
+     * - It is **distinct from the element key.** `ElementKeyProvider` produces a
+     *   handle that round-trips to a node *within one document* (used for GModel
+     *   ids and UI selection); this resolves a name against the whole workspace.
+     *   Neither substitutes for the other, and there is no framework identifier
+     *   that is both workspace-wide and rename-stable.
+     *
+     * Base implementation returns `undefined` — the framework does not decide
+     * which qualification level an adopter's names carry. Adopters override,
+     * typically by delegating to
+     * `HydraniumIndexManager.resolveElementByName`, which resolves against
+     * the `elementsByName` index that `HydraniumScopeComputation` populates.
+     */
+    resolveElementByName(_name, _type) {
+        return undefined;
+    }
+    /**
+     * Sort key for the candidate provider's
+     * `ReferenceCandidateProvider.getCandidateScope` pipeline. Default
+     * prefixes the qualified-name segment count so local (bare-name)
+     * entries surface before nested (`a.b.c`) entries, then sorts
+     * lexicographically. Adopters whose name provider uses a non-default
+     * separator inherit the default behaviour; adopters wanting a
+     * different rank override.
+     *
+     * Public because the LSP `CompletionProvider` reads the same sort key
+     * directly when assembling completion items, and the sibling candidate
+     * provider in `reference-candidate-provider.ts` reads it during
+     * its sort stage. Lives on the scope provider so both callers share
+     * one implementation.
+     */
+    sortText(description) {
+        return description.name.split(this.nameProvider.nameSeparator).length + '_' + description.name;
+    }
+}
+//# sourceMappingURL=hydranium-scope-provider.js.map

package/lib/langium/scope/hydranium-scope-provider.js.map

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

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

@@ -0,0 +1,18 @@
+/********************************************************************************
+ * 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 './ast-node-description-provider.js';
+export * from './reference-builder.js';
+export * from './reference-candidate-provider.js';
+export * from './hydranium-scope-computation.js';
+export * from './hydranium-scope-provider.js';
+export * from './scope-extension-contribution.js';
+export * from './scope-extension-service.js';
+export * from './scoped-ast-node-description.js';
+export * from './tier-specificity.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/langium/scope/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC"}

package/lib/langium/scope/index.js

@@ -0,0 +1,18 @@
+/********************************************************************************
+ * 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 './ast-node-description-provider.js';
+export * from './reference-builder.js';
+export * from './reference-candidate-provider.js';
+export * from './hydranium-scope-computation.js';
+export * from './hydranium-scope-provider.js';
+export * from './scope-extension-contribution.js';
+export * from './scope-extension-service.js';
+export * from './scoped-ast-node-description.js';
+export * from './tier-specificity.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/langium/scope/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC"}