@hydranium/glsp-server 1.0.0-next.31 → 1.0.0-next.315

package/src/storage/index.ts

@@ -7,5 +7,6 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
+export * from './hydranium-glsp-request-save-model-action-handler.js';
 export * from './hydranium-glsp-storage.js';
-export * from './save-conflict-policy.js';
+export * from './save-delivery-policy.js';

package/src/storage/save-delivery-policy.ts

@@ -0,0 +1,49 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+/**
+ * How `HydraniumGlspStorage.saveSourceModel` delivers its result: whether the
+ * GLSP save action awaits the write, and what happens on failure.
+ *
+ * The two are not independent — fire-and-forget plus rethrow would leave an
+ * unhandled rejection — so each arm bundles them into one coherent, nameable
+ * policy an adopter selects whole. It is a *selection of configuration*,
+ * delivered as a bound option (see the {@link SaveDeliveryPolicy} symbol) rather
+ * than a behaviour hook.
+ *
+ * **Neither arm guards on a base version.** A save flushes the store's
+ * settled text rather than authoring from the diagram's captured model, and the
+ * store already holds every other client's change — so a guard here refuses a
+ * write whose content is already correct. The gate that does exist sits on the
+ * update path, per operation, where the diagram authors.
+ */
+export type SaveDeliveryPolicy =
+   /**
+    * Await the write and the language client's settle, and propagate any
+    * failure to the GLSP save action. The default. A language client that
+    * does not answer holds the first such save, and the diagram's queued
+    * actions, for the settle bound; saves after it do not wait for it again.
+    */
+   | { kind: 'await' }
+   /**
+    * Fire-and-forget, logging and swallowing every failure. Correct when a
+    * failed diagram save must neither block the action nor surface as an error.
+    */
+   | { kind: 'fire-and-forget' };
+
+/** The policy applied when no {@link SaveDeliveryPolicy} option is bound. */
+export const DEFAULT_SAVE_DELIVERY_POLICY: SaveDeliveryPolicy = { kind: 'await' };
+
+/**
+ * DI token for the {@link SaveDeliveryPolicy} option. Bind a constant value in a
+ * `DiagramModule` to select a non-default policy; left unbound,
+ * `HydraniumGlspStorage` falls back to {@link DEFAULT_SAVE_DELIVERY_POLICY}.
+ * Shares its name with the type, the way a `class` is both a value and a type.
+ */
+export const SaveDeliveryPolicy = Symbol('SaveDeliveryPolicy');

package/src/submission/hydranium-glsp-submission-handler.ts

@@ -12,15 +12,20 @@ import {
    type DirtyStateChangeReason,
    type GModelRootSchema,
    type LayoutOperation,
+   MarkersReason,
    ModelState,
    ModelSubmissionHandler,
+   type ModelValidator,
    SetDirtyStateAction,
+   SetMarkersAction,
    type SetModelAction
 } from '@eclipse-glsp/server';
 import { IntegrityService } from '@hydranium/core';
 import { inject, injectable } from 'inversify';
 import { type AstNode, type DocumentState } from '@hydranium/langium';
+import { describeErrorWithStack } from '@hydranium/protocol';
 import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
+import { DiagramStatus } from '../state/diagram-status.js';
 
 /**
  * GLSP {@link ModelSubmissionHandler} base shared by all hydranium adopters.
@@ -79,6 +84,8 @@ export class HydraniumGlspSubmissionHandler<TRoot extends AstNode, TSourceModel
    }
 
    override async submitModel(reason?: DirtyStateChangeReason, layout?: LayoutOperation): Promise<Action[]> {
+      // Numbered before the first await, so a caller can predict it.
+      const submission = ++this._startedSubmissions;
       if (this.readyEvent !== undefined) {
          // Adopters with on-build integrity rules wait so the GModel-factory walk sees
          // a settled AST; otherwise the GModel could include elements the build pass is
@@ -86,8 +93,15 @@ export class HydraniumGlspSubmissionHandler<TRoot extends AstNode, TSourceModel
          // via onReadyRefreshed.
          await this.modelState.ready(this.readyEvent);
       }
-      const actions = await super.submitModel(reason, layout);
+      const submitted = super.submitModel(reason, layout);
+      // Read before awaiting: GLSP bumps the revision synchronously, and another
+      // submission may run once this one yields.
+      const revision = this.modelState.root?.revision;
+      const actions = await submitted;
+      this.previousSubmission = { signature: this._lastSubmittedSignature, revision: this.lastSubmittedRevision };
       this._lastSubmittedSignature = this.signatureOf(actions);
+      this.lastSubmittedRevision = revision;
+      this.lastCompletedSubmission = submission;
       this.logSubmit(reason, actions);
       return actions;
    }
@@ -107,6 +121,78 @@ export class HydraniumGlspSubmissionHandler<TRoot extends AstNode, TSourceModel
 
    protected _lastSubmittedSignature?: string;
 
+   /** GModel revision of the last submission, whatever its reason. */
+   protected lastSubmittedRevision?: number;
+
+   /**
+    * How many submissions have started, whatever their reason. A caller that
+    * may drop the submission it is about to start names it to
+    * {@link withdrawLastSubmission} as this count plus one.
+    */
+   get startedSubmissions(): number {
+      return this._startedSubmissions;
+   }
+
+   protected _startedSubmissions = 0;
+
+   /** The number of the submission that completed last. */
+   protected lastCompletedSubmission?: number;
+
+   /** What {@link withdrawLastSubmission} restores. */
+   protected previousSubmission?: { readonly signature?: string; readonly revision?: number };
+
+   /**
+    * Take back the latest submission, which the caller drops unsent because it
+    * matches the one before. `submission` is its number, the
+    * {@link startedSubmissions} count when it started. GLSP bumped the GModel
+    * revision for it; left bumped, the client's measured bounds for the graph
+    * it already has arrive stale and its update is never sent. A no-op once
+    * another submission has finished or rebuilt the root since, which the
+    * client is given instead.
+    *
+    * An override of {@link submitModel} may return its own array. If it awaits
+    * before calling `super.submitModel`, another submission can take the number
+    * first, and the withdraw is then a no-op.
+    */
+   withdrawLastSubmission(submission: number): void {
+      const previous = this.previousSubmission;
+      if (!previous || submission !== this.lastCompletedSubmission || this.modelState.root?.revision !== this.lastSubmittedRevision) {
+         return;
+      }
+      this.previousSubmission = undefined;
+      this._lastSubmittedSignature = previous.signature;
+      this.lastSubmittedRevision = previous.revision;
+      const root = this.modelState.root;
+      if (root && previous.revision !== undefined) {
+         root.revision = previous.revision;
+      }
+   }
+
+   /**
+    * Live validation as the {@link DiagramStatus.VALIDATION} status, rather than
+    * GLSP's own status writes, whose closing clear erases any status still in
+    * force, such as the reason a diagram is read-only.
+    *
+    * Never rejects: GLSP runs it from a debounce that drops the result, so a
+    * failure here would go unhandled. A validator that throws is logged as an
+    * error, markers that cannot be sent as a warning.
+    */
+   protected override async performLiveValidation(validator: ModelValidator): Promise<void> {
+      this.modelState.setStatus(DiagramStatus.VALIDATION, { message: 'Validate Model...', severity: 'INFO' });
+      try {
+         const markers = await validator.validate([this.modelState.root], MarkersReason.LIVE);
+         await this.actionDispatcher
+            .dispatch(SetMarkersAction.create(markers, { reason: MarkersReason.LIVE }))
+            .catch((error: unknown) =>
+               this.modelState.logger.warn(`Could not send the live-validation markers: ${describeErrorWithStack(error)}`)
+            );
+      } catch (error: unknown) {
+         this.modelState.logger.error(`Live validation failed: ${describeErrorWithStack(error)}`);
+      } finally {
+         this.modelState.setStatus(DiagramStatus.VALIDATION, undefined);
+      }
+   }
+
    /**
     * Serialise the model-bearing actions of a submission into a comparable
     * signature.
@@ -134,9 +220,9 @@ export class HydraniumGlspSubmissionHandler<TRoot extends AstNode, TSourceModel
    }
 
    /**
-    * Logs the {@link SetModelAction} dispatch so the initial
-    * `requestModel → setModel` handshake is observable in the server log
-    * alongside `Submit model` and `ComputedBounds accepted`.
+    * Logs the {@link SetModelAction} dispatch, so a diagram's initial
+    * `requestModel → setModel` handshake is a milestone in the server log; the
+    * submit and computed-bounds lines around it are diagnosis.
     */
    protected override createSetModeAction(newRoot: GModelRootSchema): SetModelAction {
       const action = super.createSetModeAction(newRoot);
@@ -151,7 +237,7 @@ export class HydraniumGlspSubmissionHandler<TRoot extends AstNode, TSourceModel
       const gChildren = root?.children?.length ?? 0;
       const sourceRoot = this.modelState.sourceRoot;
       const kinds = actions.map(a => a.kind).join(',');
-      this.modelState.logger.info(
+      this.modelState.logger.debug(
          `Submit model [reason=${reason ?? 'initial'}, actions=[${kinds}], ` +
             `gmodel={type=${root?.type ?? 'none'}, children=${gChildren}}, ` +
             `ast={${this.formatSourceRoot(sourceRoot)}}]`

package/src/testing/glsp-harness.ts

@@ -10,16 +10,20 @@
 import 'reflect-metadata';
 import {
    type Action,
+   ActionDispatchScope,
    type ActionMessage,
    ClientSessionManager,
    EndProgressAction,
    GLSPClientProxy,
    GLSPServer,
+   MessageAction,
    ModelState,
+   RejectAction,
    RequestBoundsAction,
    RequestModelAction,
    SOURCE_URI_ARG,
    SetDirtyStateAction,
+   SetMarkersAction,
    SetModelAction,
    StartProgressAction,
    StatusAction,
@@ -35,7 +39,6 @@ import {
    type ServerModule,
    getRequestParentName
 } from '@eclipse-glsp/server/node.js';
-import { ActionDispatchScope } from '@eclipse-glsp/server';
 import { Container, ContainerModule, type interfaces } from 'inversify';
 import type { AstNode } from '@hydranium/langium';
 import type { ServerSharedServices } from '@hydranium/core';
@@ -87,33 +90,49 @@ export interface MakeGlspHarnessOptions {
    readonly clientSessionId?: string;
    /**
     * Adopter-specific client action kinds to forward IN ADDITION to
-    * {@link DEFAULT_CLIENT_ACTION_KINDS}. The server's
+    * {@link MINIMAL_CLIENT_ACTION_KINDS}. The server's
     * `ClientActionForwarder` only forwards declared kinds to the capturing
     * `GLSPClientProxy`, so list any custom server→client action a test needs
-    * to observe. The standard set covers ordinary round-trips, so most tests
+    * to observe. The minimal set covers ordinary round-trips, so most tests
     * leave this unset.
     */
    readonly additionalClientActionKinds?: ReadonlyArray<string>;
 }
 
 /**
- * The standard client-bound action kinds a real GLSP client handles — the
- * minimal set needed for any model round-trip. The harness declares these on
- * the session by default so the capturing {@link GLSPClientProxy} receives
- * them and the action dispatcher never errors with "no handler registered"
- * for an ordinary server→client action. Adopter-specific kinds are added via
+ * The fewest client-bound action kinds a session can declare and still finish
+ * a model round-trip without the server's dispatcher erroring with "no handler
+ * registered" for an ordinary server→client action.
+ *
+ * A real GLSP client declares every kind its own handler registry holds, which
+ * is far more than this, and GLSP ships no fixed list to declare instead. So a
+ * test session that leaves one of these out sees errors no deployed client
+ * would, or none at all: a dispatch the server does not await, such as the
+ * markers after a load, fails without telling the client. The harness declares
+ * them by default; adopter-specific kinds are added via
  * {@link MakeGlspHarnessOptions.additionalClientActionKinds}.
  */
-const DEFAULT_CLIENT_ACTION_KINDS: ReadonlyArray<string> = [
+export const MINIMAL_CLIENT_ACTION_KINDS: ReadonlyArray<string> = Object.freeze([
    SetModelAction.KIND,
    UpdateModelAction.KIND,
    RequestBoundsAction.KIND,
    SetDirtyStateAction.KIND,
    StatusAction.KIND,
+   MessageAction.KIND,
+   SetMarkersAction.KIND,
    StartProgressAction.KIND,
    UpdateProgressAction.KIND,
    EndProgressAction.KIND
-];
+]);
+
+/**
+ * Whether the server reported a failure to the client: a rejected request, or
+ * an ERROR or FATAL message. A server can fail a request and still send the
+ * model, so a test that sees the model has not yet seen the load succeed.
+ */
+export function isRejectionOrError(action: Action): boolean {
+   return RejectAction.is(action) || (MessageAction.is(action) && (action.severity === 'ERROR' || action.severity === 'FATAL'));
+}
 
 /** Options for {@link GlspHarness.nextModelSubmission}. */
 export interface NextModelSubmissionOptions {
@@ -156,10 +175,11 @@ export interface GlspHarness<TState extends AbstractHydraniumGlspState<AstNode,
    /** Send an action to the server as `{ clientId, action }`. Fire-and-forget (GLSP `process` is `void`). */
    dispatch(action: Action): void;
    /**
-    * Resolve with the next captured action whose `kind` matches — an
-    * already-captured-but-unconsumed match resolves immediately, otherwise
-    * waits for the next arrival. Rejects after `timeoutMs` (default 2000) so
-    * a missing action fails fast instead of hanging.
+    * Resolve with the next action whose `kind` matches and that arrived after
+    * the last {@link dispatch}, or since {@link start} before any. One already
+    * captured and unconsumed resolves immediately, otherwise the next arrival
+    * wins. An earlier action is read from {@link actions}. Rejects after
+    * `timeoutMs` (default 2000) so a missing action fails fast.
     */
    nextAction<T extends Action = Action>(kind: string, timeoutMs?: number): Promise<T>;
    /**
@@ -179,7 +199,8 @@ export interface GlspHarness<TState extends AbstractHydraniumGlspState<AstNode,
    openDocument(sourceUri: string, timeoutMs?: number): Promise<Action>;
    /**
     * Resolve with the next action that publishes a model — the settling point
-    * after an operation, since a successful operation re-submits.
+    * after an operation, since a successful operation re-submits. Matches as
+    * {@link nextAction} does, only after the last dispatch.
     *
     * Kind-agnostic for the same reason as {@link openDocument}. Set
     * `rejectOnTimeout: false` to ask whether a submission happened *at all*.
@@ -189,6 +210,11 @@ export interface GlspHarness<TState extends AbstractHydraniumGlspState<AstNode,
     * LIGHT fidelity: seed the state's source root directly via
     * `setSourceRoot`, bypassing source-model storage. Valid only after
     * {@link start}.
+    *
+    * A test of a provider that reads `builtNodeOf` or `referenceTo` outside
+    * an operation seeds the real state here rather than stub them. They answer as in production
+    * for a root with a `$document` in a project; without one, `referenceTo`
+    * names a target as in no project, unchecked for visibility.
     */
    seedSourceRoot(uri: string, root: Parameters<TState['setSourceRoot']>[1]): void;
 
@@ -235,11 +261,13 @@ export function makeGlspHarness<TState extends AbstractHydraniumGlspState<AstNod
 ): GlspHarness<TState> {
    const applicationId = options.applicationId ?? 'test-app';
    const clientSessionId = options.clientSessionId ?? 'test-session';
-   const clientActionKinds = [...DEFAULT_CLIENT_ACTION_KINDS, ...(options.additionalClientActionKinds ?? [])];
+   const clientActionKinds = [...MINIMAL_CLIENT_ACTION_KINDS, ...(options.additionalClientActionKinds ?? [])];
    const createLogger = options.createLogger ?? (() => makeNoopGlspLogger());
 
    const actions: Action[] = [];
    const consumed = new WeakSet<Action>();
+   // Where the last dispatch fell in `actions`; a wait matches only from here.
+   let dispatchedAt = 0;
    const waiters: PendingWaiter[] = [];
 
    const captureProxy: GLSPClientProxy = {
@@ -257,8 +285,9 @@ export function makeGlspHarness<TState extends AbstractHydraniumGlspState<AstNod
    };
 
    /**
-    * Resolve with the first unconsumed action matching any of `kinds` — one
-    * already captured resolves immediately, otherwise the next arrival wins.
+    * Resolve with the first unconsumed action matching any of `kinds` since the
+    * last dispatch — one already captured resolves immediately, otherwise the
+    * next arrival wins.
     *
     * `rejectOnTimeout` is what lets a caller distinguish the two questions a
     * test asks. `true` (the default) is "this must happen", and a timeout is a
@@ -268,7 +297,7 @@ export function makeGlspHarness<TState extends AbstractHydraniumGlspState<AstNod
     * `ActionDispatcher.requestUntil(action, timeoutMs, rejectOnTimeout)`.
     */
    function waitFor(kinds: ReadonlyArray<string>, timeoutMs: number, rejectOnTimeout: boolean): Promise<Action | undefined> {
-      const existing = actions.find(action => kinds.includes(action.kind) && !consumed.has(action));
+      const existing = actions.find((action, index) => index >= dispatchedAt && kinds.includes(action.kind) && !consumed.has(action));
       if (existing) {
          consumed.add(existing);
          return Promise.resolve(existing);
@@ -290,8 +319,19 @@ export function makeGlspHarness<TState extends AbstractHydraniumGlspState<AstNod
                   // Distinguishing "nothing happened" from "something else
                   // happened" is the difference between a five-minute hunt and a
                   // one-line diagnosis.
-                  const seen = actions.map(captured => captured.kind);
-                  const context = seen.length === 0 ? 'no actions were captured at all' : `captured since start: ${seen.join(', ')}`;
+                  // Split at the last dispatch, since a wait matches only what
+                  // came after it: an earlier match is no answer to this one.
+                  const kindsIn = (from: number, to?: number): string =>
+                     actions
+                        .slice(from, to)
+                        .map(captured => captured.kind)
+                        .join(', ') || 'nothing';
+                  const context =
+                     actions.length === 0
+                        ? 'no actions were captured at all'
+                        : dispatchedAt === 0
+                          ? `captured since start: ${kindsIn(0)}`
+                          : `captured before the last dispatch, which a wait does not match: ${kindsIn(0, dispatchedAt)}; since: ${kindsIn(dispatchedAt)}`;
                   reject(
                      new Error(
                         `makeGlspHarness: no ${kinds.map(kind => `'${kind}'`).join(' / ')} action within ${timeoutMs}ms — ${context}`
@@ -328,10 +368,10 @@ export function makeGlspHarness<TState extends AbstractHydraniumGlspState<AstNod
    const container = new Container();
    container.load(defaultAppModule, ...(options.appModules ?? []), captureProxyModule);
    container.load(options.serverModule);
-   // After the serverModule, which binds `GLSPServer`: the override rebinds that
-   // symbol, so it needs the binding to exist. The launchers reach the same tier
-   // by passing this to `configure` — a harness that skipped it would answer
-   // request failures differently from every real bringup.
+   // Into the container the serverModule binds `GLSPServer` in, as the
+   // launchers' `configure` loads it: a harness that skipped it would keep
+   // upstream's server and answer request failures differently from every
+   // real bringup.
    container.load(createGlspServerOverrides());
    const server = container.get<GLSPServer>(GLSPServer);
 
@@ -378,6 +418,7 @@ export function makeGlspHarness<TState extends AbstractHydraniumGlspState<AstNod
       },
 
       dispatch(action: Action): void {
+         dispatchedAt = actions.length;
          server.process({ clientId: clientSessionId, action });
       },
 
@@ -389,6 +430,7 @@ export function makeGlspHarness<TState extends AbstractHydraniumGlspState<AstNod
          if (!state) {
             throw new Error('makeGlspHarness: openDocument() is only valid after start()');
          }
+         dispatchedAt = actions.length;
          server.process({
             clientId: clientSessionId,
             action: RequestModelAction.create({ options: { [SOURCE_URI_ARG]: sourceUri } })

package/src/validation/diagnostic-markers.ts

@@ -7,10 +7,10 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { type Marker, MarkerKind } from '@eclipse-glsp/protocol';
+import { type Marker, MarkerKind } from '@eclipse-glsp/server';
 import { type AstNode } from '@hydranium/langium';
 import { Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-types';
-import { type TransferLspDiagnostic } from '@hydranium/core';
+import { type AstDiagnostic } from '@hydranium/core';
 
 /**
  * The model-shaped lookups the diagnostic→marker translation needs, injected so
@@ -48,7 +48,7 @@ export interface DiagnosticMarkerLookups {
  * `MarkersReason` so a fresh `SetMarkersAction` replaces the previous markers
  * (an empty result clears them when all errors are fixed).
  */
-export function diagnosticsToMarkers(diagnostics: readonly TransferLspDiagnostic[], lookups: DiagnosticMarkerLookups): Marker[] {
+export function diagnosticsToMarkers(diagnostics: readonly AstDiagnostic[], lookups: DiagnosticMarkerLookups): Marker[] {
    const markers: Marker[] = [];
    for (const diagnostic of diagnostics) {
       const kind = markerKind(diagnostic.severity);

package/src/validation/hydranium-glsp-model-validator.ts

@@ -7,12 +7,11 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { type Marker } from '@eclipse-glsp/protocol';
-import { type GModelElement, ModelState, type ModelValidator } from '@eclipse-glsp/server';
+import { type GModelElement, type Marker, ModelState, type ModelValidator } from '@eclipse-glsp/server';
 import { inject, injectable } from 'inversify';
 import { type AstNode } from '@hydranium/langium';
 import { URI } from '@hydranium/langium';
-import { type ServerSharedServices, type TransferLspDiagnostic } from '@hydranium/core';
+import { type ServerSharedServices, type AstDiagnostic } from '@hydranium/core';
 import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
 import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
 import { type DiagnosticMarkerLookups, diagnosticsToMarkers } from './diagnostic-markers.js';
@@ -75,9 +74,9 @@ export class HydraniumGlspModelValidator<TRoot extends AstNode = AstNode> implem
             continue;
          }
          // Diagnostics are produced by the framework's `HydraniumDocumentValidator`,
-         // which emits `TransferLspDiagnostic` (LSP `Diagnostic` + `element` path).
+         // which emits `AstDiagnostic` (LSP `Diagnostic` + `element` path).
          // Parser/lexer diagnostics carry no `element`; the lookup drops them.
-         const diagnostics = document.diagnostics as TransferLspDiagnostic[] | undefined;
+         const diagnostics = document.diagnostics as AstDiagnostic[] | undefined;
          if (!diagnostics || diagnostics.length === 0) {
             continue;
          }

package/lib/storage/save-conflict-policy.d.ts

@@ -1,56 +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
- ********************************************************************************/
-/**
- * How `HydraniumGlspStorage.saveSourceModel` reacts when a concurrent edit has
- * advanced the document past the version this diagram was last captured at.
- *
- * A save spans otherwise-independent choices — whether to guard on the captured
- * based-on version, whether the GLSP save action awaits the persist, and what
- * happens on failure. Each arm bundles those into one coherent, nameable policy
- * so an adopter selects a whole behaviour rather than assembling an incoherent
- * mix: fire-and-forget plus rethrow would leave an unhandled rejection. It is a
- * *selection of configuration*, delivered as a bound option (see the
- * {@link SaveConflictPolicy} symbol) rather than a behaviour hook.
- */
-export type SaveConflictPolicy = 
-/**
- * Last-write-wins: no based-on guard, await the persist, propagate any
- * failure to the GLSP save action. The default; correct for a single-editor
- * head where nothing races the save.
- */
-{
-    kind: 'overwrite';
-}
-/**
- * Guard on the captured version, await the persist, and surface a
- * `ConflictError` (and any other failure) to the GLSP save action.
- */
- | {
-    kind: 'reject';
-}
-/**
- * Guard on the captured version, fire-and-forget, and log + swallow every
- * failure. Correct when another editor of the same document may already have
- * written the truth, so a stale diagram save is benign and must neither
- * block the action nor surface as an error.
- */
- | {
-    kind: 'drop-and-log';
-};
-/** The policy applied when no {@link SaveConflictPolicy} option is bound. */
-export declare const DEFAULT_SAVE_CONFLICT_POLICY: SaveConflictPolicy;
-/**
- * DI token for the {@link SaveConflictPolicy} option. Bind a constant value in a
- * `DiagramModule` to select a non-default policy; left unbound,
- * `HydraniumGlspStorage` falls back to
- * {@link DEFAULT_SAVE_CONFLICT_POLICY}. Shares its name with the type, the way a
- * `class` is both a value and a type.
- */
-export declare const SaveConflictPolicy: unique symbol;
-//# sourceMappingURL=save-conflict-policy.d.ts.map

package/lib/storage/save-conflict-policy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"save-conflict-policy.d.ts","sourceRoot":"","sources":["../../src/storage/save-conflict-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB;AAC3B;;;;GAIG;AACD;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE;AACvB;;;GAGG;GACD;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE;AACpB;;;;;GAKG;GACD;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC;AAE9B,6EAA6E;AAC7E,eAAO,MAAM,4BAA4B,EAAE,kBAA0C,CAAC;AAEtF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,eAA+B,CAAC"}

package/lib/storage/save-conflict-policy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"save-conflict-policy.js","sourceRoot":"","sources":["../../src/storage/save-conflict-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAkClF,6EAA6E;AAC7E,MAAM,CAAC,MAAM,4BAA4B,GAAuB,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;AAEtF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAC"}

package/src/storage/save-conflict-policy.ts

@@ -1,52 +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
- ********************************************************************************/
-
-/**
- * How `HydraniumGlspStorage.saveSourceModel` reacts when a concurrent edit has
- * advanced the document past the version this diagram was last captured at.
- *
- * A save spans otherwise-independent choices — whether to guard on the captured
- * based-on version, whether the GLSP save action awaits the persist, and what
- * happens on failure. Each arm bundles those into one coherent, nameable policy
- * so an adopter selects a whole behaviour rather than assembling an incoherent
- * mix: fire-and-forget plus rethrow would leave an unhandled rejection. It is a
- * *selection of configuration*, delivered as a bound option (see the
- * {@link SaveConflictPolicy} symbol) rather than a behaviour hook.
- */
-export type SaveConflictPolicy =
-   /**
-    * Last-write-wins: no based-on guard, await the persist, propagate any
-    * failure to the GLSP save action. The default; correct for a single-editor
-    * head where nothing races the save.
-    */
-   | { kind: 'overwrite' }
-   /**
-    * Guard on the captured version, await the persist, and surface a
-    * `ConflictError` (and any other failure) to the GLSP save action.
-    */
-   | { kind: 'reject' }
-   /**
-    * Guard on the captured version, fire-and-forget, and log + swallow every
-    * failure. Correct when another editor of the same document may already have
-    * written the truth, so a stale diagram save is benign and must neither
-    * block the action nor surface as an error.
-    */
-   | { kind: 'drop-and-log' };
-
-/** The policy applied when no {@link SaveConflictPolicy} option is bound. */
-export const DEFAULT_SAVE_CONFLICT_POLICY: SaveConflictPolicy = { kind: 'overwrite' };
-
-/**
- * DI token for the {@link SaveConflictPolicy} option. Bind a constant value in a
- * `DiagramModule` to select a non-default policy; left unbound,
- * `HydraniumGlspStorage` falls back to
- * {@link DEFAULT_SAVE_CONFLICT_POLICY}. Shares its name with the type, the way a
- * `class` is both a value and a type.
- */
-export const SaveConflictPolicy = Symbol('SaveConflictPolicy');