@grafloria/element 0.3.20 → 0.3.22

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

@@ -1,538 +0,0 @@
-"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/index.d.ts

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

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

@@ -1,31 +0,0 @@
-"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/mentions.d.ts

@@ -1,52 +0,0 @@
-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;