@grafloria/element 0.3.18 → 0.3.19

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

@@ -0,0 +1,510 @@
+"use strict";
+// Wave 9 — Card 0: turning real edits into ops.
+//
+// THIS FILE IS THE ONE THAT MATTERS, and it is the one the roadmap did not ask for.
+//
+// It would be very easy to ship Card 0 as: an Op type, a LamportClock, an applyOp()
+// reducer, a replay() function, and a suite of tests that hand-construct ops and
+// replay them. Everything green. Everything documented. And the log would be fed by
+// NOTHING — an op format that no actual edit ever produces.
+//
+// That is precisely the bug this engine has shipped in every wave: `setLayoutService()`
+// that nothing called, 17 LOD presets that were all a no-op, a worker stack whose tests
+// all forced `useWorker:false`, a quality governor (mine) wired to nothing, and — right
+// here in this capability — a `Command.serialize()` on every command with NO
+// DESERIALIZER ANYWHERE. Write-only. Green tests, zero reachability.
+//
+// So the capture layer exists, and the load-bearing test in this wave is not "ops
+// replay" — it is: DRIVE THE REAL ENGINE WITH REAL EDITS, CAPTURE, REPLAY INTO AN EMPTY
+// DIAGRAM, AND DEMAND BYTE-IDENTICAL serialize(). That is the only test that can tell
+// you the log is COMPLETE (nothing an edit does is missed), REPLAYABLE, and
+// DETERMINISTIC — and no amount of hand-written ops can substitute for it.
+//
+// ---------------------------------------------------------------------------
+// HOW
+// ---------------------------------------------------------------------------
+// `DiagramEntity.trackChange(property, old, new)` is the SINGLE funnel every mutation
+// in this engine passes through (it is what powers dirty-tracking, versioning and the
+// change events). It emits `change` with the property name — and, beautifully, the
+// vocabulary it already speaks is exactly the vocabulary an op path needs:
+// 'position', 'size', 'state', 'style', 'points', 'metadata.<key>'. The diagram itself
+// emits trackChange('nodes'|'links'|'groups', old, new) for add/remove.
+//
+// So capture is a listener on that funnel. No parallel bookkeeping, no second source of
+// truth that can drift from the first.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpCapture = void 0;
+const tslib_1 = require("tslib");
+const NodeModel_1 = require("../models/NodeModel");
+const GroupModel_1 = require("../models/GroupModel");
+const op_1 = require("./op");
+/** Property names that are structural (add/remove), not property registers. */
+const STRUCTURAL = new Set(['nodes', 'links', 'groups', 'strokes']);
+/** The `trackChange` collection name → the op target it adds/removes. */
+const STRUCTURAL_TARGET = {
+    nodes: 'node',
+    links: 'link',
+    groups: 'group',
+    strokes: 'stroke',
+};
+/**
+ * Properties we do NOT put on the wire — SCOPED PER TARGET.
+ *
+ * `points` is a LINK's ROUTED geometry — it is DERIVED, recomputed by the renderer from
+ * the node positions and the router on every frame that needs it. Broadcasting it would
+ * (a) trade a 2-number node move for an N-point path on every drag frame, and (b) be
+ * actively wrong: the receiving peer recomputes the route anyway, so the transmitted
+ * points are overwritten milliseconds later. A collaboration engine must sync CAUSES,
+ * not their derived consequences.
+ *
+ * The exception is a link the user has hand-routed — those waypoints are authored
+ * intent, not derived geometry — and the model already distinguishes the two with the
+ * `hasManualWaypoints` metadata flag, which IS synced (it is a metadata.* register).
+ * So a manual reroute travels; an automatic one does not. That is the correct line, and
+ * it is the model's own line, not one invented here.
+ *
+ * wave10/whiteboard: `points` ON A STROKE IS THE OPPOSITE — it is the authored content
+ * itself, nothing derives it, and a global `DERIVED = {points}` would drop the one thing a
+ * stroke edit changes, so editing a stroke's geometry would silently never reach a peer.
+ * (StrokeModel.setPoints documents exactly this trap.) Hence per-target: `points` is
+ * derived for a link and authored for a stroke.
+ */
+const DERIVED_BY_TARGET = {
+    link: new Set(['points']),
+    diagram: new Set(['points']),
+};
+function isDerived(target, property) {
+    var _a, _b;
+    return (_b = (_a = DERIVED_BY_TARGET[target]) === null || _a === void 0 ? void 0 : _a.has(property)) !== null && _b !== void 0 ? _b : false;
+}
+/**
+ * ---------------------------------------------------------------------------
+ * EPHEMERAL VIEWER STATE — THE BUG THIS SET EXISTS TO CLOSE
+ * ---------------------------------------------------------------------------
+ *
+ * `NodeState` mixes two completely different kinds of fact in one object:
+ *
+ *     DURABLE (about the DOCUMENT):  visible, locked, expanded, enabled, error, status
+ *     EPHEMERAL (about a VIEWER):    selected, hovered, highlighted, focused
+ *
+ * …and this capture layer used to sync the whole object as a single register. The
+ * consequences, found by wave9/sync driving a real two-peer session:
+ *
+ *   • MOVING YOUR MOUSE ACROSS A NODE WROTE TWO PERMANENT OPS INTO THE SHARED DOCUMENT
+ *     (hover on, hover off) — and the peer APPLIED them, so a node lit up on my screen
+ *     because your cursor was somewhere near it.
+ *   • YOUR CLICK DESELECTED MY NODE. Selection is not a property of the diagram; it is a
+ *     property of a person looking at it.
+ *   • And every one of those ops went into the replayable, persisted, totally-ordered log
+ *     FOREVER. A five-minute session would bury the actual edit history under thousands
+ *     of hover events.
+ *
+ * `LinkModel.state` is worse still: its ONLY values are 'default' | 'selected' | 'hovered'
+ * | 'highlighted'. It is ephemeral in its entirety, so a link's state is never synced at
+ * all.
+ *
+ * This is the same distinction wave9/comments drew for read-markers ("Ada read this" is a
+ * fact about Ada, not about the document) and the same one that keeps live cursors out of
+ * the op log. Presence belongs on the awareness channel — ephemeral, per-peer, expiring —
+ * and NEVER in the document.
+ */
+const EPHEMERAL_NODE_STATE = new Set(['selected', 'hovered', 'highlighted', 'focused']);
+/** A link's `state` is view state, top to bottom. Never synced. */
+const EPHEMERAL_BY_TARGET = {
+    link: new Set(['state']),
+};
+/** Strip the viewer-local keys out of a node/group `state` object. */
+function durableState(value) {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (!EPHEMERAL_NODE_STATE.has(k))
+            out[k] = v;
+    }
+    return out;
+}
+/** Structural equality, so a hover that changes nothing durable emits nothing. */
+function sameJson(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+/**
+ * A port as it travels: the serialized form MINUS `version`.
+ *
+ * `version` is a per-replica mutation counter — a local quantity, like a vector-clock
+ * component; the convergence oracle already exempts it for exactly that reason. Keeping
+ * it in the register value would also defeat the coarse-per-port dedupe below: every
+ * derived-state twitch (a link registering a connection bumps the port's version and
+ * nothing else) would look like a fresh register value and go on the wire.
+ */
+function portWireValue(port) {
+    const _a = port.serialize(), { version: _version } = _a, data = tslib_1.__rest(_a, ["version"]);
+    return data;
+}
+/**
+ * Port properties that are DERIVED and must not re-emit the register.
+ *
+ * `connections` is rebuilt from the diagram's links on every peer (PortModel calls it
+ * derived state in so many words) — broadcasting it would race the link ops it is
+ * derived from. It is not in serialize() anyway; this skip just avoids doing the
+ * serialize-and-compare work on every link attach/detach.
+ */
+const PORT_DERIVED = new Set(['connections']);
+/**
+ * Watches a live diagram and emits an Op for every real edit.
+ *
+ * Re-entrancy: while `applyRemote()` is running, capture is SUPPRESSED. Without that,
+ * applying a peer's op would capture it as a local op and re-broadcast it, and the two
+ * peers would ping-pong the same edit forever, each amplifying the other. This is the
+ * single most important line in the file and it is three characters long.
+ */
+class OpCapture {
+    constructor(diagram, options) {
+        var _a;
+        this.diagram = diagram;
+        this.unsubs = [];
+        this.entitySubs = new Map();
+        /**
+         * nodeId → (portId → the register value last emitted/seen for that port).
+         *
+         * The per-port `before` shadow for undo. trackChange('ports', …) reports the ONE port
+         * that changed, and a port's own change events report one property — so the register's
+         * prior value has to be remembered here; there is nowhere else to read it from once
+         * the model has been mutated. Seeded from the node's existing ports at watch time, so
+         * `before` for a port's first change is its REAL prior state, not "empty" — the old
+         * whole-collection shadow got that wrong once and undo stripped a node of every port
+         * it was born with.
+         */
+        this.portShadows = new Map();
+        /** portId → unsubscribe for the live-port watch (Defect 2: port edits must sync). */
+        this.portSubs = new Map();
+        /**
+         * groupId → the member collection last emitted for that group.
+         *
+         * The same shadow trick as `portShadows`, for the same reason and against a worse bug.
+         * `GroupModel.addMember` reports the funnel change as trackChange('members', null,
+         * <the one id that joined>) — a DELTA, where every other register in this engine
+         * reports the property's VALUE. Emitted verbatim, that put the bare string 'node-1' on
+         * the wire as the whole `members` register (and a bare `null` for a removal), which the
+         * receiving peer wrote straight over its Set. See apply-op.ts for what that did to
+         * serialize().
+         *
+         * So the value is read off the live Set instead — trackChange fires AFTER the mutation,
+         * so the Set is already the post-state — and the shadow supplies `before`. It has to:
+         * `before` for a removal is the collection WITH the member back IN ITS ORIGINAL
+         * POSITION, and a Set that has had an element deleted cannot reproduce that (re-adding
+         * appends). Undo restores `before`, and order is in serialize(), so a reconstructed one
+         * would make undo save a byte-different document.
+         */
+        this.memberShadows = new Map();
+        /** True while we are applying a REMOTE op: everything the model emits is an echo. */
+        this.applying = false;
+        this.stopped = false;
+        this.clock = new op_1.LamportClock(options.actor, (_a = options.startClock) !== null && _a !== void 0 ? _a : 0);
+        this.onOp = options.onOp;
+        this.watchDiagram();
+        // Entities that already exist when capture starts still need watching — a diagram
+        // is rarely empty at the moment you decide to start collaborating on it.
+        for (const n of diagram.getNodes())
+            this.watchEntity('node', n);
+        for (const l of diagram.getLinks())
+            this.watchEntity('link', l);
+        for (const g of diagram.getGroups())
+            this.watchEntity('group', g);
+        for (const s of diagram.getStrokes())
+            this.watchEntity('stroke', s);
+    }
+    /** The Lamport clock this capture issues from — shared with the sync layer. */
+    get lamport() {
+        return this.clock;
+    }
+    /**
+     * Apply remote ops WITHOUT capturing them as local edits.
+     *
+     * The clock observes each remote op first, so any op we issue after this sorts after
+     * theirs. That is what makes the resulting order respect causality between peers and
+     * not merely within one.
+     */
+    applyRemote(ops, apply) {
+        this.silently(() => {
+            for (const op of ops) {
+                this.clock.observe(op.clock);
+                apply(op);
+            }
+        });
+    }
+    /**
+     * Run `fn` with capture SUPPRESSED — the model mutations it makes emit no ops.
+     *
+     * For work that is DERIVED rather than authored: referential integrity moving an
+     * orphaned link out of the document and back again is a function of state that every
+     * peer computes for itself, so broadcasting it would put a redundant op on the wire that
+     * races with the ops it was derived from. Deriving it locally is not just cheaper, it is
+     * the only thing that converges.
+     *
+     * Re-entrant: nesting must not clear the flag early (integrity reconciles INSIDE
+     * applyRemote), or a remote op's mutations would start echoing back mid-batch.
+     */
+    silently(fn) {
+        const was = this.applying;
+        this.applying = true;
+        try {
+            fn();
+        }
+        finally {
+            // finally, not a trailing assignment: if fn() throws, a stuck `applying` flag would
+            // silently disable capture for the rest of the session — every subsequent local edit
+            // lost, with no error anywhere.
+            this.applying = was;
+        }
+    }
+    stop() {
+        this.stopped = true;
+        for (const u of this.unsubs)
+            u();
+        for (const u of this.entitySubs.values())
+            u();
+        for (const u of this.portSubs.values())
+            u();
+        this.unsubs.length = 0;
+        this.entitySubs.clear();
+        this.portSubs.clear();
+        this.portShadows.clear();
+        this.memberShadows.clear();
+    }
+    // -------------------------------------------------------------------------
+    emit(op, before) {
+        if (this.applying || this.stopped)
+            return;
+        this.onOp(Object.assign(Object.assign({}, op), { clock: this.clock.tick(), actor: this.clock.actorId }), before);
+    }
+    /**
+     * A `set` draft, with clears made EXPLICIT (Defect 3).
+     *
+     * `undefined` is what the model funnel hands us when a register is being EMPTIED
+     * (deleteMetadata, clearFlexItem) — and `OpValue` forbids it. The old code emitted it
+     * anyway; it crossed the wire only because JSON.stringify drops an undefined key and
+     * the peer's apply read missing-as-undefined. Two accidents, both load-bearing. Now a
+     * clear says so: `clear: true`, no value key, JSON-exact round-trip. (NOT null — null
+     * is a legitimate stored value, and the suite proves the two stay distinct.)
+     */
+    setDraft(target, id, path, value) {
+        return value === undefined
+            ? { op: 'set', target, id, path, clear: true }
+            : { op: 'set', target, id, path, value };
+    }
+    watchDiagram() {
+        const onChange = (entry) => {
+            const { property, oldValue, newValue } = entry;
+            if (STRUCTURAL.has(property)) {
+                // trackChange('nodes', null, node) = add · trackChange('nodes', node, null) = remove
+                const target = STRUCTURAL_TARGET[property];
+                if (newValue && !oldValue) {
+                    const e = newValue;
+                    this.emit({ op: 'add', target, id: e.id, data: e.serialize() }, { kind: 'none' });
+                    this.watchEntity(target, e);
+                }
+                else if (oldValue && !newValue) {
+                    // The entity's FULL STATE at the moment it was removed — the only thing that can
+                    // undo a delete. (deepClone hands class instances through untouched, so this is
+                    // the live model, and serialize() on it is exact rather than a stale snapshot.)
+                    const e = oldValue;
+                    this.emit({ op: 'remove', target, id: e.id }, { kind: 'entity', data: e.serialize() });
+                    this.unwatchEntity(e.id);
+                }
+                return;
+            }
+            // A property of the diagram itself (name, viewport, …).
+            if (!isDerived('diagram', property)) {
+                this.emit(this.setDraft('diagram', '', property, newValue), { kind: 'value', value: oldValue });
+            }
+        };
+        // on() hands back its own unsubscriber — no need to reconstruct the handler identity
+        this.unsubs.push(this.diagram.on('change', onChange));
+    }
+    watchEntity(target, entity) {
+        if (this.entitySubs.has(entity.id))
+            return;
+        // SEED the per-port shadows with what the node ALREADY has, and WATCH each port.
+        //
+        // The seed: without it, `before` for a port's first change is undefined — and undo
+        // reads that as "the register was empty", so undoing the first edit to a port the
+        // node was born with would DELETE that port. (The whole-collection ancestor of this
+        // bug once stripped a node of every port it had; the fuzz found it as a node with an
+        // empty ports array on one peer.)
+        //
+        // The watch is Defect 2's fix: PortModel is a DiagramEntity with trackChange calls of
+        // its own (position, alignment, offset, allowedTypes) that no one was listening to —
+        // editing a LIVE port silently never synced.
+        if (entity instanceof NodeModel_1.NodeModel) {
+            const shadows = new Map();
+            this.portShadows.set(entity.id, shadows);
+            for (const p of entity.getPorts()) {
+                shadows.set(p.id, portWireValue(p));
+                this.watchPort(entity, p);
+            }
+        }
+        // SEED the member shadow with what the group ALREADY has, for the same reason the
+        // port shadows are seeded: `before` for a group's first membership change must be its
+        // REAL prior collection, not "empty" — or undoing the first add would strip the group
+        // of every member it was born with.
+        if (entity instanceof GroupModel_1.GroupModel) {
+            this.memberShadows.set(entity.id, [...entity.members]);
+        }
+        const onChange = (entry) => {
+            var _a, _b;
+            // Per-target: a LINK's `points` is derived and dropped; a STROKE's `points` is the
+            // authored content and must travel. See DERIVED_BY_TARGET.
+            if (isDerived(target, entry.property))
+                return;
+            // Wholly-ephemeral registers never reach the wire at all. A link's `state` is
+            // 'default' | 'selected' | 'hovered' | 'highlighted' — view state, top to bottom.
+            if ((_a = EPHEMERAL_BY_TARGET[target]) === null || _a === void 0 ? void 0 : _a.has(entry.property))
+                return;
+            // PORTS: ONE REGISTER PER PORT — `ports.<portId>` — because the whole-collection
+            // register this used to be was Card 0's rejected design smuggled back in one level
+            // down. Two peers concurrently adding a DIFFERENT port to the same node raced one
+            // register; one collection write superseded the other, and the reconciling apply
+            // branch DELETED the losing port from its creator's own node — orphaning every
+            // link already attached to it. The user watched their work vanish, silently.
+            //
+            // The path IS the register key (op.ts), so per-port needs no new op kind: an
+            // add/update is `set(node, 'ports.<id>', <serialized port>)` and a remove is the
+            // explicit clear of that register. COARSE per-port, deliberately: the value is the
+            // whole serialized port, never `ports.<id>.position` sub-registers — the register
+            // keyspace stays prefix-free (the comments-suite lesson), and a port is small.
+            //
+            // NodeModel.addPort() emits trackChange('ports', null, <the live PortModel>) and
+            // deepClone hands class instances through untouched — so entry.newValue here IS the
+            // port, and it must be SERIALIZED before it can be a value (a live instance on the
+            // wire is how the original Map-corruption bug happened; see apply-op.ts, which
+            // still refuses to write ports except through the real addPort/removePort).
+            if (entry.property === 'ports' && entity instanceof NodeModel_1.NodeModel) {
+                const shadows = this.portShadows.get(entity.id);
+                if (entry.newValue && !entry.oldValue) {
+                    // add — watch it (bookkeeping runs even while applying a REMOTE op, exactly
+                    // like watchEntity below: only EMISSION is suppressed, or a remotely-added
+                    // port would be invisible to capture for the rest of the session)
+                    const port = entry.newValue;
+                    const now = portWireValue(port);
+                    const was = shadows === null || shadows === void 0 ? void 0 : shadows.get(port.id);
+                    shadows === null || shadows === void 0 ? void 0 : shadows.set(port.id, now);
+                    this.watchPort(entity, port);
+                    this.emit(this.setDraft(target, entity.id, `ports.${port.id}`, now), { kind: 'value', value: was });
+                }
+                else if (entry.oldValue && !entry.newValue) {
+                    // remove — the clear of exactly one register, with the port's last state as
+                    // `before` so undo restores exactly one port
+                    const port = entry.oldValue;
+                    const was = (_b = shadows === null || shadows === void 0 ? void 0 : shadows.get(port.id)) !== null && _b !== void 0 ? _b : portWireValue(port);
+                    shadows === null || shadows === void 0 ? void 0 : shadows.delete(port.id);
+                    this.unwatchPort(port.id);
+                    this.emit(this.setDraft(target, entity.id, `ports.${port.id}`, undefined), { kind: 'value', value: was });
+                }
+                return;
+            }
+            // MEMBERS: the register value is THE WHOLE COLLECTION, never the delta the funnel
+            // reports. GroupModel.addMember/removeMember call trackChange('members', null, id)
+            // and ('members', id, null) — they name the member that MOVED, not the value the
+            // register now holds, which makes `members` the one register in the engine whose
+            // funnel payload is not its value. Emitting it verbatim shipped a bare id string
+            // (and a bare null) as the whole Set; see memberShadows and apply-op.ts.
+            //
+            // Read off the live Set — trackChange fires after the mutation, so it is the
+            // post-state — and take `before` from the shadow, which is the only thing that
+            // remembers the collection's ORDER before a delete.
+            if (entry.property === 'members' && entity instanceof GroupModel_1.GroupModel) {
+                const now = [...entity.members];
+                const was = this.memberShadows.get(entity.id);
+                // A membership change that changes nothing emits nothing: re-adding a member the
+                // group already has is a no-op in the model, and it must be one on the wire too.
+                if (sameJson(now, was))
+                    return;
+                this.memberShadows.set(entity.id, now);
+                this.emit(this.setDraft(target, entity.id, 'members', now), { kind: 'value', value: was });
+                return;
+            }
+            let value = entry.newValue;
+            let before = entry.oldValue;
+            if (entry.property === 'state') {
+                // `state` is a MIXED register: durable document facts (visible, locked, expanded)
+                // sitting in the same object as per-viewer ephemera (selected, hovered, focused).
+                // Project BOTH sides — and emit NOTHING when only the ephemera moved.
+                //
+                // Without the second half of that, hovering a node still puts an op on the wire and
+                // in the permanent log on every mouse-over. The receiver's redundant-write guard
+                // would drop it, so the DOCUMENT would look correct and the bug would be invisible
+                // to every convergence test — while the log filled with hover events that outlive
+                // the session. (Found by wave9/sync, in two real browser tabs. jsdom does not hover.)
+                //
+                // `before` is projected TOO, and that is not symmetry for its own sake: undo
+                // restores `before`, so an unprojected one would put the undoing user's stale
+                // selection back onto every peer's screen — reintroducing the very bug through the
+                // undo path.
+                const next = durableState(entry.newValue);
+                const prev = durableState(entry.oldValue);
+                if (sameJson(next, prev))
+                    return;
+                value = next;
+                before = prev;
+            }
+            this.emit(this.setDraft(target, entity.id, entry.property, value), { kind: 'value', value: before });
+        };
+        this.entitySubs.set(entity.id, entity.on('change', onChange));
+    }
+    /**
+     * Watch ONE live port (Defect 2).
+     *
+     * Any real change re-emits the port's whole serialized form to its `ports.<id>`
+     * register — coarse-per-port. The wire-value dedupe below is what keeps derived
+     * twitches (a link registering a connection bumps `version` and nothing else) off
+     * the wire: if the register value did not change, nothing is emitted.
+     *
+     * Attached on every path a port can reach a live diagram by: capture attach,
+     * node add (watchEntity seeds and watches), port add (the ports branch above).
+     * Detached on port remove, node remove and stop().
+     */
+    watchPort(node, port) {
+        if (this.portSubs.has(port.id))
+            return;
+        const onPortChange = (entry) => {
+            if (PORT_DERIVED.has(entry.property))
+                return;
+            const shadows = this.portShadows.get(node.id);
+            const now = portWireValue(port);
+            const was = shadows === null || shadows === void 0 ? void 0 : shadows.get(port.id);
+            if (sameJson(now, was))
+                return;
+            shadows === null || shadows === void 0 ? void 0 : shadows.set(port.id, now);
+            this.emit(this.setDraft('node', node.id, `ports.${port.id}`, now), { kind: 'value', value: was });
+        };
+        this.portSubs.set(port.id, port.on('change', onPortChange));
+    }
+    unwatchPort(portId) {
+        const un = this.portSubs.get(portId);
+        if (un) {
+            un();
+            this.portSubs.delete(portId);
+        }
+    }
+    unwatchEntity(id) {
+        const un = this.entitySubs.get(id);
+        if (un) {
+            un();
+            this.entitySubs.delete(id);
+        }
+        // A removed NODE takes its port watches with it — the shadows too, or a node
+        // deleted and re-added (resurrection) would inherit stale `before` values.
+        const shadows = this.portShadows.get(id);
+        if (shadows) {
+            for (const portId of shadows.keys())
+                this.unwatchPort(portId);
+            this.portShadows.delete(id);
+        }
+        // Same for a removed GROUP's member shadow: a group deleted and resurrected must not
+        // inherit the membership its previous incarnation had.
+        this.memberShadows.delete(id);
+    }
+}
+exports.OpCapture = OpCapture;
+//# sourceMappingURL=capture.js.map

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

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

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

@@ -0,0 +1,12 @@
+export { LamportClock, compareOps, opId } from './op';
+export type { ActorId, Op, AddOp, RemoveOp, SetOp, OpPath, OpTarget, OpValue } from './op';
+export { applyOp, applyEntitySet, OpApplyError } from './apply-op';
+export { OpLog, replay } from './op-log';
+export { OpCapture } from './capture';
+export type { OpCaptureOptions, OpBefore } from './capture';
+export { Replica } from './replica';
+export type { ReplicaOptions } from './replica';
+export { LwwRegistry } from './lww';
+export type { Stamp } from './lww';
+export { ReferentialIntegrity } from './integrity';
+export { UndoStack } from './undo';

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

@@ -0,0 +1,84 @@
+"use strict";
+// Wave 9 (Collaboration) — Card 0: the operation substrate.
+//
+// The op log is the thing every other collaboration card stands on: CRDT convergence
+// (Card 4), the sync transport (Card 5), anchored comments (Card 6) and presentation
+// mode (Card 7) all consume it. It exists because the engine's TWO existing candidates
+// could not do the job:
+//
+//   • Command.serialize() is WRITE-ONLY — there is no deserializer anywhere in the tree.
+//   • DiagramIncremental is a WHOLE-ENTITY diff — so a concurrent move and rename of the
+//     same node silently throws one of them away.
+//
+// Ops are per-PROPERTY, carry a Lamport clock (causality, not wall time), sort into a
+// total order identical on every peer, and are captured from `trackChange` — the single
+// funnel every mutation in this engine already passes through.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndoStack = exports.ReferentialIntegrity = exports.LwwRegistry = exports.Replica = exports.OpCapture = exports.replay = exports.OpLog = exports.OpApplyError = exports.applyEntitySet = exports.applyOp = exports.opId = exports.compareOps = exports.LamportClock = void 0;
+var op_1 = require("./op");
+Object.defineProperty(exports, "LamportClock", { enumerable: true, get: function () { return op_1.LamportClock; } });
+Object.defineProperty(exports, "compareOps", { enumerable: true, get: function () { return op_1.compareOps; } });
+Object.defineProperty(exports, "opId", { enumerable: true, get: function () { return op_1.opId; } });
+var apply_op_1 = require("./apply-op");
+Object.defineProperty(exports, "applyOp", { enumerable: true, get: function () { return apply_op_1.applyOp; } });
+Object.defineProperty(exports, "applyEntitySet", { enumerable: true, get: function () { return apply_op_1.applyEntitySet; } });
+Object.defineProperty(exports, "OpApplyError", { enumerable: true, get: function () { return apply_op_1.OpApplyError; } });
+var op_log_1 = require("./op-log");
+Object.defineProperty(exports, "OpLog", { enumerable: true, get: function () { return op_log_1.OpLog; } });
+Object.defineProperty(exports, "replay", { enumerable: true, get: function () { return op_log_1.replay; } });
+var capture_1 = require("./capture");
+Object.defineProperty(exports, "OpCapture", { enumerable: true, get: function () { return capture_1.OpCapture; } });
+var replica_1 = require("./replica");
+Object.defineProperty(exports, "Replica", { enumerable: true, get: function () { return replica_1.Replica; } });
+var lww_1 = require("./lww");
+Object.defineProperty(exports, "LwwRegistry", { enumerable: true, get: function () { return lww_1.LwwRegistry; } });
+// Card 4. The one invariant a diagram cannot survive breaking, and the undo that knows it
+// is not alone in the room.
+var integrity_1 = require("./integrity");
+Object.defineProperty(exports, "ReferentialIntegrity", { enumerable: true, get: function () { return integrity_1.ReferentialIntegrity; } });
+var undo_1 = require("./undo");
+Object.defineProperty(exports, "UndoStack", { enumerable: true, get: function () { return undo_1.UndoStack; } });
+// ===========================================================================
+// THERE IS NO YJS BINDING, AND THIS IS WHERE YOU WOULD HAVE LOOKED FOR IT
+// ===========================================================================
+//
+// Card 4 asked for "an optional binding to Yjs for teams already standardized on it". It was
+// not built. The reasoning, so that nobody has to reconstruct it:
+//
+// WHAT WOULD IT BUY? Not convergence — we have that. Yjs's Y.Map is a per-key LWW register
+// map, which is exactly, precisely what `LwwRegistry` already is. Adopting Yjs would replace
+// the one part of this system that was already correct, small, and free.
+//
+// The honest answer is INTEROP: a team with a running y-websocket server, y-indexeddb for
+// offline, and y-protocols/awareness for presence could point them at this engine. That is a
+// real thing to want. It is also a TRANSPORT concern, and this engine is already transport-
+// agnostic: a Replica needs nothing but something that can move an array of JSON ops
+// (`onLocalOp` out, `receive()` in). Wave 9's sync card is building exactly that seam. A Yjs
+// binding would not open a door that is already open.
+//
+// AND IT WOULD PUNCH A HOLE. Everything this card actually spent its time on lives ABOVE the
+// register layer, and the mutation matrix proves each piece is load-bearing:
+//
+//     • referential integrity  (a link whose endpoint node is gone must not survive)
+//     • the presence barrier   (a write older than an entity's incarnation is void)
+//     • repair-from-log        (an `add` must not clobber writes newer than itself)
+//     • canonical entity order (Map insertion order is paint order, and it must converge)
+//     • supersession-aware undo
+//
+// Yjs supplies NONE of them. A peer merging through a Y.Doc would hold dangling links,
+// diverge on resurrection, and paint overlapping nodes in a different order — while believing
+// it had converged, because at the register level it HAD. So the binding is either a second,
+// weaker convergence path (a correctness hole, and the worst kind: silent), or it is all five
+// mechanisms re-implemented on top of Y.Doc observers — at which point Yjs is contributing a
+// wire format, in exchange for a hard dependency and a mapping layer to keep in step forever.
+//
+// The one thing Yjs would genuinely add is Y.Text: character-level merge of two people typing
+// in the same node label, where we take last-writer-wins. That is a real gap and it is a
+// SMALL one — a diagram label is a few words, every diagram tool on the market does LWW on it,
+// and if we ever want it, the answer is a text CRDT on that one register, not a document model
+// swap.
+//
+// So: not built. Last wave an agent built a canvas tier, measured it at 8.9× slower than what
+// we had, and deleted its own card; that was the best result of the wave. A roadmap sentence
+// is not a reason.
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../engine/src/collab/index.ts"],"names":[],"mappings":";AAAA,4DAA4D;AAC5D,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,uFAAuF;AACvF,wBAAwB;AACxB,EAAE;AACF,yFAAyF;AACzF,yFAAyF;AACzF,kDAAkD;AAClD,EAAE;AACF,sFAAsF;AACtF,wFAAwF;AACxF,+DAA+D;;;AAE/D,2BAAsD;AAA7C,kGAAA,YAAY,OAAA;AAAE,gGAAA,UAAU,OAAA;AAAE,0FAAA,IAAI,OAAA;AAGvC,uCAAmE;AAA1D,mGAAA,OAAO,OAAA;AAAE,0GAAA,cAAc,OAAA;AAAE,wGAAA,YAAY,OAAA;AAC9C,mCAAyC;AAAhC,+FAAA,KAAK,OAAA;AAAE,gGAAA,MAAM,OAAA;AACtB,qCAAsC;AAA7B,oGAAA,SAAS,OAAA;AAGlB,qCAAoC;AAA3B,kGAAA,OAAO,OAAA;AAEhB,6BAAoC;AAA3B,kGAAA,WAAW,OAAA;AAGpB,0FAA0F;AAC1F,4BAA4B;AAC5B,yCAAmD;AAA1C,iHAAA,oBAAoB,OAAA;AAC7B,+BAAmC;AAA1B,iGAAA,SAAS,OAAA;AAElB,8EAA8E;AAC9E,0EAA0E;AAC1E,8EAA8E;AAC9E,EAAE;AACF,6FAA6F;AAC7F,kEAAkE;AAClE,EAAE;AACF,2FAA2F;AAC3F,6FAA6F;AAC7F,yEAAyE;AACzE,EAAE;AACF,0FAA0F;AAC1F,6FAA6F;AAC7F,4FAA4F;AAC5F,qFAAqF;AACrF,6FAA6F;AAC7F,sDAAsD;AACtD,EAAE;AACF,6FAA6F;AAC7F,6EAA6E;AAC7E,EAAE;AACF,qFAAqF;AACrF,oFAAoF;AACpF,oFAAoF;AACpF,0FAA0F;AAC1F,gCAAgC;AAChC,EAAE;AACF,uFAAuF;AACvF,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,EAAE;AACF,8FAA8F;AAC9F,yFAAyF;AACzF,+FAA+F;AAC/F,+FAA+F;AAC/F,QAAQ;AACR,EAAE;AACF,8FAA8F;AAC9F,6FAA6F;AAC7F,mBAAmB"}