@hydranium/protocol 1.0.0-next.13 → 1.0.0-next.132

package/src/testing/catalogue-audit.ts

@@ -0,0 +1,111 @@
+/********************************************************************************
+ * 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 { collectMessages } from '../messages/primitives';
+
+/**
+ * Audit a translation catalogue against the codes that actually exist.
+ *
+ * **The one failure mode a catalogue has, and the only one nothing else
+ * catches.** A key naming no declared code falls back to the English — which is
+ * byte-identical to a deliberate omission, so a typo is invisible at runtime and
+ * indistinguishable from the partial-catalogue behaviour every adopter relies
+ * on. Nothing on the render path can tell them apart, `theia nls-extract`
+ * reports what the SOURCE declares rather than whether a catalogue matches it,
+ * and the framework's own gates see only the framework's own files.
+ *
+ * Shipped as test support rather than as a runtime check on purpose: an
+ * orphaned key is an authoring mistake, and failing a server boot over one would
+ * take a running product down for a cosmetic defect.
+ */
+
+/**
+ * Flatten a nested catalogue into the `/`-joined keys a message code is spelled
+ * with, dropping `_`-prefixed keys as notes to a human reader.
+ *
+ * Nesting is a HOST convention, not the framework's: Theia flattens a nested
+ * catalogue by joining keys with `/`, which is the separator a code already
+ * uses, so an adopter on that host writes the file nested and one handed
+ * straight to a `DefaultMessageRenderer` writes it flat. Both end up here.
+ *
+ * `_`-prefixed keys are dropped by PREFIX rather than by matching one literal
+ * name, so a second note added to a file cannot silently become a catalogue
+ * entry. A code is three `/`-separated segments, so no real entry can begin
+ * with `_`.
+ */
+export function flattenCatalogue(catalogue: Record<string, unknown>, prefix = ''): Record<string, string> {
+   const flat: Record<string, string> = {};
+   for (const [key, value] of Object.entries(catalogue)) {
+      if (key.startsWith('_')) {
+         continue;
+      }
+      const joined = prefix ? `${prefix}/${key}` : key;
+      if (typeof value === 'string') {
+         flat[joined] = value;
+      } else if (typeof value === 'object' && value !== null) {
+         Object.assign(flat, flattenCatalogue(value as Record<string, unknown>, joined));
+      }
+   }
+   return flat;
+}
+
+/** Options for {@link findUndeclaredCodes}. */
+export interface CatalogueAuditOptions {
+   /**
+    * Key prefixes to skip, for entries whose codes are NOT declared through a
+    * `defineMessage` barrel.
+    *
+    * The real case is a host's own mechanism: Theia's `nls.localize` takes its
+    * key as an inline literal at the call site, so those keys exist only in
+    * source text and no barrel can enumerate them. Keep this as narrow as the
+    * host layer actually is — exempting a namespace is exempting every typo in
+    * it, which is what this function exists to find.
+    */
+   readonly exemptPrefixes?: readonly string[];
+}
+
+/**
+ * Every catalogue key that names no code any of `barrels` declares.
+ *
+ * Barrels are taken as opaque objects and read with {@link collectMessages},
+ * which is what lets a caller pass a `import * as messages` namespace directly:
+ * a barrel's value type is a union of its declarations AND its functions, and
+ * filtering that union will not narrow to a `MessageDefinition`.
+ *
+ * Returns the offending keys rather than a boolean, so a failing assertion names
+ * WHICH key is wrong — a count says only that something is.
+ */
+export function findUndeclaredCodes(
+   catalogueKeys: readonly string[],
+   barrels: readonly object[],
+   options: CatalogueAuditOptions = {}
+): string[] {
+   const declared = new Set(barrels.flatMap(barrel => collectMessages(barrel).map(message => message.code)));
+   const exempt = options.exemptPrefixes ?? [];
+   return catalogueKeys.filter(key => !exempt.some(prefix => key.startsWith(prefix)) && !declared.has(key));
+}
+
+/**
+ * Keys present in more than one catalogue — the shape a split catalogue rots
+ * into.
+ *
+ * Exactly one side renders a given message, so two catalogues holding one code
+ * are two authorities over one sentence and they diverge on the first reword.
+ * Nothing at runtime notices: both sides render, and whichever ran last wins on
+ * its own surface.
+ *
+ * Takes the key sets rather than a boolean answer for the same reason as
+ * {@link findUndeclaredCodes}, and reports NOTHING when a set is empty — an
+ * empty catalogue shares no key with anything, so a caller must assert
+ * non-emptiness separately or a failed read passes this vacuously.
+ */
+export function findSharedCodes(first: readonly string[], second: readonly string[]): string[] {
+   const other = new Set(second);
+   return first.filter(key => other.has(key));
+}

package/src/testing/data-doubles.ts

@@ -34,7 +34,15 @@
 import { Emitter, type MessageConnection } from 'vscode-jsonrpc';
 import type { DataPort } from '../client/data-port';
 import type { DataClientProtocol } from '../data/data-server-protocol';
-import type { ProjectsChangedEvent, TransferDocumentSavedEvent, TransferDocumentUpdatedEvent } from '../data/events';
+import type {
+   ProjectsChangedEvent,
+   TransferDocumentDeletedEvent,
+   TransferDocumentDirtyChangedEvent,
+   TransferDocumentSavedEvent,
+   TransferDocumentsBuiltEvent,
+   TransferDocumentUpdatedEvent
+} from '../data/events';
+import type { ResolvedMessage } from '../messages/primitives';
 import type { Project } from '../project';
 import type { TransferDiagnostic } from '../transfer-diagnostic';
 import type { TransferElement } from '../transfer-element';
@@ -51,13 +59,6 @@ export interface FakeDataPortOptions {
     * which the consumer surfaces through {@link FakeDataPort.reported}.
     */
    connect(): MessageConnection | Promise<MessageConnection>;
-   /**
-    * Stable client identity. Defaults to `'fake-data-port'`, which avoids the
-    * three sentinels the framework reserves (`'language-client'`, `'unknown'`,
-    * `'revert-on-close'`); override it when a test needs two distinguishable
-    * clients on one server.
-    */
-   clientId?: string;
 }
 
 /** A {@link DataPort} that records what passed through it. */
@@ -73,10 +74,11 @@ export interface FakeDataPort extends DataPort {
    /**
     * Every {@link DataPort.reportError} call, in order. Read from outside: this
     * is the only place a transport failure surfaces, so a test for the failure
-    * path asserts on the `context` string here rather than on a rejection that
-    * the consumer may legitimately swallow.
+    * path asserts here rather than on a rejection the consumer may legitimately
+    * swallow. Prefer asserting on `message.code`, which is stable, over
+    * `message.text`, which is the English default and may be reworded.
     */
-   readonly reported: readonly { readonly error: unknown; readonly context: string }[];
+   readonly reported: readonly { readonly error: unknown; readonly message: ResolvedMessage }[];
    /**
     * Fire {@link DataPort.onDispose} — the host tearing the transport down, a
     * language-server restart being the case that forces the event to exist.
@@ -96,10 +98,9 @@ export interface FakeDataPort extends DataPort {
  */
 export function makeFakeDataPort(options: FakeDataPortOptions): FakeDataPort {
    const connections: MessageConnection[] = [];
-   const reported: { error: unknown; context: string }[] = [];
+   const reported: { error: unknown; message: ResolvedMessage }[] = [];
    const disposeEmitter = new Emitter<void>();
    return {
-      clientId: options.clientId ?? 'fake-data-port',
       connections,
       reported,
       onDispose: disposeEmitter.event,
@@ -108,8 +109,8 @@ export function makeFakeDataPort(options: FakeDataPortOptions): FakeDataPort {
          connections.push(connection);
          return connection;
       },
-      reportError(error: unknown, context: string): void {
-         reported.push({ error, context });
+      reportError(error: unknown, message: ResolvedMessage): void {
+         reported.push({ error, message });
       },
       fireDispose(): void {
          disposeEmitter.fire(undefined);
@@ -132,6 +133,12 @@ export interface CapturingDataClient<
    readonly updates: TransferDocumentUpdatedEvent<TTransfer, TDiagnostic>[];
    /** Every `onDocumentSaved` event, in arrival order. */
    readonly saves: TransferDocumentSavedEvent<TTransfer, TDiagnostic>[];
+   /** Every `onDocumentDirtyChanged` event, in arrival order. */
+   readonly dirtyChanges: TransferDocumentDirtyChangedEvent[];
+   /** Every `onDocumentDeleted` event, in arrival order. */
+   readonly deletions: TransferDocumentDeletedEvent[];
+   /** Every `onDocumentsBuilt` event, in arrival order. */
+   readonly builds: TransferDocumentsBuiltEvent[];
    /** Every `onProjectsChanged` event, in arrival order. */
    readonly projectsChanges: ProjectsChangedEvent<TProject>[];
 }
@@ -139,7 +146,7 @@ export interface CapturingDataClient<
 /**
  * A {@link DataClientProtocol} that records every notification it receives.
  *
- * Recording ALL THREE channels even when a suite reads one is deliberate: an
+ * Recording EVERY channel even when a suite reads one is deliberate: an
  * event delivered on the wrong channel is a real defect of the data head, and a
  * double that drops the other two turns it into silence on the one being
  * watched.
@@ -156,6 +163,9 @@ export function makeCapturingDataClient<
 >(overrides: Partial<DataClientProtocol<TTransfer, TDiagnostic, TProject>> = {}): CapturingDataClient<TTransfer, TDiagnostic, TProject> {
    const updates: TransferDocumentUpdatedEvent<TTransfer, TDiagnostic>[] = [];
    const saves: TransferDocumentSavedEvent<TTransfer, TDiagnostic>[] = [];
+   const dirtyChanges: TransferDocumentDirtyChangedEvent[] = [];
+   const deletions: TransferDocumentDeletedEvent[] = [];
+   const builds: TransferDocumentsBuiltEvent[] = [];
    const projectsChanges: ProjectsChangedEvent<TProject>[] = [];
    const client: DataClientProtocol<TTransfer, TDiagnostic, TProject> = {
       onDocumentUpdated:
@@ -168,11 +178,26 @@ export function makeCapturingDataClient<
          (event => {
             saves.push(event);
          }),
+      onDocumentDirtyChanged:
+         overrides.onDocumentDirtyChanged ??
+         (event => {
+            dirtyChanges.push(event);
+         }),
+      onDocumentDeleted:
+         overrides.onDocumentDeleted ??
+         (event => {
+            deletions.push(event);
+         }),
+      onDocumentsBuilt:
+         overrides.onDocumentsBuilt ??
+         (event => {
+            builds.push(event);
+         }),
       onProjectsChanged:
          overrides.onProjectsChanged ??
          (event => {
             projectsChanges.push(event);
          })
    };
-   return { client, updates, saves, projectsChanges };
+   return { client, updates, saves, dirtyChanges, deletions, builds, projectsChanges };
 }

package/src/testing/fake-clock.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { type Clock, type Stopwatch, type Timed } from '../clock';
+import { type Clock, type Stopwatch, SystemClock } from '../clock';
 import { Disposable } from '../util';
 
 /** A {@link Clock} whose time only moves when the test calls {@link FakeClock.advance}. */
@@ -17,9 +17,13 @@ export interface FakeClock extends Clock {
     * whose deadline falls within the window — in chronological order, each at
     * its own deadline (so `now()` inside a callback reads the fire instant, not
     * the advance target). Timers scheduled by a callback fire too if they fall
-    * within the same window.
+    * within the same window. A {@link Clock.raceTimer} over a promise that
+    * settles through a chain still pending loses to the timer, so let that
+    * chain settle before advancing.
     */
    advance(ms: number): void;
+   /** How many {@link Clock.setTimer} timers have neither fired nor been disposed. */
+   pendingTimers(): number;
 }
 
 interface FakeTimer {
@@ -39,68 +43,79 @@ interface FakeTimer {
  *
  * Server-free and DI-free — lives in `@hydranium/protocol/testing` so every
  * head can bind it without pulling in a server package.
+ *
+ * The clock is a `SystemClock` with its time replaced, so its methods live on
+ * its prototype and a spread of it carries none of them. Replace one by
+ * assigning it onto the clock, or layer over the clock with `Object.create`.
  */
 export function makeFakeClock(options: { now?: number } = {}): FakeClock {
-   let current = options.now ?? 0;
-   const timers: FakeTimer[] = [];
+   return new VirtualClock(options.now ?? 0);
+}
+
+/**
+ * A `SystemClock` whose time, stopwatches and timers read one virtual axis, so
+ * the `measure` and `raceTimer` it inherits run on that axis too.
+ */
+class VirtualClock extends SystemClock implements FakeClock {
+   protected readonly timers: FakeTimer[] = [];
 
-   const makeStopwatch = (): Stopwatch => {
-      const start = current;
-      let lastLap = current;
+   constructor(protected current: number) {
+      super();
+   }
+
+   override now(): number {
+      return this.current;
+   }
+
+   override setTimer(callback: () => void, ms: number): Disposable {
+      const timer: FakeTimer = { at: this.current + ms, callback, disposed: false, fired: false };
+      this.timers.push(timer);
+      return Disposable.create(() => {
+         timer.disposed = true;
+      });
+   }
+
+   override stopwatch(): Stopwatch {
+      const read = (): number => this.current;
+      const start = read();
+      let lastLap = start;
       let stopped: number | undefined;
       return {
          get elapsedMs(): number {
-            return (stopped ?? current) - start;
+            return (stopped ?? read()) - start;
          },
          lap(): number {
-            const at = stopped ?? current;
+            const at = stopped ?? read();
             const split = at - lastLap;
             lastLap = at;
             return split;
          },
          stop(): number {
-            if (stopped === undefined) {
-               stopped = current;
-            }
+            stopped ??= read();
             return stopped - start;
          }
       };
-   };
+   }
 
-   return {
-      now: () => current,
-      setTimer(callback: () => void, ms: number): Disposable {
-         const timer: FakeTimer = { at: current + ms, callback, disposed: false, fired: false };
-         timers.push(timer);
-         return Disposable.create(() => {
-            timer.disposed = true;
-         });
-      },
-      stopwatch: makeStopwatch,
-      measure: (<T>(callback: () => T | Promise<T>): Timed<T> | Promise<Timed<T>> => {
-         const stopwatch = makeStopwatch();
-         const result = callback();
-         if (result instanceof Promise) {
-            return (result as Promise<T>).then(value => ({ result: value, elapsedMs: stopwatch.elapsedMs }));
-         }
-         return { result: result as T, elapsedMs: stopwatch.elapsedMs };
-      }) as Clock['measure'],
-      advance(ms: number): void {
-         const target = current + ms;
-         // Fire due timers one at a time, re-scanning after each so a callback
-         // that schedules a nearer timer still fires within this window.
-         for (;;) {
-            const next = timers
-               .filter(timer => !timer.disposed && !timer.fired && timer.at <= target)
-               .sort((left, right) => left.at - right.at)[0];
-            if (!next) {
-               break;
-            }
-            current = next.at;
-            next.fired = true;
-            next.callback();
+   pendingTimers(): number {
+      return this.timers.filter(timer => !timer.disposed && !timer.fired).length;
+   }
+
+   advance(ms: number): void {
+      const target = this.current + ms;
+      // Fire due timers one at a time, re-scanning after each so a callback
+      // that schedules a nearer timer still fires within this window.
+      for (;;) {
+         const next = this.timers
+            .filter(timer => !timer.disposed && !timer.fired && timer.at <= target)
+            .sort((left, right) => left.at - right.at)[0];
+         if (!next) {
+            break;
          }
-         current = target;
+         this.current = next.at;
+         next.fired = true;
+         next.callback();
       }
-   };
+      this.current = target;
+   }
 }

package/src/testing/index.ts

@@ -10,7 +10,9 @@
 // Subpath barrel for `@hydranium/protocol/testing` — the BROWSER-NEUTRAL shared
 // primitives: `makeFakeClock` (deterministic `Clock` double on one virtual time
 // axis), `waitFor` / `tick`, the client-side data-head doubles
-// (`makeFakeDataPort` / `makeCapturingDataClient`), and the `Harness` marker
+// (`makeFakeDataPort` / `makeCapturingDataClient`), the translation-catalogue
+// audit (`flattenCatalogue` / `findUndeclaredCodes` / `findSharedCodes`), and
+// the `Harness` marker
 // interface every framework harness extends. Kept out of the main barrel so production bundles don't pull
 // the test scaffolding in by default; adopters opt in by importing from
 // `@hydranium/protocol/testing`.
@@ -20,6 +22,7 @@
 // type, so they cannot be made portable and live at `./testing/node` instead.
 // The same rule the package surface uses — the portable name is the short one.
 
+export * from './catalogue-audit';
 export * from './data-doubles';
 export * from './fake-clock';
 export * from './harness';

package/src/testing/node/index.ts

@@ -8,8 +8,7 @@
  ********************************************************************************/
 
 // Subpath barrel for `@hydranium/protocol/testing/node` — the test transports
-// that need a Node runtime: a crossed `PassThrough` pair and the in-process
-// `MessageConnection` bridge over it.
+// that need a Node runtime.
 //
 // Separate from `./testing` because a `PassThrough` is in `DuplexStreamPair`'s
 // exported type and `StreamMessageReader` comes from `vscode-jsonrpc/node`, so
@@ -20,3 +19,4 @@
 
 export * from './duplex-connection';
 export * from './duplex-stream';
+export * from './message-port-pair';

package/src/testing/node/message-port-pair.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * Copyright (c) 2026 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 { MessageChannel } from 'node:worker_threads';
+import type { TransferredMessagePort } from '../../client/post-message-transport';
+
+/**
+ * The two ends of a `worker_threads` `MessageChannel`, typed as the transferred
+ * browser ports `createMessagePortTransport` takes. Node's port clones and keeps
+ * order as a browser's does, which is what lets a headless test stand in for a
+ * worker.
+ *
+ * `dispose` closes both ports. Node reports that as a close and a browser port
+ * reports nothing, so a test that asserts on a close does so before teardown.
+ */
+export interface MessagePortPair {
+   readonly port1: TransferredMessagePort;
+   readonly port2: TransferredMessagePort;
+   dispose(): void;
+}
+
+export function makeMessagePortPair(): MessagePortPair {
+   const channel = new MessageChannel();
+   return {
+      // Node's port satisfies the structural type at runtime; the cast records
+      // one platform's port standing in for the other's.
+      port1: channel.port1 as unknown as TransferredMessagePort,
+      port2: channel.port2 as unknown as TransferredMessagePort,
+      dispose(): void {
+         channel.port1.close();
+         channel.port2.close();
+      }
+   };
+}

package/src/transfer-diagnostic.ts

@@ -7,6 +7,8 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
+import { type MessageParams, type ResolvedMessage } from './messages/primitives';
+
 /**
  * Generic, transport-friendly diagnostic shape used by the model-server protocol.
  *
@@ -56,6 +58,21 @@ export interface TransferDiagnostic {
     * is not usable as a rule identity on its own.
     */
    code?: number | string;
+   /**
+    * Substitutions for the placeholders in the message this {@link code} names,
+    * present only for a diagnostic raised from a framework message declaration.
+    *
+    * Without them a translated template renders with its `{name}` tokens left
+    * standing, because substitution leaves an unmatched token in place rather
+    * than raising — so a surface that translates from {@link code} alone is
+    * correct for a parameterless sentence and visibly wrong for a parameterised
+    * one. This is the field that makes the second case work; the LSP carrier has
+    * always moved the params, and no carrier below it did.
+    *
+    * Prefer {@link TransferDiagnostic.resolved} over reading this: it decides
+    * whether an identity is present at all, which a lone `params` cannot.
+    */
+   params?: MessageParams;
 }
 
 export namespace TransferDiagnostic {
@@ -74,6 +91,29 @@ export namespace TransferDiagnostic {
       return diagnostic.type === 'parsing-error';
    }
 
+   /**
+    * The diagnostic as a renderable message, for a surface that translates.
+    * `undefined` when it carries no framework identity — a syntactic error, an
+    * adopter's own check, a linker failure — which is the case a caller must
+    * distinguish rather than render.
+    *
+    * Hand the result to `renderFrameworkMessage` with whatever catalogue the
+    * host has loaded. The `text` is the server's English, so a code the
+    * catalogue does not carry still yields a complete sentence.
+    *
+    * `code` alone does not establish an identity: it also holds Langium's
+    * internal code and an adopter's own, and either would be looked up against a
+    * catalogue that cannot have it. Requiring `params` is what discriminates,
+    * and it is why a parameterless framework message still populates the field
+    * with an empty object rather than omitting it.
+    */
+   export function resolved(diagnostic: TransferDiagnostic): ResolvedMessage | undefined {
+      if (typeof diagnostic.code !== 'string' || diagnostic.params === undefined) {
+         return undefined;
+      }
+      return { code: diagnostic.code, params: diagnostic.params, text: diagnostic.message };
+   }
+
    export function getPath(diagnostic: TransferDiagnostic): string {
       return diagnostic.property ? `${diagnostic.element}${ELEMENT_PROPERTY_SEPARATOR}${diagnostic.property}` : diagnostic.element;
    }

package/src/transfer-document.ts

@@ -9,6 +9,7 @@
 
 import type { TransferDiagnostic } from './transfer-diagnostic';
 import type { TransferElement } from './transfer-element';
+import { asSnapshotVersion, type SnapshotVersion } from './model-service/based-on';
 
 /**
  * Wire envelope exchanged between the model-server's data-server head and
@@ -27,14 +28,13 @@ export interface TransferDocument<TTransfer extends TransferElement, TDiagnostic
    uri: string;
    /**
     * The document version this snapshot was taken at — sourced from the
-    * server's text-document version counter. Callers that mutate the
-    * document subsequently pass this value back as `TransferUpdateArgs.baseVersion`
-    * (or `TransferSaveArgs.baseVersion`) so the server can detect stale-based
-    * updates and reject them with `ConflictError`.
+    * server's text-document version counter. A caller that mutates the document
+    * subsequently sends this straight back as `TransferUpdateDocumentArgs.basedOn`, and
+    * the server rejects a stale-based update with `ConflictError`.
     *
     * See `@hydranium/protocol#errors` for the conflict-detection contract.
     */
-   version: number;
+   version: SnapshotVersion;
    /**
     * Absent when the document does not exist — the server answers an unknown URI
     * with a shaped envelope rather than an error, so absence is an ordinary
@@ -43,6 +43,14 @@ export interface TransferDocument<TTransfer extends TransferElement, TDiagnostic
     */
    root?: TTransfer;
    diagnostics: TDiagnostic[];
+   /**
+    * Whether the server holds text for this document that its file does not,
+    * as the server last knew the file: set on every document a data server
+    * answers or sends that the server holds, and absent otherwise. A change
+    * after this snapshot arrives as `onDocumentDirtyChanged` to a client
+    * watching the document.
+    */
+   dirty?: boolean;
 }
 
 /**
@@ -82,6 +90,21 @@ export namespace TransferDocument {
       return document;
    }
 
+   /**
+    * The envelope for a document the server does not have — `root` absent, and
+    * the version a read of a URI the store never saw reports.
+    *
+    * Exists so the absent branch is built the same way the present one is: both
+    * doors mark the version as coming from a read, and neither asks a caller to
+    * do it.
+    */
+   export function absent<TTransfer extends TransferElement, TDiagnostic = TransferDiagnostic>(
+      uri: string,
+      diagnostics: TDiagnostic[] = []
+   ): TransferDocument<TTransfer, TDiagnostic> {
+      return { uri, version: asSnapshotVersion(0), root: undefined, diagnostics };
+   }
+
    /**
     * Construct a {@link TransferDocument} envelope. `diagnostics` defaults
     * to `[]` so test fixtures, fake protocol implementations, and the
@@ -94,6 +117,6 @@ export namespace TransferDocument {
       root: TTransfer,
       diagnostics: TDiagnostic[] = []
    ): TransferDocument<TTransfer, TDiagnostic> {
-      return { uri, version, root, diagnostics };
+      return { uri, version: asSnapshotVersion(version), root, diagnostics };
    }
 }

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

@@ -1,64 +0,0 @@
-/********************************************************************************
- * 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

@@ -1 +0,0 @@
-{"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"}