@grafloria/element 0.3.17 → 0.3.19

package/src/libs/engine/src/comments/comment-store.js

@@ -0,0 +1,538 @@
+"use strict";
+// Wave 9 — Card 6: the comment store.
+//
+// A VIEW over `diagram.comments`, not a second copy of it. The store owns no thread
+// state; every read walks the register tree on the model and every write goes through
+// `diagram.writeCommentRegister()`, which is the model's change funnel, which is what
+// OpCapture listens to, which is what mints the op. One source of truth, and the path
+// from "user pressed Enter" to "op on the wire" has no branch in it that could be
+// forgotten.
+//
+// The store holds exactly two things that are NOT document data, and both are honest
+// about it:
+//   • `readState` — what THIS viewer has read. Per-person, never synced (read-state.ts).
+//   • `lastKnownPoint` — where each thread's target was the last time this peer saw it
+//     alive. A pure cache, described where it is used.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentStore = void 0;
+const mentions_1 = require("./mentions");
+const read_state_1 = require("./read-state");
+const types_1 = require("./types");
+class CommentStore {
+    constructor(diagram, options) {
+        var _a, _b;
+        this.diagram = diagram;
+        /**
+         * WHERE THE TARGET WAS, LAST TIME WE SAW IT ALIVE.
+         *
+         * The anchor carries a `fallback` point captured when the thread was CREATED. If the
+         * node then gets dragged across the canvas and only afterwards deleted, that fallback
+         * is stale by however far it moved, and the ghost pin would appear somewhere the node
+         * has not been for an hour — which is worse than useless, it is misleading.
+         *
+         * The fix must not cost traffic: broadcasting the node's position into the anchor on
+         * every drag frame would sync DERIVED geometry, which is exactly what capture.ts
+         * refuses to do and for exactly the right reasons. So each peer simply REMEMBERS,
+         * locally, where it last saw the target. Free, precise, and not one byte on the wire.
+         *
+         * A peer that joined after the delete never saw it and falls back to the op-borne
+         * snapshot. That peer's ghost pin is a little stale. It is also the only thing anyone
+         * could possibly know, so it is the right answer.
+         */
+        this.lastKnownPoint = new Map();
+        /** Message ids this store has already dispatched mention events for. */
+        this.notified = new Set();
+        this.subs = new Set();
+        this.unsubscribe = null;
+        this.counter = 0;
+        this.opts = options;
+        this.readState = (_a = options.readState) !== null && _a !== void 0 ? _a : new read_state_1.ReadState(options.viewer);
+        // Anything already in the document was written before this store existed. It is
+        // history, not news: seed the notified set so loading a file with 400 old @mentions
+        // does not fire 400 notifications at the person who opened it.
+        for (const [tid, t] of Object.entries(this.tree())) {
+            for (const mid of Object.keys((_b = t.messages) !== null && _b !== void 0 ? _b : {}))
+                this.notified.add((0, mentions_1.mentionKey)(tid, mid));
+        }
+        this.unsubscribe = this.diagram.on('change', ((entry) => {
+            if (entry.property !== 'comments' && !entry.property.startsWith('comments.'))
+                return;
+            this.onCommentsChanged();
+        }));
+    }
+    // ==========================================================================
+    // AUTHORING — every one of these ends in exactly one register write per fact.
+    // ==========================================================================
+    /**
+     * Start a thread. Three ops: head, anchor, first message.
+     *
+     * Three and not one, because `comments.<tid>` and `comments.<tid>.status` would be
+     * OVERLAPPING registers — LWW cannot order two writes to different paths, so a
+     * whole-thread write that arrived late would silently wipe a resolve. Prefix-free
+     * leaves are the price of correctness under out-of-order delivery, and the fuzz test
+     * asserts prefix-freedom rather than trusting me to remember it.
+     */
+    createThread(spec, body) {
+        const tid = this.mintId('t');
+        const at = this.now();
+        this.diagram.writeCommentRegister(`${tid}.head`, {
+            id: tid,
+            author: this.opts.viewer,
+            createdAt: at,
+        });
+        this.diagram.writeCommentRegister(`${tid}.anchor`, this.buildAnchor(spec));
+        this.writeMessage(tid, this.mintId('m'), body, at);
+        return tid;
+    }
+    /** Add a message. ONE register — which is why a colleague's simultaneous reply lives. */
+    reply(threadId, body) {
+        const mid = this.mintId('m');
+        this.writeMessage(threadId, mid, body, this.now());
+        return mid;
+    }
+    /**
+     * Edit a message: rewrite its register whole.
+     *
+     * Two people editing the same message concurrently is a genuine conflict on one
+     * register and LWW picks one, deterministically, on every peer. That is the right
+     * answer — an edit IS a whole-body replacement, so there is no finer cut that would
+     * have saved both, and merging two rewrites of one sentence produces a sentence
+     * neither person wrote.
+     */
+    editMessage(threadId, messageId, body) {
+        const existing = this.message(threadId, messageId);
+        if (!existing || existing.deleted)
+            return false;
+        const mentions = (0, mentions_1.mentionIds)(body);
+        const next = {
+            id: existing.id,
+            author: existing.author,
+            body,
+            createdAt: existing.createdAt,
+            editedAt: this.now(),
+        };
+        if (mentions.length)
+            next.mentions = mentions;
+        return this.diagram.writeCommentRegister(`${threadId}.messages.${messageId}`, next);
+    }
+    /**
+     * Delete a message — TOMBSTONE, never key removal.
+     *
+     * Removing the key would let a concurrent edit of the same message resurrect it from
+     * the dead (the edit's register write auto-creates the path again), and it would shift
+     * the ordering of the surviving messages on a peer that has not yet seen the delete.
+     * A tombstone keeps the author and the timestamp, so the conversation still reads in
+     * the order it happened, with a hole where somebody withdrew something — which is what
+     * actually occurred.
+     */
+    deleteMessage(threadId, messageId) {
+        const existing = this.message(threadId, messageId);
+        if (!existing || existing.deleted)
+            return false;
+        const tomb = {
+            id: existing.id,
+            author: existing.author,
+            body: '',
+            createdAt: existing.createdAt,
+            deleted: true,
+        };
+        return this.diagram.writeCommentRegister(`${threadId}.messages.${messageId}`, tomb);
+    }
+    resolve(threadId) {
+        return this.setStatus(threadId, true);
+    }
+    reopen(threadId) {
+        return this.setStatus(threadId, false);
+    }
+    /** Re-point a thread — the manual rescue for an orphan, and the only way to move one. */
+    reanchor(threadId, spec) {
+        if (!this.head(threadId))
+            return false;
+        this.lastKnownPoint.delete(threadId);
+        return this.diagram.writeCommentRegister(`${threadId}.anchor`, this.buildAnchor(spec));
+    }
+    setStatus(threadId, resolved) {
+        if (!this.head(threadId))
+            return false;
+        const status = {
+            resolved,
+            by: this.opts.viewer,
+            at: this.now(),
+        };
+        // Resolve/reopen is ONE register, so the flag and its attribution can never split —
+        // a thread that says "resolved" but not by whom is a thread nobody will reopen.
+        return this.diagram.writeCommentRegister(`${threadId}.status`, status);
+    }
+    writeMessage(threadId, messageId, body, at) {
+        const mentions = (0, mentions_1.mentionIds)(body);
+        const msg = {
+            id: messageId,
+            author: this.opts.viewer,
+            body,
+            createdAt: at,
+        };
+        if (mentions.length)
+            msg.mentions = mentions;
+        this.diagram.writeCommentRegister(`${threadId}.messages.${messageId}`, msg);
+    }
+    // ==========================================================================
+    // ANCHORING — the part the whole card lives or dies on.
+    // ==========================================================================
+    /** Snapshot the target's position and name INTO the anchor. Its obituary, written early. */
+    buildAnchor(spec) {
+        if (spec.kind === 'region') {
+            const a = { kind: 'region', x: spec.x, y: spec.y };
+            if (spec.width !== undefined)
+                a.width = spec.width;
+            if (spec.height !== undefined)
+                a.height = spec.height;
+            return a;
+        }
+        const live = this.livePoint(spec.kind, spec.id);
+        const anchor = {
+            kind: spec.kind,
+            id: spec.id,
+            fallback: live !== null && live !== void 0 ? live : { x: 0, y: 0 },
+        };
+        const label = this.labelOf(spec.kind, spec.id);
+        if (label)
+            anchor.targetLabel = label;
+        return anchor;
+    }
+    /**
+     * WHERE THE PIN GOES, AND WHETHER ITS SUBJECT STILL EXISTS.
+     *
+     * ===========================================================================
+     * WHAT HAPPENS TO A COMMENT WHEN SOMEBODY DELETES ITS NODE
+     * ===========================================================================
+     *
+     * It survives. It becomes ORPHANED — visibly detached, still readable, still
+     * replyable, still listed — and it never, under any circumstance, disappears.
+     *
+     * Argued from the user's side, because that is the only side that matters here. A
+     * thread is a conversation between PEOPLE. The node is merely what it was about. If
+     * Ben deletes a box and that silently destroys the eight-message design argument Ada
+     * and Chen had about it, then a routine edit has quietly deleted other people's work —
+     * work they cannot recover, cannot see was lost, and were never asked about. Worse, the
+     * comment is very often ABOUT the deletion ("why is this still here? we cut this in
+     * March") — so the delete would destroy precisely the discussion that authorised it.
+     * There is no version of that trade that is worth a tidier canvas.
+     *
+     * The inverse mistake is just as bad: keeping the pin attached to nothing, hovering at
+     * the coordinates of a box that is gone. That is a lie with a timestamp on it. So the
+     * orphan is DRAWN DIFFERENTLY, NAMED DIFFERENTLY ("detached"), and grouped separately
+     * in the panel. The user is told, in the place they are looking, exactly what happened.
+     *
+     * ===========================================================================
+     * AND WHY `attached` IS DERIVED RATHER THAN STORED — this is the subtle half
+     * ===========================================================================
+     *
+     * The obvious implementation writes an `orphaned: true` flag when the node dies. It is
+     * wrong three ways, and every one of them bites:
+     *
+     *   1. IT RACES. Marking a thread orphaned would be an OP, emitted by whichever peer
+     *      noticed the delete first. Two peers notice, two ops. Worse, the flag now merges
+     *      by LWW against a concurrent un-delete, and the flag can converge to a value that
+     *      contradicts the diagram it is meant to describe: `orphaned: true` on a thread
+     *      whose node is manifestly right there. Derived state cannot contradict its source.
+     *      Stored state can, and eventually will.
+     *   2. IT BREAKS UNDO. Ctrl-Z brings the node back. A stored flag would need a second
+     *      op to un-orphan the thread, from some peer that thought to look, and until then
+     *      the thread sits detached beside the node it is attached to. Derived, the thread
+     *      RE-ATTACHES on the very next read, with zero ops and zero code.
+     *   3. IT ASSUMES AN ANSWER THE CRDT CARD HAS NOT GIVEN YET. Card 4 is concurrently
+     *      deciding whether a remove beats a concurrent add, or whether an observed-remove
+     *      set lets the add survive. If they land on add-wins, a node this store had marked
+     *      dead comes back. Deriving the state means BOTH answers are already handled and
+     *      neither can be wrong: whatever the diagram says right now, the pin agrees with
+     *      it. That is the only way to be robust to a decision that has not been made.
+     *
+     * So: nothing is stored, nothing is broadcast, and `attached` is simply "is the entity
+     * in the diagram, right now". The thread survives the delete BY NOT DEPENDING ON THE
+     * ENTITY AT ALL.
+     */
+    resolveAnchor(threadId, anchor) {
+        var _a, _b, _c, _d;
+        if (anchor.kind === 'region') {
+            return {
+                point: { x: anchor.x, y: anchor.y },
+                attached: true, // a region is anchored to the canvas, and the canvas cannot be deleted
+                targetLabel: 'a region of the canvas',
+                targetKind: 'region',
+            };
+        }
+        const live = this.livePoint(anchor.kind, anchor.id);
+        if (live) {
+            // Alive. Remember where — this is the ONLY place the ghost position is learned,
+            // and it costs nothing because we already had to compute the pin's position.
+            this.lastKnownPoint.set(threadId, live);
+            return {
+                point: live,
+                attached: true,
+                targetLabel: (_b = (_a = this.labelOf(anchor.kind, anchor.id)) !== null && _a !== void 0 ? _a : anchor.targetLabel) !== null && _b !== void 0 ? _b : anchor.id,
+                targetKind: anchor.kind,
+                targetId: anchor.id,
+            };
+        }
+        return {
+            point: (_c = this.lastKnownPoint.get(threadId)) !== null && _c !== void 0 ? _c : anchor.fallback,
+            attached: false,
+            targetLabel: (_d = anchor.targetLabel) !== null && _d !== void 0 ? _d : anchor.id,
+            targetKind: anchor.kind,
+            targetId: anchor.id,
+        };
+    }
+    /** The live world point for an entity, or undefined if it is not in the diagram. */
+    livePoint(kind, id) {
+        if (kind === 'node') {
+            const node = this.diagram.getNode(id);
+            if (!node)
+                return undefined;
+            const box = node.getBoundingBox();
+            // Top-right corner: the conventional place for a pin, and the one least likely to
+            // sit on top of the node's own label.
+            return { x: box.right, y: box.top };
+        }
+        const link = this.diagram.getLink(id);
+        if (!link)
+            return undefined;
+        return this.linkMidpoint(link);
+    }
+    linkMidpoint(link) {
+        var _a, _b;
+        // Prefer the ROUTED points when the renderer has produced them — that is where the
+        // line actually is. Fall back to the midpoint of the endpoint nodes, which is where
+        // it will be once it is routed.
+        const pts = (_a = link.points) !== null && _a !== void 0 ? _a : [];
+        if (pts.length >= 2) {
+            const mid = pts[Math.floor(pts.length / 2)];
+            if (pts.length % 2 === 1)
+                return { x: mid.x, y: mid.y };
+            const a = pts[pts.length / 2 - 1];
+            return { x: (a.x + mid.x) / 2, y: (a.y + mid.y) / 2 };
+        }
+        const s = this.endpointCenter(link.sourceNodeId, link.sourcePortId);
+        const t = this.endpointCenter(link.targetNodeId, link.targetPortId);
+        if (s && t)
+            return { x: (s.x + t.x) / 2, y: (s.y + t.y) / 2 };
+        return (_b = s !== null && s !== void 0 ? s : t) !== null && _b !== void 0 ? _b : { x: 0, y: 0 };
+    }
+    endpointCenter(nodeId, portId) {
+        var _a;
+        const node = (_a = (nodeId ? this.diagram.getNode(nodeId) : undefined)) !== null && _a !== void 0 ? _a : (portId ? this.diagram.getNodeByPortId(portId) : undefined);
+        if (!node)
+            return undefined;
+        const box = node.getBoundingBox();
+        return { x: (box.left + box.right) / 2, y: (box.top + box.bottom) / 2 };
+    }
+    labelOf(kind, id) {
+        if (this.opts.labelOf)
+            return this.opts.labelOf(kind, id);
+        const entity = kind === 'node' ? this.diagram.getNode(id) : this.diagram.getLink(id);
+        if (!entity)
+            return undefined;
+        const label = entity.getMetadata('label');
+        if (typeof label === 'string' && label)
+            return label;
+        const type = entity.type;
+        return typeof type === 'string' && type ? type : id;
+    }
+    // ==========================================================================
+    // READING
+    // ==========================================================================
+    tree() {
+        var _a;
+        return (_a = this.diagram.comments) !== null && _a !== void 0 ? _a : {};
+    }
+    head(threadId) {
+        var _a;
+        return (_a = this.tree()[threadId]) === null || _a === void 0 ? void 0 : _a.head;
+    }
+    message(threadId, messageId) {
+        var _a, _b;
+        return (_b = (_a = this.tree()[threadId]) === null || _a === void 0 ? void 0 : _a.messages) === null || _b === void 0 ? void 0 : _b[messageId];
+    }
+    /**
+     * Assemble a thread for reading.
+     *
+     * INCOMPLETE THREADS ARE INVISIBLE, NOT BROKEN. A thread is three ops, and an
+     * unreliable transport is free to deliver the reply before the head that owns it — the
+     * substrate says so out loud (causal readiness is explicitly Card 4/5's, and until they
+     * ship it, `applyOp` will happily write `comments.t1.messages.m1` into a tree with no
+     * `t1.head`). A store that crashed on that would be broken by a packet reorder; a store
+     * that rendered a half-thread would show a message from nobody, about nothing. So a
+     * thread without a head or an anchor simply does not exist yet, and it appears — whole,
+     * with every message that arrived early already in it — the moment its head lands.
+     * Nothing is dropped; the pieces just wait.
+     */
+    thread(threadId) {
+        var _a, _b;
+        const stored = this.tree()[threadId];
+        if (!(stored === null || stored === void 0 ? void 0 : stored.head) || !stored.anchor)
+            return undefined;
+        const messages = Object.values((_a = stored.messages) !== null && _a !== void 0 ? _a : {})
+            .filter((m) => !!m && typeof m.id === 'string' && !!m.author)
+            .sort(types_1.messageOrder);
+        const status = stored.status;
+        const view = {
+            id: stored.head.id,
+            author: stored.head.author,
+            createdAt: stored.head.createdAt,
+            anchor: stored.anchor,
+            resolved: (_b = status === null || status === void 0 ? void 0 : status.resolved) !== null && _b !== void 0 ? _b : false,
+            messages,
+            unread: this.readState.unreadCount(threadId, messages),
+            resolvedAnchor: this.resolveAnchor(threadId, stored.anchor),
+        };
+        if (status === null || status === void 0 ? void 0 : status.resolved) {
+            view.resolvedBy = status.by;
+            view.resolvedAt = status.at;
+        }
+        return view;
+    }
+    /** Every readable thread, in a stable order identical on every peer. */
+    threads(options) {
+        var _a;
+        const includeResolved = (_a = options === null || options === void 0 ? void 0 : options.includeResolved) !== null && _a !== void 0 ? _a : true;
+        const out = [];
+        for (const tid of Object.keys(this.tree())) {
+            const t = this.thread(tid);
+            if (!t)
+                continue;
+            if (!includeResolved && t.resolved)
+                continue;
+            out.push(t);
+        }
+        return out.sort((a, b) => a.createdAt !== b.createdAt
+            ? a.createdAt - b.createdAt
+            : a.id < b.id
+                ? -1
+                : a.id > b.id
+                    ? 1
+                    : 0);
+    }
+    /** Threads whose subject is gone. Derived, every time. Never stored, never synced. */
+    orphans() {
+        return this.threads().filter((t) => !t.resolvedAnchor.attached);
+    }
+    /** Threads anchored to a given entity — attached ones only. */
+    threadsFor(kind, id) {
+        return this.threads().filter((t) => t.anchor.kind === kind && t.anchor.id === id && t.resolvedAnchor.attached);
+    }
+    // ==========================================================================
+    // READ STATE (local) + MENTIONS (seam)
+    // ==========================================================================
+    markRead(threadId) {
+        const t = this.thread(threadId);
+        if (!t)
+            return;
+        this.readState.markRead(threadId, t.messages);
+        this.emit();
+    }
+    markUnread(threadId) {
+        this.readState.markUnread(threadId);
+        this.emit();
+    }
+    /** Unread messages across every unresolved thread — the number a badge shows. */
+    totalUnread() {
+        return this.threads({ includeResolved: false }).reduce((n, t) => n + t.unread, 0);
+    }
+    /** Threads that @mention this viewer and that they have not read. */
+    mentionsOfViewer() {
+        return this.threads().filter((t) => t.messages.some((m) => { var _a; return !m.deleted && m.author !== this.opts.viewer && ((_a = m.mentions) === null || _a === void 0 ? void 0 : _a.includes(this.opts.viewer)); }));
+    }
+    /**
+     * A message has entered the store — local or remote, first time only. Fire the seam.
+     *
+     * Fires on EVERY peer that receives the op, with an idempotency key that is identical
+     * on all of them. That is deliberate and it is documented in mentions.ts: the engine
+     * cannot know which peer is privileged, so it tells all of them the same true thing and
+     * gives the host the one piece of information it needs to send exactly one email.
+     */
+    onCommentsChanged() {
+        var _a, _b;
+        if (this.opts.notifier) {
+            for (const [tid, stored] of Object.entries(this.tree())) {
+                // No anchor yet ⇒ the thread is still arriving. Do NOT mark these notified: the
+                // event carries the anchor, and a notification that cannot say what it is about
+                // is worth less than one that arrives a beat later and can.
+                if (!stored.head || !stored.anchor)
+                    continue;
+                for (const m of Object.values((_a = stored.messages) !== null && _a !== void 0 ? _a : {})) {
+                    const key = (0, mentions_1.mentionKey)(tid, m.id);
+                    if (this.notified.has(key))
+                        continue;
+                    this.notified.add(key);
+                    if (!((_b = m.mentions) === null || _b === void 0 ? void 0 : _b.length) || m.deleted)
+                        continue;
+                    const event = {
+                        key,
+                        diagramId: this.diagram.id,
+                        threadId: tid,
+                        messageId: m.id,
+                        mentioned: [...m.mentions],
+                        author: m.author,
+                        body: m.body,
+                        anchor: stored.anchor,
+                        createdAt: m.createdAt,
+                        local: m.author === this.opts.viewer,
+                    };
+                    this.opts.notifier.notify(event);
+                }
+            }
+        }
+        this.emit();
+    }
+    // ==========================================================================
+    /** Fired whenever the comment DATA or this viewer's READ STATE changes. */
+    onChange(cb) {
+        this.subs.add(cb);
+        return () => this.subs.delete(cb);
+    }
+    emit() {
+        for (const cb of [...this.subs])
+            cb();
+    }
+    dispose() {
+        var _a;
+        (_a = this.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.unsubscribe = null;
+        this.subs.clear();
+    }
+    // ==========================================================================
+    now() {
+        return this.opts.now ? this.opts.now() : Date.now();
+    }
+    /**
+     * A globally unique id, minted by the AUTHORING peer and carried in the op.
+     *
+     * Determinism is preserved even though this is random, and the distinction matters: a
+     * random id chosen INSIDE a reducer would make replay non-deterministic and destroy
+     * every guarantee in the substrate. A random id chosen at AUTHORING time is just a
+     * value in the payload — every peer replays the same one forever.
+     *
+     * A per-session counter alone would be a disaster: restart the tab and it restarts at
+     * 1, so `alice-m1` collides with a message alice wrote yesterday, whose register it
+     * would then silently OVERWRITE. Hence time + a counter + randomness, and an
+     * `idFactory` seam so tests can be deterministic without the production path pretending
+     * to be.
+     *
+     * THE COUNTER SITS BEFORE THE RANDOM SUFFIX, AND THAT ORDERING IS LOAD-BEARING. The id
+     * is the LAST tiebreak in `messageOrder` — (createdAt, author, id) — so it decides the
+     * order of two messages written by the same person in the same MILLISECOND. Put the
+     * random part first and that decision is a coin toss: paste two comments in quick
+     * succession and they can read back in the wrong order. (Found by a test with a frozen
+     * clock, which is the only way a millisecond collision is reliably reproducible.) With
+     * the zero-padded counter in front, same-millisecond messages sort in the order they
+     * were actually written — on every peer, forever, because the id travels in the op.
+     */
+    mintId(prefix) {
+        if (this.opts.idFactory)
+            return this.opts.idFactory();
+        const seq = (this.counter++).toString(36).padStart(4, '0');
+        const rand = Math.random().toString(36).slice(2, 8);
+        return `${prefix}_${Date.now().toString(36)}_${seq}_${rand}`;
+    }
+}
+exports.CommentStore = CommentStore;
+//# sourceMappingURL=comment-store.js.map

package/src/libs/engine/src/comments/comment-store.js.map

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

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

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './mentions';
+export * from './read-state';
+export * from './comment-store';

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

@@ -0,0 +1,31 @@
+"use strict";
+// Wave 9 (Collaboration) — Card 6: comments, annotations & @mentions.
+//
+// Threaded comments anchored to a node, a link, or a free region of the canvas. They
+// ride the Card 0 op log (see types.ts for the argument), so they converge, replicate,
+// persist and undo through machinery that already exists and is already proven.
+//
+// The three things worth knowing before you read the code:
+//
+//   1. ANCHOR BY IDENTITY. A thread on a node stores the NODE ID and derives the pin's
+//      position from the live node every frame. Move the node and the pin follows, with
+//      no op. A free-region thread stores WORLD coordinates, so it survives pan and zoom
+//      by construction.
+//
+//   2. A DELETED NODE DOES NOT DELETE THE CONVERSATION. The thread is ORPHANED — still
+//      readable, still replyable, drawn detached at the last place its subject was seen —
+//      and `attached` is DERIVED, never stored, so it cannot contradict the diagram, it
+//      re-attaches for free on undo, and it is correct no matter which way the CRDT card
+//      settles add/remove races. See `CommentStore.resolveAnchor`.
+//
+//   3. ONE MESSAGE = ONE REGISTER. That is the cut that makes two people's concurrent
+//      replies both survive. The obvious `messages: [...]` array would let LWW throw one
+//      of them away, silently. There is a test that builds the wrong design and watches
+//      it lose the comment.
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./mentions"), exports);
+tslib_1.__exportStar(require("./read-state"), exports);
+tslib_1.__exportStar(require("./comment-store"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../engine/src/comments/index.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,EAAE;AACF,qFAAqF;AACrF,uFAAuF;AACvF,gFAAgF;AAChF,EAAE;AACF,2DAA2D;AAC3D,EAAE;AACF,uFAAuF;AACvF,wFAAwF;AACxF,yFAAyF;AACzF,wBAAwB;AACxB,EAAE;AACF,uFAAuF;AACvF,0FAA0F;AAC1F,wFAAwF;AACxF,yFAAyF;AACzF,mEAAmE;AACnE,EAAE;AACF,sFAAsF;AACtF,yFAAyF;AACzF,wFAAwF;AACxF,4BAA4B;;;AAE5B,kDAAwB;AACxB,qDAA2B;AAC3B,uDAA6B;AAC7B,0DAAgC"}

package/src/libs/engine/src/comments/mentions.d.ts

@@ -0,0 +1,52 @@
+import type { CommentAnchor } from './types';
+/** One @mention found in a message body. */
+export interface MentionRef {
+    /** The user id to notify. From `@[Name](id)` this is `id`; from `@handle` it is `handle`. */
+    id: string;
+    /** What was written on screen, for rendering the chip. */
+    display: string;
+    /** The exact source text, so a renderer can replace it in place. */
+    raw: string;
+    /** Character offset of `raw` in the body. */
+    index: number;
+}
+/**
+ * Extract the mentions from a body. Pure, and total: never throws, never re-orders.
+ *
+ * Deduplicated by id — mentioning Ada three times in one message is one notification, not
+ * three, and that is a property of the DATA, not of the notifier's retry policy.
+ */
+export declare function parseMentions(body: string): MentionRef[];
+/** Just the ids — what gets stored on the message register. */
+export declare function mentionIds(body: string): string[];
+/**
+ * What a notifier is handed. Everything it needs, nothing it would have to guess.
+ *
+ * `anchor` is in here on purpose: "Ada was mentioned" is useless; "Ada was mentioned in a
+ * thread on the Payment gateway node" is a notification a human can act on without opening
+ * the file.
+ */
+export interface MentionEvent {
+    /**
+     * STABLE ACROSS PEERS AND ACROSS REPLAYS. Dedupe on this or send N copies. See header.
+     */
+    key: string;
+    diagramId: string;
+    threadId: string;
+    messageId: string;
+    /** User ids. The host's directory turns these into people. */
+    mentioned: string[];
+    /** The user id of whoever wrote the message. */
+    author: string;
+    body: string;
+    anchor: CommentAnchor;
+    createdAt: number;
+    /** True when this peer is the one that authored the message. */
+    local: boolean;
+}
+/** The seam. One method. The engine calls it; the host implements it. */
+export interface MentionNotifier {
+    notify(event: MentionEvent): void;
+}
+/** The idempotency key. Derived only from op-borne data — never from local state. */
+export declare function mentionKey(threadId: string, messageId: string): string;