@hydranium/core 1.0.0-next.10

package/lib/langium/service-registry.js

@@ -0,0 +1,258 @@
+/********************************************************************************
+ * 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 { AstUtils, DefaultServiceRegistry, isAstNode, URI } from '@hydranium/langium';
+import { buildLanguageTypeIndex } from './language-types.js';
+/**
+ * `DefaultServiceRegistry` whose `register` / `getServices` methods are typed
+ * with a consumer-specific extended-services type.
+ *
+ * Langium's stock `ServiceRegistry` returns the base `LangiumCoreServices`,
+ * which forces consumers to cast every time they reach for an extended
+ * service. By parameterising the registry with the consumer's full service
+ * type, the type narrowing happens at the registry boundary instead of every
+ * call site.
+ */
+export class HydraniumServiceRegistry extends DefaultServiceRegistry {
+    /**
+     * Shared services, held only so `workspace.TextDocuments` can be resolved
+     * per lookup instead of at construction.
+     */
+    sharedServices;
+    /** Backing field for {@link registrations}. */
+    _registrations = 0;
+    /**
+     * How many times {@link register} has been called — monotonic, and the
+     * cache key a consumer memoising over the registered set should use.
+     *
+     * `all.length` does not work for that: `register` writes into
+     * `languageIdMap` keyed by language id, so RE-registering an id replaces
+     * the entry and leaves the length unchanged. A consumer keyed on the count
+     * would then keep a cache built from the replaced language's metadata.
+     */
+    get registrations() {
+        return this._registrations;
+    }
+    constructor(services) {
+        // Deliberately NOT forwarded to `super`. Langium's constructor eagerly
+        // dereferences `services.workspace.TextDocuments`, which would make the
+        // registry construction-time dependent on it — and that path leads
+        // straight back here: TextDocuments → Tracer → Logger →
+        // `Settings.value` → `lsp.configurationRoot` → `ServiceRegistry.all`.
+        // Langium's injector throws on that cycle ("Cycle detected"). Holding
+        // the reference and resolving TextDocuments per lookup keeps Langium's
+        // languageId rung (see `getServices`) with no construction-time edge.
+        // Latent rather than live for an adopter that binds
+        // `lsp.configurationRoot` to a constant, which is exactly the kind of
+        // accident that should not be left for the next adopter to hit.
+        super();
+        this.sharedServices = services;
+    }
+    /**
+     * Supply the shared services after construction, for a registry built
+     * without them. Only fills an empty reference — an explicitly constructed
+     * one is never replaced. Called by `bootstrapLangiumLanguages` so the
+     * languageId rung works regardless of how the adopter's `ServiceRegistry`
+     * binding constructed the registry; without it, an adopter rebinding the
+     * slot with a zero-argument `new MyRegistry()` would silently lose that
+     * rung with nothing to indicate it.
+     */
+    acceptSharedServices(services) {
+        this.sharedServices ??= services;
+    }
+    register(language) {
+        super.register(language);
+        this._registrations++;
+    }
+    /**
+     * Langium's lookup ladder: an open document's declared `languageId`, then
+     * its file name, then its extension, then a throw. Because `super` was
+     * never given the services it reads `textDocuments` from, its own
+     * languageId rung is inert — so this supplies that rung and delegates
+     * every rung below it (and the throw) to `super`, rather than restating
+     * the ladder.
+     *
+     * The declared-id rung is what lets an `untitled:` or extensionless
+     * document route at all, and what gives an OPEN buffer's declared id
+     * precedence over its file extension.
+     *
+     * It does NOT make two languages that share a file extension workable, and
+     * `assertDistinctFileRouting` fails the boot on that configuration: only an
+     * open buffer has a declared id, while indexing, scope computation and
+     * validation route every CLOSED file in the workspace by extension, where
+     * Langium's last-registered-wins would silently hand half the workspace to
+     * the wrong grammar.
+     */
+    getServices(uri) {
+        const languageId = this.sharedServices?.workspace.TextDocuments?.get(uri)?.languageId;
+        if (languageId !== undefined) {
+            const byLanguageId = this.languageIdMap.get(languageId);
+            if (byLanguageId) {
+                return byLanguageId;
+            }
+            // A declared id nothing is registered for (a stale client
+            // contribution, a plain-text buffer) is not an error — fall through
+            // to the file-name and extension rungs.
+        }
+        return super.getServices(uri);
+    }
+}
+/**
+ * Annotate a generated {@link LanguageMetaData} constant with the
+ * extended-services type it indexes. Use once per grammar at module
+ * scope; the resulting handle is a stable identity for typed
+ * `getServices(metadata)` lookups.
+ */
+export function typedMetadata(metadata) {
+    return metadata;
+}
+function isLanguageMetaData(arg) {
+    return typeof arg === 'object' && arg !== null && 'languageId' in arg && 'fileExtensions' in arg;
+}
+/**
+ * Extended {@link HydraniumServiceRegistry}, adding the lookups the inherited
+ * URI-keyed `getServices(uri)` cannot answer:
+ *
+ * - **Typed metadata handle** — `getServices(metadata: TypedLanguageMetaData<T>)`
+ *   returns the registered services typed as `T | undefined`. The primary
+ *   path: callers hold a typed handle per grammar (constructed once via
+ *   {@link typedMetadata}) and resolve services without any caller-side cast.
+ * - **Anything that identifies a document** — {@link getServicesFor} takes an
+ *   AST node, a `URI` or a URI string, and abstains instead of throwing.
+ * - **String id escape hatch** — {@link getServicesById}, for a language id
+ *   derived dynamically (from a wire envelope) where the typed handle isn't
+ *   reachable at the call site.
+ * - **File extension escape hatch** — {@link getServicesByExtension}, for
+ *   file-routing logic that has no URI yet.
+ * - **Producible AST type** — {@link getServicesByType} returns every language
+ *   whose grammar can produce a `$type`, and {@link soleServicesByType}
+ *   narrows that to the unambiguous case. It is the only routing signal a
+ *   request that names no document carries at all.
+ *
+ * Two overload signatures on `getServices` discriminate at compile time
+ * — passing a `URI` keeps the inherited `TServices` return shape; passing a
+ * `TypedLanguageMetaData<T>` returns `T | undefined`.
+ *
+ * Langium's base `ServiceRegistry` type stays unchanged. The framework narrows
+ * its own `ServiceRegistry` slot to this class instead, so the extended lookups
+ * are reachable from the shared-services shapes without a cast.
+ */
+export class ExtendedServiceRegistry extends HydraniumServiceRegistry {
+    getServices(arg) {
+        if (isLanguageMetaData(arg)) {
+            return this.languageIdMap.get(arg.languageId);
+        }
+        return super.getServices(arg);
+    }
+    /**
+     * Lookup by anything that identifies a document — an AST node (routed by
+     * the document it lives in), a `URI`, or a URI string. `undefined` when the
+     * node has no document, or nothing routes the URI.
+     *
+     * **Abstains rather than throws**, unlike the inherited `getServices(uri)`.
+     * Throwing is right for a build pipeline, which must have a language for
+     * every document it builds, and wrong for a caller asking an optional
+     * question about an arbitrary target: a foreign reference target, a
+     * synthetic node, a directory URI. Same contract as
+     * {@link getServicesById}.
+     *
+     * **The per-target lookup belongs here, not at the call sites.** The thing
+     * to apply to a node is decided by the node's OWN document, and a caller
+     * that captures one provider and reuses it across nodes derives names and
+     * keys under the wrong grammar's `nameProperties` / `nameSeparator` the
+     * moment two languages differ — silently, since the result is a
+     * plausible-looking string. Hand-rolling the three steps (node to root
+     * document, abstain on miss, one ladder walk not two) is what let that
+     * defect recur; being a registry method makes the correct call the
+     * discoverable one, and the generic `TServices` return means no call site
+     * needs a cast.
+     *
+     * One walk of the lookup ladder: Langium implements `hasServices` as a
+     * try/catch around `getServices`, so the obvious `hasServices(uri) &&
+     * getServices(uri)` pair costs two walks on the happy path — and these are
+     * bulk paths, once per indexed node or serialised reference.
+     */
+    getServicesFor(target) {
+        const uri = isAstNode(target) ? AstUtils.findRootNode(target).$document?.uri : target;
+        if (uri === undefined) {
+            return undefined;
+        }
+        try {
+            return this.getServices(typeof uri === 'string' ? URI.parse(uri) : uri);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Lookup by raw `languageId` string. Returns `undefined` when no
+     * services have been registered for the id (vs. the URI overload's
+     * inherited Langium semantics, which throws on miss). Used for
+     * dynamically-routed lookups where the language id comes from
+     * external input.
+     */
+    getServicesById(languageId) {
+        return this.languageIdMap.get(languageId);
+    }
+    /**
+     * Lookup by file extension. Returns `undefined` when no services match.
+     * Useful for routing decisions that need to dispatch on file extension
+     * before a URI is available.
+     */
+    getServicesByExtension(extension) {
+        return this.fileExtensionMap.get(extension);
+    }
+    /**
+     * Every registered language whose grammar can PRODUCE `type`, in
+     * registration order. Empty when none can; more than one when several do
+     * (types reached through a grammar they both import).
+     *
+     * Returns the list rather than a single answer on purpose: "no language
+     * produces this" and "four do" are different facts, and a caller needs to
+     * tell them apart both to explain itself and to decide whether to fall
+     * through to another signal. The registry answers the fact; the head owns
+     * the policy. {@link soleServicesByType} is the shorthand for the common
+     * policy.
+     *
+     * Attribution is *produced, not mentioned* and *reachable from the entry
+     * rule, not merely present* — see `collectProducibleTypes`.
+     */
+    getServicesByType(type) {
+        return this.typeIndex.languagesFor(type);
+    }
+    /**
+     * The single language that can produce `type`, or `undefined` when none
+     * can or several can. The common policy over {@link getServicesByType}:
+     * an ambiguous type does not identify a language, so abstaining is the
+     * honest answer rather than taking the first.
+     */
+    soleServicesByType(type) {
+        const owners = this.getServicesByType(type);
+        return owners.length === 1 ? owners[0] : undefined;
+    }
+    /**
+     * Drop the memoised type index, so a language registered after the first
+     * type lookup is accounted for. The reason this index belongs on the
+     * registry rather than in a consumer's private memo: the registry is the
+     * one place that knows when the registered set changed.
+     */
+    register(language) {
+        super.register(language);
+        this._typeIndex = undefined;
+    }
+    _typeIndex;
+    /**
+     * Type → language index over the registered grammars, built on first use.
+     * Lazy because a grammar walk per language is not free and most lookups
+     * never need it; invalidated by {@link register}.
+     */
+    get typeIndex() {
+        return (this._typeIndex ??= buildLanguageTypeIndex(this.all));
+    }
+}
+//# sourceMappingURL=service-registry.js.map

package/lib/langium/service-registry.js.map

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

package/lib/langium/shared-services.d.ts

@@ -0,0 +1,98 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import type { Clock, Logger, Project, Tracer } from '@hydranium/protocol';
+import type { LangiumSharedCoreServices } from '@hydranium/langium';
+import type { SelfSaveRegistry } from '../documents/self-save-registry.js';
+import type { WritableFileSystemProvider } from '../documents/ast-document-manager.js';
+import type { BuildPhasePassService } from './build-phase-pass/build-phase-pass-service.js';
+import type { CstResidencyService } from './residency/cst-residency-service.js';
+import type { BuildPipelineIntegration } from './document-builder/build-pipeline-integration.js';
+import type { ProjectManager } from './project/project-manager.js';
+import type { ExtendedServiceRegistry } from './service-registry.js';
+import type { DocumentUriPolicy } from './workspace/document-uri-policy.js';
+import type { HydraniumWorkspaceManager } from './workspace/hydranium-workspace-manager.js';
+import type { AdditionalDocumentContribution } from './workspace/additional-document-contribution.js';
+/**
+ * Minimum shared-services shape every framework component reads from.
+ *
+ * Equivalent to Langium's `LangiumSharedCoreServices` enriched with the
+ * framework additions that other framework services consume: the dedicated
+ * {@link Clock}, {@link Logger} and {@link Tracer} top-level slots (injectable
+ * time source, emission-only logger, and the measure-and-emit tracer composed
+ * from the other two), the {@link AdditionalDocumentContribution} group, an
+ * {@link ExtendedServiceRegistry}, and on `workspace` a writable file-system
+ * provider plus {@link HydraniumWorkspaceManager}, {@link ProjectManager},
+ * {@link SelfSaveRegistry}, {@link BuildPipelineIntegration},
+ * {@link BuildPhasePassService}, {@link CstResidencyService} and
+ * {@link DocumentUriPolicy}.
+ *
+ * Declared structurally (interface extends + intersection on nested slots)
+ * so the full `ServerSharedServices` and any consumer-extended variant
+ * satisfy it without import cycles. Framework components
+ * that take `services` (workspace manager, index manager, document
+ * builder, ...) all take this single shape rather than a one-off type each.
+ *
+ * The fuller `ServerSharedServices` extends this for the LSP-bound surface
+ * (additional Langium services beyond core + the framework's full
+ * `ServerAddedSharedServices` declaration). Consumers writing their own
+ * framework component should prefer this minimal shape when they only need
+ * core services + framework defaults.
+ */
+export interface ServerSharedServicesMinimal<TProject extends Project = Project> extends LangiumSharedCoreServices {
+    Clock: Clock;
+    Logger: Logger;
+    Tracer: Tracer;
+    /**
+     * Contribution group of {@link AdditionalDocumentContribution}s the
+     * {@link HydraniumWorkspaceManager} drives from `loadAdditionalDocuments` at
+     * startup. The framework binds an empty default so the slot always resolves;
+     * adopters deep-merge contributions that seed built-in / stdlib documents.
+     */
+    additionalDocuments: Record<string, AdditionalDocumentContribution>;
+    /**
+     * Narrows Langium's base `ServiceRegistry` slot to the framework impl the
+     * framework always binds, so the abstaining lookups — `getServicesFor`
+     * above all — are reachable from the minimal surface without a cast. The
+     * generic stays at its `LangiumCoreServices` default: this shape is what a
+     * component reads when it needs core services only, and the LSP-bound
+     * surface re-narrows the same slot to
+     * `ExtendedServiceRegistry<ServerLanguageServices>`.
+     */
+    ServiceRegistry: ExtendedServiceRegistry;
+    workspace: LangiumSharedCoreServices['workspace'] & {
+        FileSystemProvider: WritableFileSystemProvider;
+        WorkspaceManager: HydraniumWorkspaceManager;
+        ProjectManager: ProjectManager<TProject>;
+        SelfSaveRegistry: SelfSaveRegistry;
+        BuildPipelineIntegration: BuildPipelineIntegration;
+        BuildPhasePassService: BuildPhasePassService;
+        CstResidencyService: CstResidencyService;
+        DocumentUriPolicy: DocumentUriPolicy;
+    };
+}
+/**
+ * Adapt a factory that reads framework shared slots to a Langium
+ * module-context slot, whose parameter is statically typed at Langium's
+ * narrower `LangiumSharedCoreServices`.
+ *
+ * **Why a narrowing is needed at all.** `DefaultSharedModuleContext`'s factory
+ * slots are Langium's, so they promise only Langium's core services. The tree
+ * actually passed at runtime is always the framework-extended one — composition
+ * wires every framework slot before any factory runs — but nothing in
+ * Langium's types can say so. The gap is generic erasure at a seam the
+ * framework does not own, not a modelling mistake, so it cannot be typed away;
+ * it can only be performed in ONE place instead of at every call site.
+ *
+ * This is that place: adopters write a plain typed lambda rather than
+ * repeating `services as ServerSharedServicesMinimal` per factory. The
+ * callback's parameter is {@link ServerSharedServicesMinimal}, which the
+ * fuller `ServerSharedServices` also satisfies.
+ */
+export declare function serverSharedFactory<TResult>(create: (services: ServerSharedServicesMinimal) => TResult): (services: unknown) => TResult;
+//# sourceMappingURL=shared-services.d.ts.map

package/lib/langium/shared-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-services.d.ts","sourceRoot":"","sources":["../../src/langium/shared-services.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AACvF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAC5F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kDAAkD,CAAC;AACjG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AAC5F,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iDAAiD,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,2BAA2B,CAAC,QAAQ,SAAS,OAAO,GAAG,OAAO,CAAE,SAAQ,yBAAyB;IAC/G,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAC;IACpE;;;;;;;;OAQG;IACH,eAAe,EAAE,uBAAuB,CAAC;IACzC,SAAS,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAAG;QAGjD,kBAAkB,EAAE,0BAA0B,CAAC;QAI/C,gBAAgB,EAAE,yBAAyB,CAAC;QAC5C,cAAc,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;QACzC,gBAAgB,EAAE,gBAAgB,CAAC;QACnC,wBAAwB,EAAE,wBAAwB,CAAC;QACnD,qBAAqB,EAAE,qBAAqB,CAAC;QAC7C,mBAAmB,EAAE,mBAAmB,CAAC;QACzC,iBAAiB,EAAE,iBAAiB,CAAC;KACvC,CAAC;CACJ;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE,2BAA2B,KAAK,OAAO,GAAG,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO,CAEvI"}

package/lib/langium/shared-services.js

@@ -0,0 +1,30 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+/**
+ * Adapt a factory that reads framework shared slots to a Langium
+ * module-context slot, whose parameter is statically typed at Langium's
+ * narrower `LangiumSharedCoreServices`.
+ *
+ * **Why a narrowing is needed at all.** `DefaultSharedModuleContext`'s factory
+ * slots are Langium's, so they promise only Langium's core services. The tree
+ * actually passed at runtime is always the framework-extended one — composition
+ * wires every framework slot before any factory runs — but nothing in
+ * Langium's types can say so. The gap is generic erasure at a seam the
+ * framework does not own, not a modelling mistake, so it cannot be typed away;
+ * it can only be performed in ONE place instead of at every call site.
+ *
+ * This is that place: adopters write a plain typed lambda rather than
+ * repeating `services as ServerSharedServicesMinimal` per factory. The
+ * callback's parameter is {@link ServerSharedServicesMinimal}, which the
+ * fuller `ServerSharedServices` also satisfies.
+ */
+export function serverSharedFactory(create) {
+    return services => create(services);
+}
+//# sourceMappingURL=shared-services.js.map

package/lib/langium/shared-services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-services.js","sourceRoot":"","sources":["../../src/langium/shared-services.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AA+ElF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,mBAAmB,CAAU,MAA0D;IACpG,OAAO,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,QAAuC,CAAC,CAAC;AACtE,CAAC"}

package/lib/langium/transfer/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 './transfer-encoder.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/lib/langium/transfer/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 './transfer-encoder.js';
+//# sourceMappingURL=index.js.map

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

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