@grafloria/element 0.3.17 → 0.3.19

package/src/libs/engine/src/collab/integrity.d.ts

@@ -0,0 +1,178 @@
+import { DiagramModel } from '../models/DiagramModel';
+import { LinkModel } from '../models/LinkModel';
+import type { LwwRegistry } from './lww';
+import { type Op } from './op';
+/**
+ * Holds the diagram to its one hard invariant, and buffers the ops that cannot be applied
+ * yet.
+ *
+ * Drives the model directly. Its writes MUST NOT be captured as ops (they are derived, and
+ * broadcasting them would race with the very ops they are derived from) — the Replica runs
+ * every call into this class with capture suppressed.
+ */
+export declare class ReferentialIntegrity {
+    private readonly diagram;
+    private readonly lww;
+    /** Links that logically exist but whose endpoints do not resolve. Held, not destroyed. */
+    private readonly quarantine;
+    /**
+     * portId → nodeId. OUR OWN, not the engine's.
+     *
+     * DiagramModel keeps a portIndex, and it would be the obvious thing to resolve endpoints
+     * through. It cannot be used here, and the reason is a genuine ordering trap:
+     *
+     *     installNode():  nodes.set(id, node)          ← the node is queryable
+     *                     trackChange('nodes', …)      ← CAPTURE FIRES HERE
+     *                     indexNodePorts(node)         ← the port index catches up HERE
+     *
+     *     removeNode():   nodes.delete(id)
+     *                     unindexNodePorts(node)       ← the port index is updated FIRST
+     *                     trackChange('nodes', …)      ← capture fires here
+     *
+     * So on ADD the engine's port index is a beat BEHIND the change event we react to, and on
+     * REMOVE it is a beat AHEAD. Reconciling on the add would find the new node's ports
+     * missing and refuse to release the links waiting for it — for good, since nothing would
+     * ever ask again. An asymmetry like that is exactly the kind of thing that works in every
+     * test and fails in a session.
+     *
+     * The node itself is fully queryable at both moments, so we index from the node and the
+     * ordering stops mattering.
+     */
+    private readonly portOwner;
+    /**
+     * Is the entity order possibly WRONG, and what is the newest presence stamp in each
+     * collection?
+     *
+     * canonicalize() is O(n) even when it changes nothing, and it used to run on every structural
+     * op — which is the other half of what made a bulk load quadratic. But order can only break
+     * one way: an entity APPENDED with a presence stamp OLDER than one already in the collection.
+     * Adds in the ordinary course of events arrive with ever-increasing clocks, so the collection
+     * stays sorted for free and the scan is pure waste. Removals cannot unsort anything.
+     *
+     * So: watch for a stamp that goes backwards, and only then pay for the sort.
+     */
+    private orderDirty;
+    private readonly maxPresence;
+    constructor(diagram: DiagramModel, lww: LwwRegistry);
+    /** Link ids currently held out of the document. Small; usually empty. */
+    get quarantined(): string[];
+    /** Is this link being held out of the document? */
+    isHeld(id: string): boolean;
+    /** The held instance, so a write can still reach a link that is out of the document. */
+    held(id: string): LinkModel | undefined;
+    /**
+     * Force a held link back into the document, endpoints or no endpoints.
+     *
+     * Only for undo: to UNDO the creation of a link that is currently quarantined, the link
+     * has to be in the document for `removeLink()` to be a real mutation that capture can
+     * mint an op from. Without this the undo silently does nothing, the link's presence
+     * register still says "present", and resurrecting its node brings back a link the user
+     * explicitly took back. The following reconcile() re-quarantines it if it is still
+     * orphaned, so this is a keyhole, not a hole.
+     */
+    release(id: string): void;
+    /** Keep the port map and the order watermark current with the ops that change structure. */
+    note(op: Op): void;
+    private indexPorts;
+    /**
+     * Can this op be applied to the document right now?
+     *
+     * Returns `true` when the op was DIVERTED — written into a link this class is holding out
+     * of the document — in which case the caller must not also hand it to applyOp.
+     *
+     * A held link still takes its property writes, through the SAME mutators a live one uses.
+     * An entity that took a different write path in quarantine would drift from a live one, and
+     * the drift would only surface on release, long after anything could point at the cause.
+     */
+    divert(op: Op): boolean;
+    /**
+     * The INCREMENTAL invariant check: only what THIS op could possibly have broken.
+     *
+     * A full sweep after every local edit is O(links), and a local edit stream is n ops long, so
+     * a bulk load — importing a document into a live session — was O(n²). Measured: 2,000 nodes
+     * and 2,000 links took 8.5 SECONDS through a Replica, against ~90ms without one. Nothing
+     * caught it, because no perf gate in this repo drives a Replica. That is the shape of defect
+     * this codebase keeps shipping, and I very nearly shipped another one.
+     *
+     * So each op pays only for what it can actually affect:
+     *
+     *   add node      → only a QUARANTINED link can become live. The quarantine is almost always
+     *                   empty, so this is free. (A live link cannot break when a node ARRIVES.)
+     *   add link      → that one link. O(1).
+     *   remove link   → drop it from the quarantine. O(1).
+     *   remove node   → live links attached to it can be orphaned. O(links) — but deleting a node
+     *                   is a human action, not a loop.
+     *   set ports     → same as removing a node: an endpoint may have vanished.
+     *   set endpoints → that one link. O(1).
+     *
+     * A bulk load is all adds, so it is linear again.
+     */
+    settle(op: Op): void;
+    /**
+     * Re-evaluate the invariant over the WHOLE document.
+     *
+     * Once per BATCH of remote ops, and once at the end of a replay — where the invariant is a
+     * function of the batch's final state, not of the path through it (a link orphaned mid-batch
+     * and re-parented by the end of it was never really orphaned).
+     */
+    reconcile(): void;
+    /**
+     * Evict links that have lost an endpoint — and RE-RESOLVE the cached endpoint node ids of
+     * the survivors.
+     *
+     * That re-resolution is not housekeeping, it is a bug fix. installLink() backfills
+     * sourceNodeId/targetNodeId from the port index exactly once, at install, and only if they
+     * are unset. A link applied BEFORE its node arrived (which the network is entitled to do,
+     * and which a mesh does routinely) indexes nothing and keeps `undefined` node ids FOREVER.
+     * They are in serialize(), so the peers' documents differ — and the renderer resolves port
+     * SIDES through them, so the link is drawn wrong on one peer and right on the other.
+     * Deriving them makes them a function of state, and the arrival order stops mattering.
+     */
+    private evictOrphans;
+    /** Give back the links whose endpoints have come home. */
+    private releaseResolvable;
+    /** One link, either way. */
+    private checkLink;
+    /**
+     * ORDER IS PART OF THE DOCUMENT, and the fuzz is what proved it.
+     *
+     * `serialize()` writes `nodes` as `Array.from(this.nodes.values())` — Map INSERTION order.
+     * And the SVG renderer sorts nodes by `zIndex` with a STABLE sort, so when zIndex ties (the
+     * overwhelmingly common case: nobody sets it, everything is 0) THE ARRAY ORDER IS THE PAINT
+     * ORDER. It decides which of two overlapping nodes is on top.
+     *
+     * Insertion order is a function of the path a peer took, not of the state it arrived at:
+     *
+     *     Alice deletes node `a` and undoes → `a` is re-inserted, so it moves to the END.
+     *     Bob receives the re-add BEFORE the delete → the delete is then refused as superseded,
+     *     Bob never removed anything, and `a` never moves.
+     *
+     * Same ops. Same content, field for field. Different `nodes` array. The two of them paint
+     * overlapping nodes in a different order and save byte-different files. The fuzz caught it on
+     * trial 2 and it would never have occurred to me.
+     *
+     * The fix is the same shape as everything else in this file: DERIVE the order from the
+     * converged state instead of inheriting it from the delivery path. An entity's rank is the
+     * stamp of the write that established its CURRENT INCARNATION. That is identical on every
+     * peer, and in the ordinary case (add a, add b, add c) it reproduces insertion order exactly,
+     * so nothing that was not already broken changes.
+     *
+     * Gated on `orderDirty`, because the sort is O(n) even when it changes nothing and adds
+     * normally arrive with ever-increasing clocks — see the field's comment.
+     */
+    private canonicalizeIfDirty;
+    private order;
+    /** Drop a link from quarantine for good — its presence register says it is gone. */
+    forget(op: Op): void;
+    /** The node that owns a port, IF that node is currently in the document. */
+    private ownerOf;
+    private endpointsResolve;
+    /**
+     * Derive the cached endpoint node ids.
+     *
+     * Assigned directly, NOT through a mutator, and that is deliberate: these are DERIVED
+     * state, not authored state. A trackChange here would emit an op, broadcast a value every
+     * peer can compute for itself, and race with the ops it was derived from.
+     */
+    private resolveEndpoints;
+}

package/src/libs/engine/src/collab/integrity.js

@@ -0,0 +1,438 @@
+"use strict";
+// Wave 9 — Card 4: REFERENTIAL INTEGRITY, and the buffer for ops that outran their cause.
+//
+// ---------------------------------------------------------------------------
+// THE RULE
+// ---------------------------------------------------------------------------
+//
+//     A LINK IS LIVE  ⟺  BOTH ITS ENDPOINT PORTS RESOLVE TO NODES PRESENT IN THE DIAGRAM.
+//
+// That is the whole model. Everything below is bookkeeping in service of it.
+//
+// It is stated as a PURE FUNCTION OF STATE, and that is the load-bearing choice. Every
+// peer evaluates the same predicate over the same (converged) presence registers and
+// therefore reaches the same answer — so integrity CONVERGES BECAUSE IT IS DERIVED. It
+// needs no op of its own, no cascade broadcast, no agreement protocol, and it cannot
+// itself become a source of conflict.
+//
+// The obvious alternative — cascade: when a node is deleted, also emit `remove link` for
+// each of its links — is strictly worse, and it is worth saying why, because it is what
+// one writes first:
+//
+//   • It cannot see a link it does not know about. Bob deletes node N and cascades the
+//     links HE can see. Alice, concurrently, draws a new link into N. Bob's cascade never
+//     saw it. It survives, dangling. The cascade has bought nothing in the only case that
+//     matters — the concurrent one.
+//   • It is IRREVERSIBLE. A `remove link` op puts "removed" in the link's presence
+//     register. Undo the node delete and the node returns to a diagram whose links are
+//     permanently dead, because nothing knows to resurrect them too.
+//   • It is chatty: N ops on the wire for one user action, all of them derivable.
+//
+// So orphaned links are QUARANTINED, not destroyed: held aside by this class, absent from
+// the document, and STILL PRESENT in the presence registers. Bring the node back and the
+// predicate flips and the links come back with it — including a colleague's link that this
+// peer never saw as live. Integrity being derived is exactly what makes it reversible.
+//
+// ---------------------------------------------------------------------------
+// TWO KINDS OF "NOT HERE", AND CONFLATING THEM LOSES DATA
+// ---------------------------------------------------------------------------
+// applyOp drops a `set` on an entity the diagram does not hold. For a DELETED entity that
+// is right. For one that has merely NOT ARRIVED YET it is a silent, permanent data loss —
+// and worse, the LWW gate has by then claimed the register for that write, so a
+// re-delivery is refused as superseded and cannot repair it. Card 0 flagged this honestly
+// and left it. It is the same shape of problem as the quarantine, so it is solved here, by
+// the same mechanism: hold the write until its dependency lands.
+//
+//   • entity NEVER SEEN (no presence stamp)  → BUFFER the write; flush it when the `add`
+//     arrives.
+//   • entity QUARANTINED (a held link)       → apply the write TO THE HELD INSTANCE, so
+//     its state is complete and current the moment it is released.
+//   • entity REMOVED (a remove won)          → DROP the write. It is gone, and the
+//     presence barrier in lww.ts makes that decision stick on every peer.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferentialIntegrity = void 0;
+const apply_op_1 = require("./apply-op");
+const op_1 = require("./op");
+/**
+ * Holds the diagram to its one hard invariant, and buffers the ops that cannot be applied
+ * yet.
+ *
+ * Drives the model directly. Its writes MUST NOT be captured as ops (they are derived, and
+ * broadcasting them would race with the very ops they are derived from) — the Replica runs
+ * every call into this class with capture suppressed.
+ */
+class ReferentialIntegrity {
+    constructor(diagram, lww) {
+        this.diagram = diagram;
+        this.lww = lww;
+        /** Links that logically exist but whose endpoints do not resolve. Held, not destroyed. */
+        this.quarantine = new Map();
+        /**
+         * portId → nodeId. OUR OWN, not the engine's.
+         *
+         * DiagramModel keeps a portIndex, and it would be the obvious thing to resolve endpoints
+         * through. It cannot be used here, and the reason is a genuine ordering trap:
+         *
+         *     installNode():  nodes.set(id, node)          ← the node is queryable
+         *                     trackChange('nodes', …)      ← CAPTURE FIRES HERE
+         *                     indexNodePorts(node)         ← the port index catches up HERE
+         *
+         *     removeNode():   nodes.delete(id)
+         *                     unindexNodePorts(node)       ← the port index is updated FIRST
+         *                     trackChange('nodes', …)      ← capture fires here
+         *
+         * So on ADD the engine's port index is a beat BEHIND the change event we react to, and on
+         * REMOVE it is a beat AHEAD. Reconciling on the add would find the new node's ports
+         * missing and refuse to release the links waiting for it — for good, since nothing would
+         * ever ask again. An asymmetry like that is exactly the kind of thing that works in every
+         * test and fails in a session.
+         *
+         * The node itself is fully queryable at both moments, so we index from the node and the
+         * ordering stops mattering.
+         */
+        this.portOwner = new Map();
+        /**
+         * Is the entity order possibly WRONG, and what is the newest presence stamp in each
+         * collection?
+         *
+         * canonicalize() is O(n) even when it changes nothing, and it used to run on every structural
+         * op — which is the other half of what made a bulk load quadratic. But order can only break
+         * one way: an entity APPENDED with a presence stamp OLDER than one already in the collection.
+         * Adds in the ordinary course of events arrive with ever-increasing clocks, so the collection
+         * stays sorted for free and the scan is pure waste. Removals cannot unsort anything.
+         *
+         * So: watch for a stamp that goes backwards, and only then pay for the sort.
+         */
+        this.orderDirty = false;
+        this.maxPresence = new Map();
+        // Wave 10. `DiagramModel.removeNode()` now cascades its links — the single-user
+        // document had no owner for that invariant at all, and left them dangling on screen.
+        // THIS class is the better owner, for the reasons argued at the top of this file, so
+        // take the cascade off: an orphaned link must reach the quarantine (reversibly), not
+        // the bin (permanently).
+        diagram.linkIntegrityOwner = 'external';
+        // A Replica is routinely attached to a diagram that already has content.
+        for (const n of diagram.getNodes())
+            this.indexPorts(n.id);
+    }
+    /** Link ids currently held out of the document. Small; usually empty. */
+    get quarantined() {
+        return [...this.quarantine.keys()].sort();
+    }
+    /** Is this link being held out of the document? */
+    isHeld(id) {
+        return this.quarantine.has(id);
+    }
+    /** The held instance, so a write can still reach a link that is out of the document. */
+    held(id) {
+        return this.quarantine.get(id);
+    }
+    /**
+     * Force a held link back into the document, endpoints or no endpoints.
+     *
+     * Only for undo: to UNDO the creation of a link that is currently quarantined, the link
+     * has to be in the document for `removeLink()` to be a real mutation that capture can
+     * mint an op from. Without this the undo silently does nothing, the link's presence
+     * register still says "present", and resurrecting its node brings back a link the user
+     * explicitly took back. The following reconcile() re-quarantines it if it is still
+     * orphaned, so this is a keyhole, not a hole.
+     */
+    release(id) {
+        const link = this.quarantine.get(id);
+        if (!link)
+            return;
+        this.quarantine.delete(id);
+        this.orderDirty = true; // re-inserting APPENDS — see canonicalizeIfDirty()
+        this.diagram.addLink(link);
+    }
+    /** Keep the port map and the order watermark current with the ops that change structure. */
+    note(op) {
+        // An `add` APPENDS to its collection. If its stamp is older than one already in there, the
+        // collection is no longer in canonical order and must be re-sorted — but only then.
+        if (op.op === 'add') {
+            const max = this.maxPresence.get(op.target);
+            const stamp = { clock: op.clock, actor: op.actor };
+            if (max && (max.clock > stamp.clock || (max.clock === stamp.clock && max.actor > stamp.actor))) {
+                this.orderDirty = true;
+            }
+            else {
+                this.maxPresence.set(op.target, stamp);
+            }
+        }
+        if (op.target !== 'node')
+            return;
+        // Both port vocabularies re-index: the legacy whole-collection `ports` register and
+        // the wave14 per-port `ports.<id>` registers alike change which node owns a port.
+        if (op.op === 'add' || (op.op === 'set' && op.path.startsWith('ports'))) {
+            this.indexPorts(op.id);
+        }
+        else if (op.op === 'remove') {
+            for (const [port, owner] of this.portOwner) {
+                if (owner === op.id)
+                    this.portOwner.delete(port);
+            }
+        }
+    }
+    indexPorts(nodeId) {
+        const n = this.diagram.getNode(nodeId);
+        if (!n)
+            return;
+        for (const [port, owner] of this.portOwner) {
+            if (owner === nodeId)
+                this.portOwner.delete(port); // a port may have been removed
+        }
+        for (const p of n.getPorts())
+            this.portOwner.set(p.id, nodeId);
+    }
+    /**
+     * Can this op be applied to the document right now?
+     *
+     * Returns `true` when the op was DIVERTED — written into a link this class is holding out
+     * of the document — in which case the caller must not also hand it to applyOp.
+     *
+     * A held link still takes its property writes, through the SAME mutators a live one uses.
+     * An entity that took a different write path in quarantine would drift from a live one, and
+     * the drift would only surface on release, long after anything could point at the cause.
+     */
+    divert(op) {
+        if (op.op !== 'set' || op.target !== 'link')
+            return false;
+        const held = this.quarantine.get(op.id);
+        if (!held)
+            return false;
+        if (this.lww.admit(op))
+            (0, apply_op_1.applyEntitySet)(held, op.path, (0, op_1.setValueOf)(op));
+        return true;
+    }
+    /**
+     * The INCREMENTAL invariant check: only what THIS op could possibly have broken.
+     *
+     * A full sweep after every local edit is O(links), and a local edit stream is n ops long, so
+     * a bulk load — importing a document into a live session — was O(n²). Measured: 2,000 nodes
+     * and 2,000 links took 8.5 SECONDS through a Replica, against ~90ms without one. Nothing
+     * caught it, because no perf gate in this repo drives a Replica. That is the shape of defect
+     * this codebase keeps shipping, and I very nearly shipped another one.
+     *
+     * So each op pays only for what it can actually affect:
+     *
+     *   add node      → only a QUARANTINED link can become live. The quarantine is almost always
+     *                   empty, so this is free. (A live link cannot break when a node ARRIVES.)
+     *   add link      → that one link. O(1).
+     *   remove link   → drop it from the quarantine. O(1).
+     *   remove node   → live links attached to it can be orphaned. O(links) — but deleting a node
+     *                   is a human action, not a loop.
+     *   set ports     → same as removing a node: an endpoint may have vanished.
+     *   set endpoints → that one link. O(1).
+     *
+     * A bulk load is all adds, so it is linear again.
+     */
+    settle(op) {
+        switch (op.op) {
+            case 'add':
+                if (op.target === 'node')
+                    this.releaseResolvable();
+                else if (op.target === 'link')
+                    this.checkLink(op.id);
+                break;
+            case 'remove':
+                if (op.target === 'node') {
+                    this.evictOrphans();
+                    this.releaseResolvable();
+                }
+                else if (op.target === 'link') {
+                    this.quarantine.delete(op.id);
+                }
+                break;
+            case 'set':
+                if (op.target === 'node' && op.path === 'ports') {
+                    // A port can VANISH from under a link — the same wound as deleting the node, and
+                    // the reason this is not just an add-path concern.
+                    this.evictOrphans();
+                    this.releaseResolvable();
+                }
+                else if (op.target === 'node' && op.path.startsWith('ports.')) {
+                    // wave14 per-port register. A CLEAR removes one port — same wound as above. A
+                    // VALUE can only add or edit a port, which can never orphan a link, so the
+                    // eviction sweep is skipped: port edits are draggable (a stream of ops) and an
+                    // O(links) sweep per drag frame is the quadratic-bulk-load bug reborn. Release
+                    // is O(quarantine) — almost always empty — and a newly-arrived port may be
+                    // exactly what a held link was waiting for.
+                    if ((0, op_1.setValueOf)(op) === undefined)
+                        this.evictOrphans();
+                    this.releaseResolvable();
+                }
+                else if (op.target === 'link' &&
+                    (op.path === 'sourcePortId' || op.path === 'targetPortId')) {
+                    this.checkLink(op.id);
+                }
+                break;
+        }
+        this.canonicalizeIfDirty();
+    }
+    /**
+     * Re-evaluate the invariant over the WHOLE document.
+     *
+     * Once per BATCH of remote ops, and once at the end of a replay — where the invariant is a
+     * function of the batch's final state, not of the path through it (a link orphaned mid-batch
+     * and re-parented by the end of it was never really orphaned).
+     */
+    reconcile() {
+        this.evictOrphans();
+        this.releaseResolvable();
+        this.canonicalizeIfDirty();
+    }
+    /**
+     * Evict links that have lost an endpoint — and RE-RESOLVE the cached endpoint node ids of
+     * the survivors.
+     *
+     * That re-resolution is not housekeeping, it is a bug fix. installLink() backfills
+     * sourceNodeId/targetNodeId from the port index exactly once, at install, and only if they
+     * are unset. A link applied BEFORE its node arrived (which the network is entitled to do,
+     * and which a mesh does routinely) indexes nothing and keeps `undefined` node ids FOREVER.
+     * They are in serialize(), so the peers' documents differ — and the renderer resolves port
+     * SIDES through them, so the link is drawn wrong on one peer and right on the other.
+     * Deriving them makes them a function of state, and the arrival order stops mattering.
+     */
+    evictOrphans() {
+        for (const link of this.diagram.getLinks()) {
+            if (this.endpointsResolve(link)) {
+                this.resolveEndpoints(link);
+            }
+            else {
+                this.diagram.removeLink(link.id);
+                this.quarantine.set(link.id, link);
+            }
+        }
+    }
+    /** Give back the links whose endpoints have come home. */
+    releaseResolvable() {
+        for (const [id, link] of [...this.quarantine]) {
+            if (!this.endpointsResolve(link))
+                continue;
+            this.quarantine.delete(id);
+            // Endpoints resolved BEFORE it is installed: installLink only backfills ids it finds
+            // unset, so a link released with stale ids would keep them.
+            this.resolveEndpoints(link);
+            // A released link is APPENDED, wherever its presence stamp says it belongs — so the
+            // collection may no longer be in canonical order. No `add` op passes through note() on
+            // this path, so nothing else would notice. (The 3-peer fuzz noticed: two peers holding
+            // the same two links in opposite order, which is the same document painted differently.)
+            this.orderDirty = true;
+            this.diagram.addLink(link);
+        }
+    }
+    /** One link, either way. */
+    checkLink(id) {
+        const live = this.diagram.getLink(id);
+        if (live) {
+            if (this.endpointsResolve(live))
+                this.resolveEndpoints(live);
+            else {
+                this.diagram.removeLink(id);
+                this.quarantine.set(id, live);
+            }
+            return;
+        }
+        const held = this.quarantine.get(id);
+        if (held && this.endpointsResolve(held)) {
+            this.quarantine.delete(id);
+            this.resolveEndpoints(held);
+            this.orderDirty = true; // appended — see canonicalizeIfDirty()
+            this.diagram.addLink(held);
+        }
+    }
+    /**
+     * ORDER IS PART OF THE DOCUMENT, and the fuzz is what proved it.
+     *
+     * `serialize()` writes `nodes` as `Array.from(this.nodes.values())` — Map INSERTION order.
+     * And the SVG renderer sorts nodes by `zIndex` with a STABLE sort, so when zIndex ties (the
+     * overwhelmingly common case: nobody sets it, everything is 0) THE ARRAY ORDER IS THE PAINT
+     * ORDER. It decides which of two overlapping nodes is on top.
+     *
+     * Insertion order is a function of the path a peer took, not of the state it arrived at:
+     *
+     *     Alice deletes node `a` and undoes → `a` is re-inserted, so it moves to the END.
+     *     Bob receives the re-add BEFORE the delete → the delete is then refused as superseded,
+     *     Bob never removed anything, and `a` never moves.
+     *
+     * Same ops. Same content, field for field. Different `nodes` array. The two of them paint
+     * overlapping nodes in a different order and save byte-different files. The fuzz caught it on
+     * trial 2 and it would never have occurred to me.
+     *
+     * The fix is the same shape as everything else in this file: DERIVE the order from the
+     * converged state instead of inheriting it from the delivery path. An entity's rank is the
+     * stamp of the write that established its CURRENT INCARNATION. That is identical on every
+     * peer, and in the ordinary case (add a, add b, add c) it reproduces insertion order exactly,
+     * so nothing that was not already broken changes.
+     *
+     * Gated on `orderDirty`, because the sort is O(n) even when it changes nothing and adds
+     * normally arrive with ever-increasing clocks — see the field's comment.
+     */
+    canonicalizeIfDirty() {
+        if (!this.orderDirty)
+            return;
+        this.orderDirty = false;
+        this.order(this.diagram.nodes, 'node');
+        this.order(this.diagram.links, 'link');
+        this.order(this.diagram.groups, 'group');
+        // wave10/whiteboard: ink is ordered too. serialize() writes strokes in Map-insertion
+        // order and the renderer paints them in that order (later ink on top), so two peers that
+        // received the same stroke adds in a different order would paint and SAVE differently —
+        // the exact node/link bug this method exists to kill, now for a fourth collection.
+        this.order(this.diagram.strokes, 'stroke');
+    }
+    order(map, target) {
+        if (map.size < 2)
+            return;
+        const rank = (id) => this.lww.presenceOf(target, id);
+        const cmp = (a, b) => {
+            if (!a && !b)
+                return 0; // both predate the log — a stable sort keeps them put
+            if (!a)
+                return -1;
+            if (!b)
+                return 1;
+            if (a.clock !== b.clock)
+                return a.clock - b.clock;
+            return a.actor < b.actor ? -1 : a.actor > b.actor ? 1 : 0;
+        };
+        const entries = [...map.entries()];
+        entries.sort((a, b) => cmp(rank(a[0]), rank(b[0])));
+        map.clear();
+        for (const [k, v] of entries)
+            map.set(k, v);
+    }
+    /** Drop a link from quarantine for good — its presence register says it is gone. */
+    forget(op) {
+        if (op.op === 'remove' && op.target === 'link')
+            this.quarantine.delete(op.id);
+    }
+    // -------------------------------------------------------------------------
+    /** The node that owns a port, IF that node is currently in the document. */
+    ownerOf(portId) {
+        const nodeId = this.portOwner.get(portId);
+        if (nodeId === undefined)
+            return undefined;
+        return this.diagram.getNode(nodeId) ? nodeId : undefined;
+    }
+    endpointsResolve(link) {
+        return (this.ownerOf(link.sourcePortId) !== undefined && this.ownerOf(link.targetPortId) !== undefined);
+    }
+    /**
+     * Derive the cached endpoint node ids.
+     *
+     * Assigned directly, NOT through a mutator, and that is deliberate: these are DERIVED
+     * state, not authored state. A trackChange here would emit an op, broadcast a value every
+     * peer can compute for itself, and race with the ops it was derived from.
+     */
+    resolveEndpoints(link) {
+        const s = this.ownerOf(link.sourcePortId);
+        const t = this.ownerOf(link.targetPortId);
+        if (link.sourceNodeId !== s)
+            link.sourceNodeId = s;
+        if (link.targetNodeId !== t)
+            link.targetNodeId = t;
+    }
+}
+exports.ReferentialIntegrity = ReferentialIntegrity;
+//# sourceMappingURL=integrity.js.map

package/src/libs/engine/src/collab/integrity.js.map

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