@hydranium/core 1.0.0-next.10

package/lib/langium/integrity/integrity-rule.d.ts

@@ -0,0 +1,82 @@
+/********************************************************************************
+ * 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 Logger, type MaybePromise } from '@hydranium/protocol';
+import { type AstNode, DocumentState, type LangiumDocument } from '@hydranium/langium';
+import { type RegistryItem } from '../../util/registry.js';
+/**
+ * Integrity rules run during a build phase and may mutate the AST. Allowed
+ * phases are `Parsed` (before linking — a rule that touches only the parsed
+ * shape) and `Linked` (after cross-references are resolved — a rule that
+ * needs reference targets to exist).
+ */
+export type IntegrityPhase = DocumentState.Parsed | DocumentState.Linked;
+export declare namespace IntegrityPhase {
+    const Parsed: IntegrityPhase;
+    const Linked: IntegrityPhase;
+    /**
+     * The canonical set of phases at which integrity rules may run, in build
+     * order. Single source of truth: `IntegrityService.register` validates
+     * against it, and the framework's `BuildPipelineIntegration` registers one
+     * integrity pass per entry. A function (not a const) so it reads as an
+     * operation, distinct in kind from the `Parsed` / `Linked` phase-value
+     * constants — `IntegrityPhase.all` would look like a third phase. Returns a
+     * fresh array so callers cannot mutate the canonical set.
+     */
+    function all(): readonly IntegrityPhase[];
+    function toString(phase: DocumentState): string;
+}
+/**
+ * Controls how integrity corrections are persisted for *closed* files. The
+ * mode does not reach open files: their corrected text is delivered by the
+ * model service's settled-state sync, whatever the mode says.
+ *
+ * - `silent`: write to disk immediately; no editor involvement.
+ * - `editor`: open the file dirty via `applyEdit`. If the user closes without
+ *    saving, the correction is suppressed until the file changes or the
+ *    workspace reloads.
+ */
+export type IntegritySyncMode = 'silent' | 'editor';
+/**
+ * A single integrity rule that enforces a constraint on AST nodes of a given type
+ * at a specific build phase.
+ *
+ * Extends {@link RegistryItem}: {@link RegistryItem.priority} orders rules
+ * WITHIN one phase, never across phases, because each phase has its own
+ * bucket. Lower runs first; ties break by registration order.
+ */
+export interface IntegrityRule<T extends AstNode = AstNode> extends RegistryItem {
+    /** Which AST node type this rule applies to. */
+    readonly nodeType: string;
+    /** At which document state this rule should run. Be aware that extension properties may not be available in all phases. */
+    readonly phase: IntegrityPhase;
+    /**
+     * Apply the rule. Returns `true` if the AST was mutated.
+     *
+     * Mirrors Langium's `ValidationCheck` shape (`MaybePromise<void>`) so a
+     * rule that must consult an external system can return a promise without
+     * forcing every sync rule to pay a microtask tick per node. The
+     * framework's per-node dispatch uses `isPromiseLike` to keep sync
+     * rules on the synchronous fast path; async rules are awaited normally.
+     */
+    enforce(node: T, document: LangiumDocument, logger: Logger): MaybePromise<boolean>;
+}
+/**
+ * The author id an integrity correction would carry if integrity tagged
+ * authorship. **It does not.** A correction is an internal build step riding a
+ * user's own build, so tagging it would overwrite the last human author in the
+ * version history with a synthetic one; `getAuthor` reports `undefined` for an
+ * integrity-only mutation instead, which is the honest answer. None of the
+ * three delivery paths — settled-state sync for open files, the disk write in
+ * `silent` mode, staged pending content in `editor` mode — sets an author.
+ *
+ * Exported so a consumer can assert that a correction is NOT attributed to it,
+ * which is what catches a regression that starts tagging authorship again.
+ */
+export declare const INTEGRITY_CLIENT_ID = "integrity";
+//# sourceMappingURL=integrity-rule.d.ts.map

package/lib/langium/integrity/integrity-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity-rule.d.ts","sourceRoot":"","sources":["../../../src/langium/integrity/integrity-rule.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,KAAK,OAAO,EAAE,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC;AAEzE,yBAAiB,cAAc,CAAC;IACtB,MAAM,MAAM,EAAE,cAAqC,CAAC;IACpD,MAAM,MAAM,EAAE,cAAqC,CAAC;IAE3D;;;;;;;;OAQG;IACH,SAAgB,GAAG,IAAI,SAAS,cAAc,EAAE,CAE/C;IAED,SAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CASrD;CACH;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,CAAE,SAAQ,YAAY;IAC7E,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2HAA2H;IAC3H,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B;;;;;;;;OAQG;IACH,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;CACrF;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,cAAc,CAAC"}

package/lib/langium/integrity/integrity-rule.js

@@ -0,0 +1,52 @@
+/********************************************************************************
+ * 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 { DocumentState } from '@hydranium/langium';
+export var IntegrityPhase;
+(function (IntegrityPhase) {
+    IntegrityPhase.Parsed = DocumentState.Parsed;
+    IntegrityPhase.Linked = DocumentState.Linked;
+    /**
+     * The canonical set of phases at which integrity rules may run, in build
+     * order. Single source of truth: `IntegrityService.register` validates
+     * against it, and the framework's `BuildPipelineIntegration` registers one
+     * integrity pass per entry. A function (not a const) so it reads as an
+     * operation, distinct in kind from the `Parsed` / `Linked` phase-value
+     * constants — `IntegrityPhase.all` would look like a third phase. Returns a
+     * fresh array so callers cannot mutate the canonical set.
+     */
+    function all() {
+        return [IntegrityPhase.Parsed, IntegrityPhase.Linked];
+    }
+    IntegrityPhase.all = all;
+    function toString(phase) {
+        switch (phase) {
+            case DocumentState.Parsed:
+                return 'Parsed';
+            case DocumentState.Linked:
+                return 'Linked';
+            default:
+                return `Unknown(${phase})`;
+        }
+    }
+    IntegrityPhase.toString = toString;
+})(IntegrityPhase || (IntegrityPhase = {}));
+/**
+ * The author id an integrity correction would carry if integrity tagged
+ * authorship. **It does not.** A correction is an internal build step riding a
+ * user's own build, so tagging it would overwrite the last human author in the
+ * version history with a synthetic one; `getAuthor` reports `undefined` for an
+ * integrity-only mutation instead, which is the honest answer. None of the
+ * three delivery paths — settled-state sync for open files, the disk write in
+ * `silent` mode, staged pending content in `editor` mode — sets an author.
+ *
+ * Exported so a consumer can assert that a correction is NOT attributed to it,
+ * which is what catches a regression that starts tagging authorship again.
+ */
+export const INTEGRITY_CLIENT_ID = 'integrity';
+//# sourceMappingURL=integrity-rule.js.map

package/lib/langium/integrity/integrity-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity-rule.js","sourceRoot":"","sources":["../../../src/langium/integrity/integrity-rule.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,EAAgB,aAAa,EAAwB,MAAM,oBAAoB,CAAC;AAWvF,MAAM,KAAW,cAAc,CA2B9B;AA3BD,WAAiB,cAAc;IACf,qBAAM,GAAmB,aAAa,CAAC,MAAM,CAAC;IAC9C,qBAAM,GAAmB,aAAa,CAAC,MAAM,CAAC;IAE3D;;;;;;;;OAQG;IACH,SAAgB,GAAG;QAChB,OAAO,CAAC,eAAA,MAAM,EAAE,eAAA,MAAM,CAAC,CAAC;IAC3B,CAAC;IAFe,kBAAG,MAElB,CAAA;IAED,SAAgB,QAAQ,CAAC,KAAoB;QAC1C,QAAQ,KAAK,EAAE,CAAC;YACb,KAAK,aAAa,CAAC,MAAM;gBACtB,OAAO,QAAQ,CAAC;YACnB,KAAK,aAAa,CAAC,MAAM;gBACtB,OAAO,QAAQ,CAAC;YACnB;gBACG,OAAO,WAAW,KAAK,GAAG,CAAC;QACjC,CAAC;IACJ,CAAC;IATe,uBAAQ,WASvB,CAAA;AACJ,CAAC,EA3BgB,cAAc,KAAd,cAAc,QA2B9B;AAuCD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC"}

package/lib/langium/integrity/integrity-service.d.ts

@@ -0,0 +1,221 @@
+/********************************************************************************
+ * 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 { Logger, type ProfileSession, type Tracer } from '@hydranium/protocol';
+import { type AstNode, DocumentState, type LangiumDocument } from '@hydranium/langium';
+import { type CancellationToken, type Disposable } from 'vscode-languageserver';
+import { type HydraniumDocumentBuilder } from '../document-builder/document-builder.js';
+import { type TextDocument } from 'vscode-languageserver-textdocument';
+import { type WritableFileSystemProvider } from '../../documents/ast-document-manager.js';
+import { type LogNameOptions } from '../diagnostics/logger.js';
+import { type HydraniumTextDocuments } from '../../documents/hydranium-text-documents.js';
+import { Registry } from '../../util/registry.js';
+import { type ServerLanguageServices } from '../language-module.js';
+import { type IntegrityRuleRegistry } from './integrity-contribution.js';
+import { type IntegrityRule, type IntegritySyncMode } from './integrity-rule.js';
+/**
+ * Public contract for the per-language integrity-rule runner. Extends the
+ * {@link IntegrityRuleRegistry} (which a contribution receives, and which
+ * carries `register` alone) with `unregister` and the batch-enforcement
+ * entry point driven at the `Parsed` and `Linked` build phases.
+ *
+ * Adopter overrides go through {@link DefaultIntegrityService}; the
+ * interface keeps the public API stable while the correction machinery
+ * (`resyncDocument`, `syncCorrections`, formatting hooks, bucket caches)
+ * stays `protected` on the default class.
+ *
+ * Generic over `<TRoot extends AstNode>` so each consumer plugs in
+ * their own AST root type.
+ */
+export interface IntegrityService<TRoot extends AstNode = AstNode> extends IntegrityRuleRegistry {
+    /** Remove a rule by id. Returns `true` if a rule was removed. */
+    unregister(id: string): boolean;
+    /**
+     * Enforce all rules for `phase` across a batch of documents that have
+     * reached that build state. Per document, run the rules and, if any
+     * mutated the AST, resync the document text and propagate corrections.
+     * Driven by the framework integrity pass `BuildPipelineIntegration`
+     * registers on the build-phase-pass registry; not for general adopter use.
+     */
+    enforceBatch(documents: readonly LangiumDocument<TRoot>[], phase: DocumentState, cancelToken: CancellationToken): Promise<void>;
+    /**
+     * Run all rules for `phase` against one document's matching nodes, returning
+     * `true` if any rule mutated the AST. The single-document half of
+     * {@link enforceBatch}, which drives it per document.
+     *
+     * Declared here because it is the unit an adopter can drive directly — a
+     * rule-level test asserting "this rule fires at this phase and mutates"
+     * wants one document and a boolean, not a batch and a resync. Omitting it
+     * left that caller reaching through the interface to the default class.
+     */
+    enforceIntegrity(document: LangiumDocument<TRoot>, phase: DocumentState, cancelToken?: CancellationToken, session?: ProfileSession): Promise<boolean>;
+}
+export declare namespace IntegrityService {
+    /**
+     * The earliest document state at which integrity rules have completed and the
+     * resulting AST + serialised text are stable. Use this when you need
+     * consumable post-integrity content: syncing text to language clients,
+     * settling a save, loading the AST for diagram rendering, or resolving a
+     * deferred update().
+     *
+     * Do NOT use this when you need validation diagnostics — those are computed
+     * at `DocumentState.Validated` and delivered separately via `publishDiagnostics`
+     * or the `onModelUpdated` event.
+     *
+     * Invariant: integrity rules only register at Parsed or Linked, so the build
+     * is guaranteed post-integrity once it advances past `onBuildPhase(Linked)`
+     * into `IndexedReferences`. {@link IntegrityService.register} enforces this at
+     * runtime; if a future rule needs a later phase, this value must move forward
+     * and every call site re-evaluated.
+     */
+    const SettledState: DocumentState;
+}
+/**
+ * Construction options for {@link DefaultIntegrityService}. All fields
+ * optional — the defaults reproduce the framework's behaviour exactly.
+ */
+export interface IntegrityServiceOptions extends LogNameOptions {
+    /**
+     * Controls how corrections are persisted for closed files. Fixed at
+     * construction time — the runtime contract assumes the mode is
+     * stable across the service's lifetime, so changing it after rules
+     * have already fired for a document is undefined behaviour. Defaults
+     * to `'silent'`. See {@link IntegritySyncMode}.
+     */
+    readonly syncMode?: IntegritySyncMode;
+}
+/**
+ * Default {@link IntegrityService} implementation. Enforces rules,
+ * resyncs document text after mutations, and propagates corrections.
+ * The build-pipeline wiring lives in `BuildPipelineIntegration`,
+ * which registers the integrity passes that call {@link enforceBatch} —
+ * this class owns the rule logic, not the pass lifecycle.
+ *
+ * **Per-language service.** Bound in the per-language module and
+ * constructed with {@link ServerLanguageServices}: shared dependencies
+ * (text-document manager, file-system provider, workspace manager,
+ * logger, document builder) come from `services.shared`, while
+ * serialisation uses the service's own language
+ * `services.serializer.Serializer` directly — no per-URI
+ * `ServiceRegistry` lookup, because every document this instance
+ * processes is its own grammar (the orchestrator routes per language).
+ * Adopter subclasses thread the same `(services, options?)` shape.
+ */
+export declare class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements IntegrityService<TRoot> {
+    protected readonly services: ServerLanguageServices;
+    /** Registry of integrity rules, keyed by id. Adopters can `unregister(id)` to drop a built-in rule. */
+    protected readonly rules: Registry<IntegrityRule<AstNode>>;
+    /** One logger per rule, created at registration and dropped on unregister. */
+    protected ruleLoggers: Map<string, Logger>;
+    /**
+     * Rules bucketed by the phase they target, preserving the registry's
+     * priority order within each bucket. Rebuilt lazily on the first
+     * `enforceIntegrity` call after a registry mutation — staleness is detected
+     * via reference identity of the registry's cached array (see
+     * {@link Registry.all}). Filtering the rule list per call would instead
+     * allocate one transient array per document per phase, which a workspace
+     * whose documents all settle at the same phase pays on every build.
+     */
+    protected phaseBuckets: Map<DocumentState, readonly IntegrityRule<AstNode>[]>;
+    protected phaseBucketsFor: readonly IntegrityRule[] | undefined;
+    /** Controls how corrections are persisted for closed files. See {@link IntegritySyncMode}. */
+    protected readonly syncMode: IntegritySyncMode;
+    protected readonly textDocuments: HydraniumTextDocuments<TextDocument>;
+    protected readonly fileSystemProvider: WritableFileSystemProvider;
+    protected readonly tracer: Tracer;
+    /**
+     * The framework document builder, used to re-parse + re-link a document in place after a
+     * Linked-phase correction (see {@link resyncDocument}). The framework binds
+     * `shared.workspace.DocumentBuilder` to {@link HydraniumDocumentBuilder}; the narrowing
+     * cast surfaces its single-document phase runner.
+     */
+    protected readonly documentBuilder: HydraniumDocumentBuilder;
+    constructor(services: ServerLanguageServices, options?: IntegrityServiceOptions);
+    /**
+     * Enforce all rules for `phase` across a batch of documents that have
+     * reached that build state: per document run the rules and, if any
+     * mutated the AST, resync the document text and propagate corrections.
+     *
+     * Driven by the framework integrity pass `BuildPipelineIntegration`
+     * registers — a batch-level (not per-document) pass, because a mutation
+     * here reparses the document and must not race the per-document build
+     * progression. `cancelToken` is supplied by
+     * Langium's build pipeline and honoured between documents (and inside
+     * `enforceIntegrity` between nodes) so a build preempted by a
+     * concurrent write lock interrupts cleanly rather than running the
+     * rule set to completion against a doomed build.
+     */
+    enforceBatch(documents: readonly LangiumDocument[], phase: DocumentState, cancelToken: CancellationToken): Promise<void>;
+    /** Register a single integrity rule. The {@link IntegrityRuleRegistry} entry point. */
+    register<T extends AstNode>(rule: IntegrityRule<T>): Disposable;
+    /** Remove a rule by id. Returns `true` if a rule was removed. Useful for adopters that want to swap a built-in rule. */
+    unregister(id: string): boolean;
+    /**
+     * Run all rules for the given phase against matching AST nodes. Returns
+     * `true` if any rule mutated the AST.
+     *
+     * Per-rule await is gated by {@link isPromiseLike} so sync rules
+     * (the common case) skip the microtask per iteration — important on the
+     * Parsed/Linked phases which gate the rest of the build pipeline. The
+     * outer caller still pays exactly one microtask tick per
+     * `enforceIntegrity` call (any `async` function does), but no per-node ×
+     * per-rule cost is added when nothing is async.
+     *
+     * Single pass over the document's AST, with the phase's rules read from
+     * the cached bucket rather than filtered per call.
+     *
+     * `cancelToken` is honoured at the per-node boundary (after each node's
+     * full rule sweep) — coarser than per (node × rule) to avoid a microtask
+     * per inner iteration, finer than per-document so a long-running rule set
+     * on a large file can still interrupt mid-stream. Throws
+     * `OperationCancelled` when the token is cancelled; Langium's build
+     * pipeline absorbs the throw at the lock-holder.
+     */
+    enforceIntegrity(document: LangiumDocument, phase: DocumentState, cancelToken?: CancellationToken, session?: ProfileSession): Promise<boolean>;
+    /**
+     * Re-serialise the document text after AST mutations, propagate corrections,
+     * and re-parse at Parsed phase (safe because linking hasn't occurred yet).
+     *
+     * `cancelToken` is checked at entry so a preempted build skips the
+     * serialise / disk-write atomic; the steps inside resync are not further
+     * subdivided because each is a single fast operation that does not yield
+     * a natural interruption point.
+     */
+    protected resyncDocument(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Propagate a correction to disk and/or the editor. The corrected text is
+     * already in the synced store (in-place in {@link resyncDocument}); this
+     * method routes the out-of-band part by document registration:
+     *
+     * - **Open in the language client** → nothing to push here. The AST mutation
+     *   rode the current build, so `ModelService.syncToLanguageClient` (the
+     *   persistent integrity-settled listener) mirrors the corrected text to the
+     *   client by *content* (shadow diff) — no authorship rewrite, no second
+     *   rebuild.
+     * - **Closed, silent mode** → write to disk directly (disk is authoritative).
+     * - **Closed, editor mode** → stage so the next open picks it up via applyEdit.
+     */
+    protected syncCorrections(document: TextDocument): Promise<void>;
+    /**
+     * Format a rule's name for inclusion in user-facing diagnostic strings
+     * (error messages thrown during registration). Defaults to
+     * `label ?? id`. Adopters override when their error reporting needs
+     * richer rule context.
+     */
+    protected formatRule(rule: IntegrityRule): string;
+    /**
+     * Format an AST node for the per-mutation `trace` log line. Returns
+     * `'TypeName'` or `"TypeName('label')"` when the node carries a string
+     * `name` (preferred) or `id`. Empty-string name falls through to id;
+     * non-string properties are ignored. Adopters override to fold in
+     * domain-specific context.
+     */
+    protected formatNode(node: AstNode): string;
+    protected getPhaseBucket(phase: DocumentState): readonly IntegrityRule[];
+}
+//# sourceMappingURL=integrity-service.d.ts.map

package/lib/langium/integrity/integrity-service.d.ts.map

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