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

package/lib/command/hydranium-glsp-operation-command.js

@@ -0,0 +1,491 @@
+/********************************************************************************
+ * 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 { Command, CompoundCommand } from '@eclipse-glsp/server';
+import { AstUtils, isMultiReference } from '@hydranium/langium';
+import { describeErrorWithStack } from '@hydranium/protocol';
+import { DiagramEditDroppedError } from './diagram-edit-dropped-error.js';
+const internals = new WeakMap();
+/** The canonical URI of every working root an operation made, by root. */
+const workingRootUris = new WeakMap();
+/**
+ * The canonical URI of the document whose working copy `node` belongs to;
+ * `undefined` for a node of no copy. A copy has no `$document`, so a lookup
+ * that routes by a node's document routes a copy node through this instead.
+ */
+export function workingUriOfCopy(node) {
+    return workingRootUris.get(AstUtils.findRootNode(node));
+}
+const openOperations = new WeakMap();
+/** The operation open on `state`, executing, undoing or redoing its side effects; `undefined` between operations. */
+export function openOperationOf(state) {
+    return openOperations.get(state);
+}
+/** Run `operation` as {@link HydraniumGlspOperationCommand} describes. */
+export function runOperation(operation, create) {
+    return membersOf(operation).run(create);
+}
+function membersOf(operation) {
+    const members = internals.get(operation);
+    if (!members) {
+        throw new Error('Not a HydraniumGlspOperationCommand');
+    }
+    return members;
+}
+/**
+ * One GLSP operation as a transaction, and the command-stack entry that undoes
+ * and redoes it.
+ *
+ * {@link runOperation} executes the operation's command against copies of the
+ * built roots and writes their projection once; a reader of a built root never
+ * sees an edit its write has not committed, and an edit the write drops stays
+ * out of every built root. Call it inside `runExclusive`: the copies, the write
+ * and the capture that follows assume no other operation, undo or storage
+ * capture runs meanwhile.
+ *
+ * The entry holds one model transition, from the copies' projection before the
+ * command to their projection after it, both as the documents hold them after
+ * a write (see `normalizeTransition`), and the side effects that executed, in
+ * order: each command that does not record, a `CompoundCommand`'s children
+ * counted one by one, and the bridge of each recording command at any depth.
+ * Rollback and undo run them in reverse, redo in order. A recording command
+ * executed inside an open operation writes nothing, and its own undo and redo
+ * do nothing there.
+ */
+export class HydraniumGlspOperationCommand {
+    modelState;
+    /** Working copies by canonical URI. */
+    workingRoots = new Map();
+    /** Built node to copy and copy to built node, across every working root, as `AstUtils.copyAstNode` records it. */
+    trace = new Map();
+    /** The source root captured when the operation opened. */
+    sourceRootAtOpen;
+    /** The version of {@link sourceRootAtOpen}, which the write is gated on. */
+    baseVersionAtOpen;
+    /**
+     * The primary root to capture when the operation closes: the one its write
+     * produced, or the document's built one after a dropped write or one the
+     * document already held.
+     */
+    writtenRoot;
+    /** Whether the write's reconcile dropped the edit. */
+    dropped = false;
+    /** The command the operation executed. */
+    command;
+    /** The side effects that executed, in execution order. */
+    steps = [];
+    /**
+     * The copies' projection when the operation opened, amended as documents
+     * join or leave the write set during it.
+     */
+    before;
+    transition;
+    /** Whether an undo or redo is running the side effects, on copies it discards. */
+    undoingOrRedoing = false;
+    constructor(modelState) {
+        this.modelState = modelState;
+        const members = {
+            run: create => this.run(create),
+            workingRootOf: (key, built) => this.workingRootOf(key, built),
+            existingWorkingRootOf: key => this.workingRoots.get(key),
+            workingUriOf: node => this.workingUriOf(node),
+            builtNodeOf: node => this.builtNodeOf(node),
+            recordWrittenRoot: root => {
+                this.writtenRoot = root;
+            },
+            recordDropped: current => {
+                this.dropped = true;
+                this.writtenRoot = current;
+            },
+            recordExecuted: step => {
+                this.steps.push(step);
+            },
+            amendBefore: update => {
+                if (this.before !== undefined) {
+                    this.before = update(this.before);
+                }
+            },
+            assertNotDuringUndoRedo: label => {
+                if (this.undoingOrRedoing) {
+                    throw new Error(`Recording command '${label}' executed during an undo or redo, which writes only the recorded transition, ` +
+                        'so its edit would be discarded. Execute it in an operation of its own.');
+                }
+            }
+        };
+        internals.set(this, members);
+    }
+    /**
+     * Open the operation, execute the command `create` makes, write the result
+     * once, and close the operation.
+     *
+     * `create` runs inside the operation, because handlers resolve their
+     * targets there. On any failure, `create`, the command or the write, the
+     * executed commands' side effects are undone, nothing is written, and the
+     * error is rethrown; after a write whose reconcile dropped the edit, the
+     * side effects are undone the same way and this answers `'dropped'`. The
+     * operation closes either way: the copies are dropped and the source root
+     * is captured again, with the base version, every tracked version and the
+     * index.
+     */
+    async run(create) {
+        this.open();
+        let recorded;
+        try {
+            this.before = await this.project();
+            await this.checkpoint('create');
+            const command = await create();
+            if (!command) {
+                return 'none';
+            }
+            await this.tracked(command).execute();
+            this.command = command;
+            await this.checkpoint('project');
+            const written = await this.project();
+            if (written !== undefined && !(await this.write(written))) {
+                await this.rollback();
+                return 'dropped';
+            }
+            if (this.before !== undefined && written !== undefined) {
+                recorded = { from: this.before, to: written };
+            }
+        }
+        catch (error) {
+            await this.rollback();
+            throw error;
+        }
+        finally {
+            this.close();
+        }
+        // After the write landed, so a failure here leaves it in place: the
+        // transition is then kept as recorded, and an undo may conflict.
+        try {
+            this.transition = recorded && (await this.modelState.normalizeTransition(recorded));
+        }
+        catch (error) {
+            this.modelState.logger.warn(`Normalizing an operation's transition failed: ${describeErrorWithStack(error)}`);
+            this.transition = recorded;
+        }
+        return 'executed';
+    }
+    /**
+     * Awaited where the operation, or an undo or redo of it, yields to code it
+     * does not control: before creating the command, before each side effect
+     * executes, is undone or redone, rolls back or is compensated, before
+     * projecting the copies, before resolving an undo or redo. Does nothing; a
+     * test overrides it to land a foreign edit or a failure there.
+     */
+    async checkpoint(_point) {
+        // A seam for tests.
+    }
+    /**
+     * Does nothing: {@link runOperation} executed the command; the command stack
+     * calls this when it pushes the entry.
+     */
+    async execute() {
+        // Executed by runOperation().
+    }
+    async undo() {
+        await this.undoOrRedo('undo');
+    }
+    async redo() {
+        await this.undoOrRedo('redo');
+    }
+    canUndo() {
+        return this.command?.canUndo?.() ?? true;
+    }
+    /** The working copy of `built`, the root of the document whose canonical URI is `key`, made on the first request. */
+    workingRootOf(key, built) {
+        let working = this.workingRoots.get(key);
+        if (!working) {
+            working = AstUtils.copyAstNode(built, (_node, _property, _refNode, _refText, original) => this.buildWorkingReference(original), this.trace);
+            this.rebuildWorkingMultiReferences(working);
+            this.workingRoots.set(key, working);
+            workingRootUris.set(working, key);
+            this.modelState.index.remapSemanticAliases(node => AstUtils.findRootNode(node) === built ? (this.trace.get(node) ?? node) : node);
+        }
+        return working;
+    }
+    /** The canonical URI of the working root `node` belongs to; `undefined` for a node of no copy. */
+    workingUriOf(node) {
+        const root = AstUtils.findRootNode(node);
+        for (const [key, working] of this.workingRoots) {
+            if (working === root) {
+                return key;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * The built node `node` was copied from; `node` itself for a node of no copy
+     * and for a node the operation created.
+     */
+    builtNodeOf(node) {
+        if (this.workingUriOf(node) === undefined) {
+            return node;
+        }
+        const built = this.trace.get(node);
+        return built === undefined ? node : built;
+    }
+    /**
+     * Copy the source root, and point the index at the copy, so the nodes a
+     * handler resolves by id are the nodes it edits.
+     */
+    open() {
+        this.sourceRootAtOpen = this.modelState.sourceRoot;
+        this.baseVersionAtOpen = this.modelState.baseVersion;
+        openOperations.set(this.modelState, membersOf(this));
+        if (this.sourceRootAtOpen !== undefined) {
+            this.modelState.index.reindexSemanticElements(this.modelState.sourceRoot, this.modelState.sourceUri);
+        }
+    }
+    /**
+     * Drop the copies, move every id added through `indexSemanticElement` from
+     * a copy back to the built node it was copied from, and capture the source
+     * root again, whether or not the write changed it.
+     */
+    close() {
+        const copies = new Set(this.workingRoots.values());
+        this.modelState.index.remapSemanticAliases(node => (copies.has(AstUtils.findRootNode(node)) ? this.trace.get(node) : node));
+        openOperations.delete(this.modelState);
+        const root = this.writtenRoot ?? this.sourceRootAtOpen;
+        if (root !== undefined) {
+            this.modelState.setSourceRoot(this.modelState.sourceUri, root);
+        }
+    }
+    /**
+     * Undo the side effects of the executed commands, newest first, each step
+     * on its own: a step that fails is logged and the rest are still undone.
+     * The operation's own error is the one thrown.
+     */
+    async rollback() {
+        await this.runEach([...this.steps].reverse().map(step => () => step.undo()), 'Rolling back a failed operation', 'rollback');
+    }
+    /**
+     * Run each of `actions`, each reverting a side effect of its own: a failure
+     * is logged as `what` failing and the rest still run, so one step that
+     * cannot be reverted leaves no other step applied. The caller reports its
+     * own failure, not these.
+     */
+    async runEach(actions, what, point) {
+        for (const action of actions) {
+            try {
+                await this.checkpoint(point);
+                await action();
+            }
+            catch (error) {
+                this.modelState.logger.error(`${what} failed at one step: ${describeErrorWithStack(error)}`);
+            }
+        }
+    }
+    /**
+     * `command` with every side effect it executes recorded as a step: the
+     * command itself, or for a `CompoundCommand` each child, at any depth. A
+     * tracked command's own undo and redo do nothing, so a `CompoundCommand`
+     * reverting its children when a later one throws leaves that to the steps.
+     *
+     * The children are read from GLSP's protected `CompoundCommand.commands`;
+     * should that field stop being readable, a compound becomes one step and
+     * its children's side effects no longer interleave with the bridges.
+     */
+    tracked(command) {
+        const children = command instanceof CompoundCommand ? Reflect.get(command, 'commands') : undefined;
+        if (isCommandArray(children)) {
+            children.forEach((child, i) => {
+                children[i] = this.tracked(child);
+            });
+            return command;
+        }
+        return {
+            execute: async () => {
+                await this.checkpoint('execute');
+                await command.execute();
+                this.steps.push({ undo: () => command.undo(), redo: () => command.redo() });
+            },
+            undo: () => undefined,
+            redo: () => undefined,
+            canUndo: () => Command.canUndo(command)
+        };
+    }
+    /** The model projected from the working copies, cloned; `undefined` for a state that projects none. */
+    async project() {
+        const model = await this.modelState.sourceModel;
+        return model === undefined ? undefined : structuredClone(model);
+    }
+    /**
+     * Resolve the transition onto the current model, run the commands' side
+     * effects, then write once, gated on the versions the model was read at. A
+     * collision does nothing but warn; a transition with nothing left to apply,
+     * or one the model already holds, still runs the side effects.
+     *
+     * The caller holds `runExclusive`, which nothing here takes again.
+     */
+    async undoOrRedo(direction) {
+        // Captured again so the model the transition is resolved onto, the base
+        // a conflict reconciles from and the versions the write is gated on are
+        // read together.
+        if (this.modelState.sourceRoot !== undefined) {
+            this.modelState.setSourceRoot(this.modelState.sourceUri, this.modelState.sourceRoot);
+        }
+        await this.checkpoint('resolve');
+        let merged;
+        const { transition } = this.inDirection(direction);
+        if (transition) {
+            const outcome = await this.modelState.conflictResolver.resolve(transition.from, transition.to, async () => this.modelState.sourceModel);
+            if (outcome.status === 'merged') {
+                merged = outcome.merged;
+            }
+            else if (outcome.status !== 'no-op' && outcome.status !== 'already-applied') {
+                this.modelState.logger.warn(`${direction === 'undo' ? 'Undo' : 'Redo'} of an operation skipped (${outcome.status}); a foreign edit changed a shared field`);
+                return;
+            }
+        }
+        await this.undoOrRedoSideEffects(direction, merged);
+    }
+    /**
+     * Write `model` once through the state's write path, gated on the versions
+     * read when the operation opened, a conflict reconciled as for any write of
+     * the state; `false` when the reconcile dropped it.
+     */
+    async write(model) {
+        this.dropped = false;
+        await this.modelState.updateSourceModel(model, this.baseVersionAtOpen);
+        return !this.dropped;
+    }
+    /**
+     * Run the recorded steps of an undo or redo against fresh copies of the
+     * built roots, made on demand as in an operation and discarded unwritten,
+     * then write `merged`, the resolved transition, through {@link write}: that
+     * write is what changes the model, and a step that edits `sourceRoot` must
+     * not reach the root every reader shares. A recording command executed here
+     * throws.
+     *
+     * When a step or the write throws, or the write's reconcile drops it, the
+     * steps already run are run the other way, newest first, and the error is
+     * rethrown with nothing written; GLSP's command stack then flushes, as it
+     * does for any undo or redo that fails.
+     */
+    async undoOrRedoSideEffects(direction, merged) {
+        this.workingRoots.clear();
+        this.trace.clear();
+        this.writtenRoot = undefined;
+        this.undoingOrRedoing = true;
+        this.open();
+        const { steps, run } = this.inDirection(direction);
+        const done = [];
+        try {
+            for (const step of steps) {
+                await this.checkpoint(direction);
+                await run(step);
+                done.unshift(step);
+            }
+            if (merged === undefined) {
+                // Nothing to write, but a step may have rebuilt the document: close on its built root, not the one opened on.
+                this.modelState.captureBuiltRoot();
+            }
+            else if (!(await this.write(merged))) {
+                throw new DiagramEditDroppedError(`The ${direction} of an operation was dropped: a foreign edit changed a field it writes`);
+            }
+        }
+        catch (error) {
+            await this.compensate(done, direction);
+            throw error;
+        }
+        finally {
+            this.close();
+            this.undoingOrRedoing = false;
+        }
+    }
+    /**
+     * Run `steps`, which a failed undo or redo already ran, the other way, each
+     * on its own as {@link rollback} does; the undo or redo's own error is the
+     * one thrown.
+     */
+    async compensate(steps, direction) {
+        const { revert } = this.inDirection(direction);
+        await this.runEach(steps.map(step => () => revert(step)), `Reverting a failed ${direction}`, 'compensate');
+    }
+    /**
+     * The transition and the recorded steps as `direction` runs them: an undo
+     * runs the transition backwards and each step's undo, newest first, and is
+     * reverted by each step's redo; a redo the other way round.
+     */
+    inDirection(direction) {
+        if (direction === 'redo') {
+            return { transition: this.transition, steps: [...this.steps], run: step => step.redo(), revert: step => step.undo() };
+        }
+        return {
+            transition: this.transition && { from: this.transition.to, to: this.transition.from },
+            steps: [...this.steps].reverse(),
+            run: step => step.undo(),
+            revert: step => step.redo()
+        };
+    }
+    /**
+     * The copy's stand-in for `original`: its target is the copy of
+     * `original`'s target once one exists, read when asked so a copy made later
+     * in the operation is found, else that target itself. A handler compares a
+     * target by identity with nodes it resolved from a copy.
+     */
+    buildWorkingReference(original) {
+        const trace = this.trace;
+        return {
+            $refText: original.$refText,
+            $refNode: original.$refNode,
+            get ref() {
+                const target = original.ref;
+                return target && (trace.get(target) ?? target);
+            },
+            get error() {
+                return original.error;
+            },
+            get $nodeDescription() {
+                return original.$nodeDescription;
+            }
+        };
+    }
+    /** {@link buildWorkingReference} for a reference with several targets. */
+    buildWorkingMultiReference(original) {
+        const trace = this.trace;
+        return {
+            $refText: original.$refText,
+            $refNode: original.$refNode,
+            get items() {
+                return original.items.map(item => ({ ref: trace.get(item.ref) ?? item.ref, $nodeDescription: item.$nodeDescription }));
+            },
+            get error() {
+                return original.error;
+            }
+        };
+    }
+    /**
+     * Replace every multi-reference under `working` with a working one.
+     * `AstUtils.copyAstNode` rebuilds single references only and leaves a
+     * multi-reference object shared with the built root, whose targets are
+     * built nodes.
+     */
+    rebuildWorkingMultiReferences(working) {
+        for (const node of AstUtils.streamAst(working)) {
+            const properties = node;
+            for (const [name, value] of Object.entries(properties)) {
+                if (name.startsWith('$')) {
+                    continue;
+                }
+                if (isMultiReference(value)) {
+                    properties[name] = this.buildWorkingMultiReference(value);
+                }
+                else if (Array.isArray(value) && value.some(element => isMultiReference(element))) {
+                    properties[name] = value.map((element) => isMultiReference(element) ? this.buildWorkingMultiReference(element) : element);
+                }
+            }
+        }
+    }
+}
+function isCommandArray(value) {
+    return Array.isArray(value) && value.every(element => typeof element === 'object' && element !== null && 'execute' in element);
+}
+//# sourceMappingURL=hydranium-glsp-operation-command.js.map

package/lib/command/hydranium-glsp-operation-command.js.map

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

package/lib/command/hydranium-glsp-recording-command.d.ts

@@ -9,6 +9,7 @@
 import { type AnyObject, type JsonModelState, JsonRecordingCommand, type MaybePromise } from '@eclipse-glsp/server';
 import { type AstNode } from '@hydranium/langium';
 import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
+import { HydraniumGlspOperationCommand } from './hydranium-glsp-operation-command.js';
 /**
  * Source-model state shape consumed by {@link HydraniumGlspRecordingCommand}.
  * The intersection ties together GLSP's read-side
@@ -21,112 +22,50 @@ import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-gls
  */
 export type HydraniumGlspRecordingState<TSourceModel extends AnyObject> = AbstractHydraniumGlspState<AstNode, TSourceModel> & JsonModelState<TSourceModel>;
 /**
- * GLSP {@link JsonRecordingCommand} base shared by all hydranium adopters.
- * Adds two things on top of GLSP's class:
- *
- *  1. A **time-labelled execute wrapper** so log lines record how long a
- *     user-facing operation takes end-to-end — including the `postChange`
- *     source-model update that re-parses the document. Otherwise the diff +
- *     patch + persist work happens silently and is hard to attribute when
- *     something is slow.
- *  2. A typed `state` field that exposes `updateSourceModel` for the
- *     `postChange` bridge AND the framework `logger` for time-labelled
- *     logging. GLSP's base class only types `modelState: JsonModelState`,
- *     which lacks the framework's logger surface.
+ * GLSP {@link JsonRecordingCommand} base shared by all hydranium adopters: a
+ * handler mutates `sourceRoot` in the command's runnable, and the operation
+ * the command executes in writes the result once when it ends.
  *
  * **Optional undo/redo bridge hooks.** An adopter command can supply
- * `undoAction` / `redoAction` callbacks invoked alongside the patch apply, to
- * re-emit a side-effect the patch itself does not carry. Provided as optional
- * constructor args so adopters get that composition surface without
- * subclassing. Operation handlers that don't need bridge callbacks omit them.
+ * `undoAction` / `redoAction` callbacks, run when the operation is undone or
+ * redone and when a failed operation rolls back, to re-emit a side effect the
+ * model does not carry. During an undo or redo they run against throwaway
+ * copies, and a recording command executed there throws.
  *
- * **postChange semantics.** GLSP's `JsonRecordingCommand.postChange` calls
- * `modelState.updateSourceModel(newModel)` with the model only. The
- * framework lift overrides `postChange` so it also threads the based-on
- * version captured at command start — letting the downstream
- * `ModelService.update` opt into the `ConflictError` gate. Undo / redo
- * postChange calls run with version `undefined` (no gating): the user
- * authored against the recorded patch, not against a specific server
- * version, so re-applying it should succeed regardless of intervening
- * edits. The recorded patch itself encodes the semantic intent.
+ * A command executed outside an operation opens one of its own through
+ * `runExclusive`, so executing it from inside the boundary with no operation
+ * open deadlocks. Its undo and redo then undo and redo that operation without
+ * taking the boundary, which the caller holds, as the framework's undo handler
+ * does; taking it there would deadlock under that handler.
  */
 export declare class HydraniumGlspRecordingCommand<TSourceModel extends AnyObject> extends JsonRecordingCommand<TSourceModel> {
     /** Human-readable label for the operation; appears in the timing-pair log line. */
     protected readonly label: string;
-    /** Optional bridge invoked alongside undo patch application; for adopters
-     *  that need to re-emit a side-effect the patch does not carry. */
+    /** Optional bridge invoked when the command is undone; for adopters
+     *  that need to re-emit a side-effect the model does not carry. */
     protected readonly undoAction?: (() => MaybePromise<void>) | undefined;
-    /** Optional bridge invoked alongside redo patch application. */
+    /** Optional bridge invoked when the command is redone. */
     protected readonly redoAction?: (() => MaybePromise<void>) | undefined;
     protected modelState: HydraniumGlspRecordingState<TSourceModel>;
-    /**
-     * Based-on version captured at {@link execute} start; threaded into
-     * {@link postChange} so {@link AbstractHydraniumGlspState.updateSourceModel}
-     * sees the version the user authored against. Cleared after `execute`
-     * returns so undo / redo paths fall through to `updateSourceModel`
-     * without a version (no gating).
-     */
-    protected activeVersion?: number;
-    /**
-     * Source-model snapshots captured at {@link execute} — the state the
-     * command left ({@link afterSnapshot}) and the state it started from
-     * ({@link beforeSnapshot}). {@link undo} / {@link redo} reconcile the
-     * recorded transition against the *current* source model via the state's
-     * {@link AbstractHydraniumGlspState.conflictResolver}, so under the default
-     * reconciling policy a concurrent edit to another field survives and a
-     * same-field collision is dropped rather than clobbered.
-     */
-    protected beforeSnapshot?: TSourceModel;
-    protected afterSnapshot?: TSourceModel;
+    /** The operation this command opened, when it executed outside one. */
+    protected ownOperation?: HydraniumGlspOperationCommand<TSourceModel>;
     constructor(modelState: HydraniumGlspRecordingState<TSourceModel>, 
     /** Human-readable label for the operation; appears in the timing-pair log line. */
     label: string, doExecute: () => MaybePromise<void>, 
-    /** Optional bridge invoked alongside undo patch application; for adopters
-     *  that need to re-emit a side-effect the patch does not carry. */
+    /** Optional bridge invoked when the command is undone; for adopters
+     *  that need to re-emit a side-effect the model does not carry. */
     undoAction?: (() => MaybePromise<void>) | undefined, 
-    /** Optional bridge invoked alongside redo patch application. */
+    /** Optional bridge invoked when the command is redone. */
     redoAction?: (() => MaybePromise<void>) | undefined);
-    /**
-     * Time-label the full execute path: pre-state snapshot + `doExecute` +
-     * post-state snapshot + patch-derive + `postChange` (which writes back
-     * via {@link AbstractHydraniumGlspState.updateSourceModel}). The label combines
-     * the operation name with the source-uri-stamped logger.
-     *
-     * Captures {@link AbstractHydraniumGlspState.version} at start so {@link postChange}
-     * can thread the based-on version into `updateSourceModel`. The capture
-     * is `try`/`finally`-scoped so undo / redo paths invoked later do not
-     * see a stale captured version.
-     */
     execute(): Promise<void>;
+    /** Writes nothing: the operation the command executes in writes once when it ends. */
+    protected postChange(_newModel: TSourceModel): void;
     /**
-     * Override of GLSP's {@link JsonRecordingCommand.postChange} so the
-     * call to {@link AbstractHydraniumGlspState.updateSourceModel} threads the
-     * captured based-on version alongside the new model.
-     *
-     * During {@link execute} the version is the snapshot captured at
-     * command start; during {@link undo} / {@link redo} it is `undefined`
-     * — replaying a recorded patch does not author against a specific
-     * server version, so no gate applies.
-     */
-    protected postChange(newModel: TSourceModel): MaybePromise<void>;
-    /**
-     * Reconcile the recorded `after → before` transition against the
-     * *current* source model via the state's
-     * {@link AbstractHydraniumGlspState.conflictResolver}, invoke the optional adopter
-     * `undoAction`, and persist via `postChange`. Under the default reconciling
-     * policy the revert is replayed guarded by `test` ops, so a concurrent edit
-     * to another field is preserved (merged) and a same-field collision is
-     * dropped rather than clobbered; a force policy clobbers (last-writer-wins).
-     * On anything but a clean merge the undo is a logged no-op — the side-effect
-     * bridge and `postChange` only run on a merged result, preserving a
-     * "bridge before commit" order.
+     * Inside an open operation does nothing: the operation runs the bridge, once
+     * for every recording command that executed.
      */
     undo(): Promise<void>;
-    /**
-     * Reconcile the recorded `before → after` transition against the current
-     * source model, invoke the optional adopter `redoAction`, and persist via
-     * `postChange`. Same guarded merge / drop semantics as {@link undo}.
-     */
+    /** Inside an open operation does nothing, as {@link undo}. */
     redo(): Promise<void>;
 }
 //# sourceMappingURL=hydranium-glsp-recording-command.d.ts.map