@hydranium/protocol 1.0.0-next.10

package/lib/logger.js.map

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

package/lib/model-server.d.ts

@@ -0,0 +1,352 @@
+/********************************************************************************
+ * Copyright (c) 2023 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
+ ********************************************************************************/
+/**
+ * Generic model-server protocol types: lifecycle arguments, events, and
+ * cross-reference shapes. Free of any specific grammar, AST type, or
+ * language identifier — consumers parameterise the document/root types
+ * over `TRoot`.
+ */
+import type { TransferClientArgs } from './model-service/args';
+import type { ReferenceCandidate } from './model-service/reference-candidate';
+/** Open a document on behalf of a client. */
+export interface OpenModelArgs extends TransferClientArgs {
+    /**
+     * Overrides the language the URI's extension would resolve to. Supply it
+     * only when the extension does not decide — an unregistered extension, or a
+     * document being opened under a language other than its own. A wrong value
+     * routes the document to the wrong grammar and it parses as garbage rather
+     * than failing.
+     */
+    languageId?: string;
+    /**
+     * Seeds the shared version sequence, defaulting to `0`. Only the FIRST open
+     * of a URI consumes it; after that the server owns the sequence and advances
+     * it itself, so callers never fabricate later numbers.
+     */
+    version?: number;
+    /**
+     * Content to open the document with instead of reading the file. Absent
+     * means read from the filesystem, which is the normal case.
+     *
+     * Honoured only on the first open of a URI: opening an already-open document
+     * is a no-op, so passing `text` for one silently changes nothing. Write
+     * through the update path instead.
+     */
+    text?: string;
+}
+/** Close a previously-opened document for the client. */
+export interface CloseModelArgs extends TransferClientArgs {
+}
+export interface TransferUpdatedEvent<TDocument> {
+    document: TDocument;
+    sourceClientId: string;
+    /** See `ModelDocumentUpdateReason` in `./data/events` for the canonical reason set + semantics. */
+    reason: 'changed' | 'deleted' | 'rebuilt' | 'saved';
+}
+export interface TransferSavedEvent<TDocument> {
+    /** The document as persisted — the state that reached disk, not the state at request time. */
+    document: TDocument;
+    /**
+     * The client whose save produced this. Every co-editing client receives the
+     * event including the originator, so a recipient compares it against its own
+     * id to recognise its own echo; acting on that echo is how an update loop
+     * starts.
+     */
+    sourceClientId: string;
+}
+/**
+ * The source-side address for a reference query: where the lookup is asked
+ * from. One of three shapes — a {@link DocumentSource} (the root of a
+ * document at the given URI), an {@link ElementSource} (an element resolved
+ * by its qualified name), or a {@link SyntheticSource} (a transient
+ * element that does not yet exist on disk, used during element-creation
+ * flows).
+ *
+ * Construct via the {@link ReferenceSource} namespace factories
+ * (`ReferenceSource.document(uri)` / `.element(name, type?)` /
+ * `.synthetic(uri, type)`) rather than tag-field literals — the factories
+ * surface the three variants via autocomplete and centralise any future
+ * shape changes.
+ */
+export type ReferenceSource = DocumentSource | ElementSource | SyntheticSource;
+/** A reference anchored at the root element of a document, identified by URI. */
+export interface DocumentSource {
+    uri: string;
+}
+/**
+ * Narrow an unknown value to a {@link DocumentSource}. Not exclusive within
+ * {@link ReferenceSource}: a {@link SyntheticSource} also carries `uri`, so
+ * discriminating the union must try {@link isSyntheticSource} first.
+ */
+export declare function isDocumentSource(object: unknown): object is DocumentSource;
+/**
+ * A reference to an element identified by its **qualified name**, optionally
+ * narrowed by type.
+ *
+ * The name is the form a source-text writer would type — normally the
+ * project-qualified name (see `NameProvider.getProjectQualifiedName`). It is
+ * **not** rename-stable and is distinct from an element *key*: rename the
+ * element and this address changes. Clients that need a handle surviving
+ * renames address the element some other way; this shape addresses by name.
+ */
+export interface ElementSource {
+    /**
+     * The qualified name as a source-text writer would spell it — normally the
+     * project-qualified form. Resolution is by exact match against the index, so
+     * a partially-qualified or differently-cased spelling simply finds nothing
+     * rather than falling back to a looser search.
+     */
+    name: string;
+    /**
+     * Disambiguates when one name is claimed by several AST types. Absent means
+     * "any type", which for an ambiguous name resolves arbitrarily rather than
+     * failing — pass it whenever the caller knows what it is addressing.
+     */
+    type?: string;
+}
+export declare function isElementSource(object: unknown): object is ElementSource;
+/** An element of a document that does not yet exist on disk — used during element creation flows. */
+export interface SyntheticSource {
+    /**
+     * The document the element would belong to. That document must already be
+     * LOADED — the default resolution takes its parse root as the synthetic
+     * node's container and answers `undefined` when it is not, so a URI for a
+     * file that exists on disk but was never opened resolves to nothing.
+     */
+    uri: string;
+    /**
+     * The AST type the element will have. Required here, unlike on an
+     * {@link ElementSource}, because no node exists yet from which to infer it —
+     * it is what scoping filters candidates against.
+     */
+    type: string;
+}
+export declare function isSyntheticSource(object: unknown): object is SyntheticSource;
+/**
+ * Factory helpers for the {@link ReferenceSource} variants. Use instead of
+ * tag-field literals so a future shape change lands in one place.
+ */
+export declare namespace ReferenceSource {
+    function document(uri: string): DocumentSource;
+    function element(name: string, type?: string): ElementSource;
+    function synthetic(uri: string, type: string): SyntheticSource;
+}
+/**
+ * One step in a synthetic navigation path from a {@link ReferenceSource}
+ * toward the property whose references we want to query. Each step describes
+ * a transient AST node that does not yet exist in the document — e.g. an
+ * element being created via UI flow — and is spliced into the chain so the
+ * scope provider sees the world *as if* the synthetic child were already
+ * placed at that slot.
+ *
+ * The field names mirror Langium's `$type` / `$containerProperty` so adopter
+ * callsites read consistently with AST-side code.
+ *
+ * Construct via {@link SyntheticStep.of} rather than a tag-field literal.
+ */
+export interface SyntheticStep {
+    /**
+     * The AST `$type` the spliced node claims. Scoping filters candidates
+     * against it, so a type the grammar does not declare yields an empty scope
+     * rather than an error.
+     */
+    type: string;
+    /**
+     * The containment slot on the parent step, or on the source for the first
+     * step. It must name a real containment property of that parent: the walk
+     * builds the node unconditionally, so a wrong slot produces a plausible node
+     * in a place the grammar has no rule for, and the emptiness surfaces later
+     * as "no candidates".
+     */
+    containerProperty: string;
+    /**
+     * Which element of an array-valued {@link containerProperty} the step
+     * addresses. **Mandatory for an array slot** on the resolving read
+     * (`ScopeProvider.resolveReferenceSource` given a whole context), which
+     * stops rather than descend into the array itself; a scope query reads it
+     * only as the stub's `$containerIndex`, since a fabricated node has no
+     * siblings to sit between.
+     *
+     * Absent means the slot holds a single node. Naming an out-of-range element
+     * resolves to nothing rather than failing.
+     */
+    index?: number;
+}
+/**
+ * Narrow an unknown value to a {@link SyntheticStep} — for a consumer
+ * validating a step that arrived over the wire. Framework code builds steps
+ * through {@link SyntheticStep.of} and never needs the check, so the absent
+ * in-repo caller is the seam working rather than unused surface.
+ */
+export declare function isSyntheticStep(object: unknown): object is SyntheticStep;
+export declare namespace SyntheticStep {
+    /**
+     * Construct a single {@link SyntheticStep} — "which slot of the parent, of
+     * which AST type". Pass `index` to pin the step to an existing array
+     * element instead of a transient synthetic node.
+     */
+    function of(containerProperty: string, type: string, index?: number): SyntheticStep;
+    /**
+     * Construct a sequence of {@link SyntheticStep}s from `(containerProperty,
+     * type)` tuples. Convenience for 3+ step paths where repeating
+     * `SyntheticStep.of(...)` per entry is visually noisy. For 1-2 step paths
+     * the per-step factory typically reads more clearly.
+     */
+    function chain(...steps: ReadonlyArray<Parameters<typeof of>>): SyntheticStep[];
+}
+/**
+ * Describes the question "what reachable elements are valid for this property
+ * of this (possibly synthetic) source-side element?". The server resolves it
+ * to a list of reference candidates ({@link ReferenceCandidate} in
+ * `@hydranium/protocol/model-service`).
+ *
+ * Build via {@link ReferenceContext.builder} — the staged builder enforces
+ * the `source -> path -> property` order at compile time.
+ */
+export interface ReferenceContext {
+    /** Where the query originates — the source-side {@link ReferenceSource} the lookup is anchored at. */
+    source: ReferenceSource;
+    /**
+     * Synthetic navigation path from the source toward the leaf whose
+     * references we want. Each entry is a transient AST node spliced into
+     * the navigation chain — useful for elements that are being created or
+     * that cannot yet be identified canonically. Empty / absent for queries
+     * whose source IS the leaf.
+     */
+    syntheticPath?: SyntheticStep[];
+    /**
+     * The property of the leaf element (final step in {@link syntheticPath},
+     * or the source when the path is empty) whose reachable references we
+     * want to retrieve.
+     */
+    property: string;
+}
+/**
+ * Narrow a value to a {@link ReferenceContext}, discriminating it from a bare
+ * {@link ReferenceSource}. No source variant carries either `source` or
+ * `property`, so the pair is unambiguous — which is what lets one resolver
+ * accept both an anchor and a whole context.
+ */
+export declare function isReferenceContext(object: unknown): object is ReferenceContext;
+/**
+ * A concrete reference-resolution request: a {@link ReferenceContext} plus the
+ * written value to resolve. Extending the context makes resolution literally
+ * "the candidate query, narrowed to one value" — and a request carries a
+ * `syntheticPath` for free, so a reference anchored at a nested synthetic
+ * source resolves the same way it lists candidates.
+ *
+ * Build via {@link ReferenceRequest.builder} — same staged order as
+ * {@link ReferenceContext.builder}, ending with a mandatory `value`.
+ */
+export interface ReferenceRequest extends ReferenceContext {
+    /** The textual value (the `$refText`) of the reference we are resolving. */
+    value: string;
+}
+/**
+ * First builder stage: pick the {@link ReferenceSource} variant. Generic over
+ * the stage that `property()` lands on, so the context and request builders
+ * share the source/path stages and differ only at the terminal.
+ */
+export interface ReferenceSourceStage<TAfterProperty> {
+    /** Anchor at the semantic root of a loaded document — a {@link DocumentSource}. */
+    document(uri: string): ReferencePathStage<TAfterProperty>;
+    /** Anchor at an element addressed by qualified name — an {@link ElementSource}. */
+    element(name: string, type?: string): ReferencePathStage<TAfterProperty>;
+    /** Anchor at an element that does not exist yet — a {@link SyntheticSource}. */
+    synthetic(uri: string, type: string): ReferencePathStage<TAfterProperty>;
+}
+/**
+ * Second builder stage: append synthetic {@link SyntheticStep}s (repeatable,
+ * optional), then close on the leaf property. `step()` is unavailable after
+ * `property()`, which enforces the `source -> path -> property` order.
+ */
+export interface ReferencePathStage<TAfterProperty> {
+    /**
+     * Append one {@link SyntheticStep}, outermost first, and return a new stage
+     * carrying the extended path. The builder is persistent, so a stage held in
+     * a variable is a reusable prefix: stepping off it twice builds two paths,
+     * and neither can be changed afterwards by the other.
+     */
+    step(containerProperty: string, type: string, index?: number): ReferencePathStage<TAfterProperty>;
+    /** Name the leaf property and close the builder. */
+    property(property: string): TAfterProperty;
+}
+/** Context terminal — `property()` closed the chain; build the context. */
+export interface ReferenceContextBuildStage {
+    build(): ReferenceContext;
+}
+/** Request value stage — the value is mandatory before {@link ReferenceRequestBuildStage.build}. */
+export interface ReferenceRequestValueStage {
+    value(value: string): ReferenceRequestBuildStage;
+}
+/** Request terminal — build the request. */
+export interface ReferenceRequestBuildStage {
+    build(): ReferenceRequest;
+}
+export declare namespace ReferenceContext {
+    /** Staged builder entry — `source -> path -> property -> build`. */
+    function builder(): ReferenceSourceStage<ReferenceContextBuildStage>;
+}
+export declare namespace ReferenceRequest {
+    /** Staged builder entry — `source -> path -> property -> value -> build`. */
+    function builder(): ReferenceSourceStage<ReferenceRequestValueStage>;
+    /**
+     * Promote a {@link ReferenceContext} to a request using a selected
+     * candidate's value — the find -> select -> resolve flow. The candidate
+     * supplies only the value (it is target-side); the source / property /
+     * synthetic path come from the context the candidates were listed for.
+     * Accepts any {@link ReferenceCandidate} (a `ReferenceTarget` works too).
+     */
+    function from(context: ReferenceContext, candidate: ReferenceCandidate): ReferenceRequest;
+}
+/**
+ * Naming tier for `findNextName`-style lookups — which uniqueness
+ * scope a proposed name must be unique within. This is NOT the
+ * name-qualification axis, which decides how a name is spelled; the two are
+ * independent even though each spells two of its members `local` and
+ * `project`, and conflating them reads as an argument to rename `tier`.
+ *
+ * - `'local'` — unique within the document (the document root is the
+ *   uniqueness container).
+ * - `'project'` — unique within the owning project's document-qualified
+ *   namespace.
+ * - `'public'` — unique within the project-qualified (cross-project)
+ *   namespace.
+ */
+export type NameTier = 'local' | 'project' | 'public';
+/** Arguments for a next-free-name lookup. */
+export interface FindNextNameArgs {
+    /**
+     * Locates the document, and via its project the qualification context. The
+     * create-element flow is the main caller, so this may name a document that
+     * does not exist yet; only the `'local'` tier needs it to resolve to one.
+     */
+    uri: string;
+    /**
+     * The AST `$type` of the element being named. Collisions are only looked for
+     * among elements of that same type, so the returned name may still be taken
+     * by an element of another type.
+     */
+    type: string;
+    /**
+     * The desired base name, returned unchanged when it is already free and
+     * otherwise used as the stem a suffix is appended to. Any occurrence of the
+     * name separator is replaced first, so a proposal cannot smuggle in a
+     * qualified name.
+     */
+    proposal: string;
+    /**
+     * Which uniqueness scope the returned name must be free in — how wide a net
+     * to check for collisions. The result is always a bare own-name whatever the
+     * tier; this never changes how the name is spelled. Defaults to `'project'`.
+     * See {@link NameTier} for what each tier covers.
+     */
+    tier?: NameTier;
+}
+//# sourceMappingURL=model-server.d.ts.map

package/lib/model-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-server.d.ts","sourceRoot":"","sources":["../src/model-server.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAW9E,6CAA6C;AAC7C,MAAM,WAAW,aAAc,SAAQ,kBAAkB;IACtD;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,yDAAyD;AAEzD,MAAM,WAAW,cAAe,SAAQ,kBAAkB;CAAG;AAM7D,MAAM,WAAW,oBAAoB,CAAC,SAAS;IAC5C,QAAQ,EAAE,SAAS,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,mGAAmG;IACnG,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;CACtD;AAED,MAAM,WAAW,kBAAkB,CAAC,SAAS;IAC1C,8FAA8F;IAC9F,QAAQ,EAAE,SAAS,CAAC;IACpB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;CACzB;AAMD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,aAAa,GAAG,eAAe,CAAC;AAE/E,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC5B,GAAG,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,cAAc,CAE1E;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC3B;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,aAAa,CAExE;AAED,qGAAqG;AACrG,MAAM,WAAW,eAAe;IAC7B;;;;;OAKG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,eAAe,CAS5E;AAED;;;GAGG;AACH,yBAAiB,eAAe,CAAC;IAC9B,SAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAEpD;IACD,SAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,aAAa,CAElE;IACD,SAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAEpE;CACH;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC3B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;OAUG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,aAAa,CASxE;AAED,yBAAiB,aAAa,CAAC;IAC5B;;;;OAIG;IACH,SAAgB,EAAE,CAAC,iBAAiB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAEzF;IAED;;;;;OAKG;IACH,SAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,aAAa,EAAE,CAErF;CACH;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC9B,sGAAsG;IACtG,MAAM,EAAE,eAAe,CAAC;IACxB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,aAAa,EAAE,CAAC;IAChC;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,gBAAgB,CAQ9E;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACvD,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;CAChB;AAMD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB,CAAC,cAAc;IACjD,mFAAmF;IACnF,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAC,cAAc,CAAC,CAAC;IAC1D,mFAAmF;IACnF,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAAC,cAAc,CAAC,CAAC;IACzE,gFAAgF;IAChF,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAAC,cAAc,CAAC,CAAC;CAC3E;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB,CAAC,cAAc;IAC/C;;;;;OAKG;IACH,IAAI,CAAC,iBAAiB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAAC,cAAc,CAAC,CAAC;IAClG,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAAC;CAC7C;AAED,2EAA2E;AAC3E,MAAM,WAAW,0BAA0B;IACxC,KAAK,IAAI,gBAAgB,CAAC;CAC5B;AAED,oGAAoG;AACpG,MAAM,WAAW,0BAA0B;IACxC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,0BAA0B,CAAC;CACnD;AAED,4CAA4C;AAC5C,MAAM,WAAW,0BAA0B;IACxC,KAAK,IAAI,gBAAgB,CAAC;CAC5B;AA8BD,yBAAiB,gBAAgB,CAAC;IAC/B,oEAAoE;IACpE,SAAgB,OAAO,IAAI,oBAAoB,CAAC,0BAA0B,CAAC,CAE1E;CACH;AAED,yBAAiB,gBAAgB,CAAC;IAC/B,6EAA6E;IAC7E,SAAgB,OAAO,IAAI,oBAAoB,CAAC,0BAA0B,CAAC,CAI1E;IAED;;;;;;OAMG;IACH,SAAgB,IAAI,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,kBAAkB,GAAG,gBAAgB,CAE/F;CACH;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEtD,6CAA6C;AAC7C,MAAM,WAAW,gBAAgB;IAC9B;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC;CAClB"}

package/lib/model-server.js

@@ -0,0 +1,160 @@
+"use strict";
+/********************************************************************************
+ * Copyright (c) 2023 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
+ ********************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceRequest = exports.ReferenceContext = exports.SyntheticStep = exports.ReferenceSource = void 0;
+exports.isDocumentSource = isDocumentSource;
+exports.isElementSource = isElementSource;
+exports.isSyntheticSource = isSyntheticSource;
+exports.isSyntheticStep = isSyntheticStep;
+exports.isReferenceContext = isReferenceContext;
+/**
+ * Narrow an unknown value to a {@link DocumentSource}. Not exclusive within
+ * {@link ReferenceSource}: a {@link SyntheticSource} also carries `uri`, so
+ * discriminating the union must try {@link isSyntheticSource} first.
+ */
+function isDocumentSource(object) {
+    return !!object && typeof object === 'object' && 'uri' in object && typeof object.uri === 'string';
+}
+function isElementSource(object) {
+    return !!object && typeof object === 'object' && 'name' in object && typeof object.name === 'string';
+}
+function isSyntheticSource(object) {
+    return (!!object &&
+        typeof object === 'object' &&
+        'uri' in object &&
+        typeof object.uri === 'string' &&
+        'type' in object &&
+        typeof object.type === 'string');
+}
+/**
+ * Factory helpers for the {@link ReferenceSource} variants. Use instead of
+ * tag-field literals so a future shape change lands in one place.
+ */
+var ReferenceSource;
+(function (ReferenceSource) {
+    function document(uri) {
+        return { uri };
+    }
+    ReferenceSource.document = document;
+    function element(name, type) {
+        return { name, type };
+    }
+    ReferenceSource.element = element;
+    function synthetic(uri, type) {
+        return { uri, type };
+    }
+    ReferenceSource.synthetic = synthetic;
+})(ReferenceSource || (exports.ReferenceSource = ReferenceSource = {}));
+/**
+ * Narrow an unknown value to a {@link SyntheticStep} — for a consumer
+ * validating a step that arrived over the wire. Framework code builds steps
+ * through {@link SyntheticStep.of} and never needs the check, so the absent
+ * in-repo caller is the seam working rather than unused surface.
+ */
+function isSyntheticStep(object) {
+    return (!!object &&
+        typeof object === 'object' &&
+        'type' in object &&
+        typeof object.type === 'string' &&
+        'containerProperty' in object &&
+        typeof object.containerProperty === 'string');
+}
+var SyntheticStep;
+(function (SyntheticStep) {
+    /**
+     * Construct a single {@link SyntheticStep} — "which slot of the parent, of
+     * which AST type". Pass `index` to pin the step to an existing array
+     * element instead of a transient synthetic node.
+     */
+    function of(containerProperty, type, index) {
+        return { containerProperty, type, index };
+    }
+    SyntheticStep.of = of;
+    /**
+     * Construct a sequence of {@link SyntheticStep}s from `(containerProperty,
+     * type)` tuples. Convenience for 3+ step paths where repeating
+     * `SyntheticStep.of(...)` per entry is visually noisy. For 1-2 step paths
+     * the per-step factory typically reads more clearly.
+     */
+    function chain(...steps) {
+        return steps.map(step => of(...step));
+    }
+    SyntheticStep.chain = chain;
+})(SyntheticStep || (exports.SyntheticStep = SyntheticStep = {}));
+/**
+ * Narrow a value to a {@link ReferenceContext}, discriminating it from a bare
+ * {@link ReferenceSource}. No source variant carries either `source` or
+ * `property`, so the pair is unambiguous — which is what lets one resolver
+ * accept both an anchor and a whole context.
+ */
+function isReferenceContext(object) {
+    return (!!object &&
+        typeof object === 'object' &&
+        'source' in object &&
+        'property' in object &&
+        typeof object.property === 'string');
+}
+/**
+ * Shared builder engine for both reference builders. Accumulates the source
+ * and the synthetic path, then hands the assembled {@link ReferenceContext} to
+ * `onProperty`, which produces the builder-specific terminal stage.
+ *
+ * **Persistent, not accumulating.** Each `step()` returns a NEW stage over a
+ * copied path, and `property()` copies again into the context it emits. A
+ * mutable builder would make a held stage a shared cursor — two branches off it
+ * would build one path between them, and two contexts built from it would alias
+ * a single array that a later `step()` could still change underneath both.
+ * Copying a path of two or three entries costs nothing next to a scope query.
+ */
+function referenceBuilder(onProperty) {
+    const pathStageFor = (source, steps) => ({
+        step(containerProperty, type, index) {
+            return pathStageFor(source, [...steps, { containerProperty, type, index }]);
+        },
+        property(property) {
+            return onProperty(steps.length > 0 ? { source, property, syntheticPath: [...steps] } : { source, property });
+        }
+    });
+    return {
+        document: uri => pathStageFor({ uri }, []),
+        element: (name, type) => pathStageFor({ name, type }, []),
+        synthetic: (uri, type) => pathStageFor({ uri, type }, [])
+    };
+}
+var ReferenceContext;
+(function (ReferenceContext) {
+    /** Staged builder entry — `source -> path -> property -> build`. */
+    function builder() {
+        return referenceBuilder(context => ({ build: () => context }));
+    }
+    ReferenceContext.builder = builder;
+})(ReferenceContext || (exports.ReferenceContext = ReferenceContext = {}));
+var ReferenceRequest;
+(function (ReferenceRequest) {
+    /** Staged builder entry — `source -> path -> property -> value -> build`. */
+    function builder() {
+        return referenceBuilder(context => ({
+            value: (value) => ({ build: () => ({ ...context, value }) })
+        }));
+    }
+    ReferenceRequest.builder = builder;
+    /**
+     * Promote a {@link ReferenceContext} to a request using a selected
+     * candidate's value — the find -> select -> resolve flow. The candidate
+     * supplies only the value (it is target-side); the source / property /
+     * synthetic path come from the context the candidates were listed for.
+     * Accepts any {@link ReferenceCandidate} (a `ReferenceTarget` works too).
+     */
+    function from(context, candidate) {
+        return { ...context, value: candidate.value };
+    }
+    ReferenceRequest.from = from;
+})(ReferenceRequest || (exports.ReferenceRequest = ReferenceRequest = {}));
+//# sourceMappingURL=model-server.js.map

package/lib/model-server.js.map

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

package/lib/model-service/args.d.ts

@@ -0,0 +1,64 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+/**
+ * Argument shapes for the in-process `ModelService` facade — the
+ * canonical home for the lifecycle operation signatures. Implementation
+ * lives in `@hydranium/core/langium/model-service`; this protocol
+ * package owns the types so wire-side projections (the data-server
+ * protocol in `./data`) can structurally extend them rather than
+ * mirroring them by hand.
+ *
+ * `./model-server.ts` re-exports them, so an import from either path
+ * resolves.
+ */
+/** Identifies a client-document binding. Every facade operation carries these fields. */
+export interface TransferClientArgs {
+    /** Document URI. */
+    uri: string;
+    /** Stable identifier for the client invoking the operation. */
+    clientId: string;
+}
+/**
+ * Update a document's content via the in-process facade. `model` may be
+ * the structured (transfer-model or AST) root or its serialised textual
+ * form — implementations decide which is faster on their transport.
+ * Generic over `T` so adopters parameterise the structured shape against
+ * their grammar's transfer-model overlay; passing a string is always
+ * allowed.
+ */
+export interface TransferUpdateArgs<T> extends TransferClientArgs {
+    /** Structured model root or its serialised textual form. */
+    model: T | string;
+    /**
+     * Optional based-on version: the text-document version this update
+     * was authored against. When set, the server compares against its
+     * current text-document version for `uri` and throws
+     * `ConflictError` on mismatch. Omit to opt out of the gate — mirrors
+     * LSP's `OptionalVersionedTextDocumentIdentifier` posture, intended
+     * for headless / CLI / batch tooling without a meaningful based-on
+     * version.
+     */
+    baseVersion?: number;
+}
+/**
+ * Persist a document to disk via the in-process facade. Same `model`
+ * shape as {@link TransferUpdateArgs}.
+ */
+export interface TransferSaveArgs<T> extends TransferClientArgs {
+    /** Structured model root or its serialised textual form. */
+    model: T | string;
+    /**
+     * Optional based-on version — same semantics as
+     * {@link TransferUpdateArgs.baseVersion}. `save` delegates the gating
+     * check to its inner `update`, so this field threads through to the
+     * same `ConflictError` site.
+     */
+    baseVersion?: number;
+}
+//# sourceMappingURL=args.d.ts.map

package/lib/model-service/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/model-service/args.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;;;;;;GAUG;AAEH,yFAAyF;AACzF,MAAM,WAAW,kBAAkB;IAChC,oBAAoB;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,CAAE,SAAQ,kBAAkB;IAC9D,4DAA4D;IAC5D,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC;IAClB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAE,SAAQ,kBAAkB;IAC5D,4DAA4D;IAC5D,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC;IAClB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/lib/model-service/args.js

@@ -0,0 +1,11 @@
+"use strict";
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=args.js.map

package/lib/model-service/args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.js","sourceRoot":"","sources":["../../src/model-service/args.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF"}

package/lib/model-service/index.d.ts

@@ -0,0 +1,11 @@
+/********************************************************************************
+ * 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 './args';
+export * from './reference-candidate';
+//# sourceMappingURL=index.d.ts.map

package/lib/model-service/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/model-service/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAOlF,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC"}