@geekity/cms 0.29.0 → 0.31.0

package/dist/web/conversation.js

@@ -1,16 +1,39 @@
-import { readSiteJson, readSiteSettings } from '../admin/settings.js';
 import { avatarHref } from '../avatars/avatars.js';
 import { answerable, commentPolicyOf } from '../comments/policy.js';
 import { postLabel, postTypeOf } from '../content/post-type.js';
 import { RSVP_LABELS } from '../content/rsvp.js';
 import { readAllQuoteAuthorizations } from '../federation/quotes.js';
-import { actorHandle, guessedName, quoteFrom, replyFrom, REPLY_ACTIVITY_TYPE, } from '../federation/replies.js';
-import { authorContext, authorFeedHref, siteAuthorContext } from './authors.js';
-import { activityStreamsId, isListed, isServed, permalinkOfObjectId } from './documents.js';
-import { isRepliesKey, repliesFeedPath, repliesKey } from './feed-source.js';
-import { COMMENT_PAGE_PREFIX, commentPageHref, feedGuid, replyGuid } from './guids.js';
-import { absoluteUrl } from './negotiate.js';
-import { sanitizeCommentHtml } from './sanitize.js';
+import { actorHandle, guessedName, quoteFrom, replyFrom, REPLY_ACTIVITY_TYPE, } from '../store/inbox-replies.js';
+import { readSiteJson, readSiteSettings } from '../site/site-json.js';
+import { absoluteUrl } from '../util/url.js';
+import { authorContext, profileContext, siteAuthorContext } from '../site/authors.js';
+import { authorFeedHref, repliesFeedPath } from './feed-source.js';
+import { activityStreamsId, permalinkOfObjectId } from '../content/permalinks.js';
+import { isListed, isServed } from '../content/served.js';
+import { isKey, commentPageHref, feedGuid, repliesKey } from '../content/guids.js';
+import { sanitizeCommentHtml } from '../content/sanitize.js';
+import { commentAnchor, commentKeyAt, commentNames, heldComment, isWithheld, visibleReply, } from '../comments/conversation.js';
+/**
+ * The conversation under a post, in one shape whatever it is made of, and the
+ * one reader everything that shows a conversation asks.
+ *
+ * The fediverse is only the first thing that can answer a post: native
+ * comments and webmentions land in the same thread, so nothing here is spelled
+ * in ActivityPub's vocabulary. An {@link Interaction} says where it came from
+ * (`source`) and what it is (`kind`), and everything else about it is the same
+ * whether a Mastodon note, a form on this site or somebody else's blog post
+ * produced it.
+ *
+ * Two indexes hold the raw material — `ap_inbox` for what remote servers sent
+ * and `comments` for what the files under `content/_data/comments/` say — and
+ * this module is the only place outside the comment intake that reads either
+ * of them to show somebody a conversation. That is the point of it: the thread
+ * under the post, the post's own comments feed, `/comments/feed/` and the
+ * `source:comments` count on a post feed used to merge the same two indexes in
+ * two implementations, which is two chances to disagree about what a reader
+ * may see. Now there is one {@link ConversationReader}, and the page and the
+ * feed are the same reading.
+ */
 const RSVP_GROUP_ORDER = ['yes', 'maybe', 'interested', 'no'];
 const RSVP_ACTIVITIES = {
     Accept: 'yes',
@@ -73,44 +96,93 @@ function postConversation(context, document) {
         },
     };
 }
+/**
+ * A repost joins the boosts, because a reader looking at the page is being
+ * told the same thing by both; a mention is its own group, because it is
+ * neither an answer nor a reaction.
+ */
+const GROUP_OF = {
+    reply: 'written',
+    like: 'likes',
+    boost: 'boosts',
+    repost: 'boosts',
+    mention: 'mentions',
+};
 function gather(context, document, seen = new Set([document.path])) {
-    const objectId = activityStreamsId(document, context.baseUrl);
+    const deliveredObjectId = activityStreamsId(document, context.baseUrl, context.store.now());
     const root = rootOf(context, document);
-    const activities = objectId === undefined ? [] : activitiesAround(context.admin, objectId);
+    const stored = context.admin.listCommentsFor(document.slug);
     const naming = authorNaming(context.admin);
-    const quotes = objectId === undefined
+    const isEvent = postTypeOf(document) === 'event';
+    const fediverse = deliveredObjectId === undefined
         ? []
-        : quotesOf(context.admin, readAllQuoteAuthorizations(context.contentDir), objectId, naming);
-    const withdrawn = withdrawnBy(activities);
-    const written = [];
-    const likes = [];
-    const boosts = [];
-    const mentions = [...quotes];
-    const answers = [];
+        : [
+            fromQuotes(context, deliveredObjectId, naming),
+            fromActivities(context, deliveredObjectId, stored, naming, isEvent),
+        ];
+    const comments = fromStored(context, document, stored, isEvent);
+    const sources = [...fediverse, comments];
+    const replyPosts = fromReplyPosts(context, document, root, seen, [
+        ...sources.flatMap(({ said }) => said.flatMap(([group, entry]) => (group === 'written' ? [entry] : []))),
+        ...(comments.held?.values() ?? []),
+    ]);
+    return merged(root, [...sources, replyPosts]);
+}
+function merged(root, parts) {
+    const groups = {
+        written: [],
+        likes: [],
+        boosts: [],
+        mentions: [],
+        answers: [],
+    };
     const held = new Map();
-    const reacted = new Set();
-    const isEvent = postTypeOf(document) === 'event';
+    const withdrawn = new Set();
+    for (const part of parts) {
+        for (const [group, entry] of part.said)
+            groups[group].push(entry);
+        for (const [id, entry] of part.held ?? [])
+            held.set(id, entry);
+        for (const id of part.withdrawn ?? [])
+            withdrawn.add(id);
+    }
+    // Sorted before threading rather than after, because a thread is built by
+    // walking this list: two sources' entries would otherwise interleave in the
+    // order the code happened to read them rather than in the order they were
+    // written.
+    groups.written.sort(byPublished);
+    return { root, ...groups, held, withdrawn };
+}
+function fromQuotes(context, objectId, naming) {
+    const approvals = readAllQuoteAuthorizations(context.contentDir);
+    return {
+        said: quotesOf(context.admin, approvals, objectId, naming).map((quote) => ['mentions', quote]),
+    };
+}
+function fromActivities(context, objectId, stored, naming, isEvent) {
+    // What was imported from the fediverse is walked from too: an answer to an
+    // imported note names the note, which no logged activity may carry.
+    const origins = stored.flatMap((comment) => comment.source === 'activitypub' && comment.origin !== undefined ? [comment.origin] : []);
+    const activities = activitiesAround(context.admin, [objectId, ...origins]);
+    const withdrawn = withdrawnBy(activities);
+    const taken = (activityId) => activityId !== null && withdrawn.has(activityId);
+    // One like per actor, so a like imported from the site this one replaced
+    // and the same person's like delivered here are one.
+    const reacted = new Set(stored.flatMap(storedReaction));
+    const said = [];
     for (const activity of activities) {
         const answer = isEvent ? RSVP_ACTIVITIES[activity.activityType] : undefined;
         if (answer !== undefined) {
-            if (activity.objectId !== objectId)
+            if (activity.objectId !== objectId || taken(activity.activityId))
                 continue;
-            if (activity.activityId !== null && withdrawn.has(activity.activityId))
-                continue;
-            const author = naming(activity.actorId);
-            answers.push({
-                id: activity.activityId ?? `${activity.actorId}#rsvp`,
-                source: 'activitypub',
-                kind: 'reply',
-                author,
-                url: author.url,
-                content: '',
-                published: new Date(activity.receivedAt),
-                inReplyTo: null,
-                status: 'published',
-                replies: [],
-                rsvp: { value: answer, label: RSVP_LABELS[answer] },
-            });
+            said.push([
+                'answers',
+                {
+                    ...reaction(activity, naming, `${activity.actorId}#rsvp`),
+                    kind: 'reply',
+                    rsvp: { value: answer, label: RSVP_LABELS[answer] },
+                },
+            ]);
             continue;
         }
         const kind = REACTIONS[activity.activityType];
@@ -119,77 +191,96 @@ function gather(context, document, seen = new Set([document.path])) {
             // belongs to that reply's own conversation, wherever it is shown.
             if (activity.objectId !== objectId)
                 continue;
-            // One like per actor, however many times it was delivered, and none at
-            // all once its actor has taken it back.
-            const key = `${kind}\0${activity.actorId}`;
-            if (reacted.has(key))
+            // One like per actor, however many times it was delivered, and none
+            // at all once its actor has taken it back.
+            const key = reactionKey(kind, activity.actorId);
+            if (reacted.has(key) || taken(activity.activityId))
                 continue;
-            if (activity.activityId !== null && withdrawn.has(activity.activityId))
+            if (activity.activityId !== null &&
+                heldComment(context.admin, activity.activityId) !== undefined) {
                 continue;
+            }
             reacted.add(key);
-            const author = naming(activity.actorId);
-            (kind === 'like' ? likes : boosts).push({
-                id: activity.activityId ?? `${activity.actorId}#${kind}`,
-                source: 'activitypub',
-                kind,
-                author,
-                url: author.url,
-                content: '',
-                published: new Date(activity.receivedAt),
-                inReplyTo: null,
-                status: 'published',
-                replies: [],
-            });
+            said.push([
+                GROUP_OF[kind],
+                { ...reaction(activity, naming, `${activity.actorId}#${kind}`), kind },
+            ]);
             continue;
         }
         const reply = replyFrom(activity);
-        if (reply === undefined)
+        if (reply === undefined || heldComment(context.admin, reply.id) !== undefined)
             continue;
-        written.push(federatedInteraction(reply, naming(activity.actorId)));
+        const parent = heldComment(context.admin, reply.inReplyTo);
+        said.push([
+            'written',
+            federatedInteraction(parent === undefined ? reply : { ...reply, inReplyTo: parent.id }, naming(activity.actorId)),
+        ]);
     }
-    for (const stored of context.admin.listCommentsFor(document.slug)) {
-        const comment = interactionOf(stored, document.permalink);
-        if (stored.status !== 'approved') {
+    return { said, withdrawn };
+}
+function storedReaction({ kind, actor }) {
+    const group = GROUP_OF[kind];
+    return actor === undefined || (group !== 'likes' && group !== 'boosts')
+        ? []
+        : [reactionKey(kind, actor)];
+}
+function reactionKey(kind, actor) {
+    return `${GROUP_OF[kind]}\0${actor}`;
+}
+function reaction(activity, naming, fallbackId) {
+    const author = naming(activity.actorId);
+    return {
+        ...unstored(activity.activityId ?? fallbackId),
+        source: 'activitypub',
+        author,
+        url: author.url,
+        content: '',
+        published: new Date(activity.receivedAt),
+        inReplyTo: null,
+        status: 'published',
+        replies: [],
+    };
+}
+function fromStored(context, document, stored, isEvent) {
+    const users = context.users();
+    const said = [];
+    const held = new Map();
+    for (const record of stored) {
+        const comment = interactionOf(record, document.permalink, context.baseUrl, users);
+        if (record.status !== 'approved') {
             held.set(comment.id, comment);
             continue;
         }
-        // A repost joins the boosts, because a reader looking at the page is being
-        // told the same thing by both; a mention is its own group, because it is
-        // neither an answer nor a reaction.
-        const group = isEvent && comment.rsvp !== undefined
-            ? answers
-            : comment.kind === 'reply'
-                ? written
-                : comment.kind === 'like'
-                    ? likes
-                    : comment.kind === 'mention'
-                        ? mentions
-                        : boosts;
-        group.push({ ...comment, replies: [] });
+        const group = isEvent && comment.rsvp !== undefined ? 'answers' : GROUP_OF[comment.kind];
+        said.push([group, { ...comment, replies: [] }]);
     }
-    // The reply posts answering the post or anything said under it, each
-    // bringing what was said under it: an answer to a reply post lands against
-    // the reply post, and this is what stitches it into the thread it is in.
-    const names = namesIn(context, document, root, [...written, ...held.values()]);
+    return { said, held };
+}
+/**
+ * The reply posts answering the post or anything said under it, each
+ * bringing what was said under it: an answer to a reply post lands against
+ * the reply post, and this is what stitches it into the thread it is in.
+ */
+function fromReplyPosts(context, document, root, seen, answered) {
+    const names = namesIn(context, document, root, answered);
+    const said = [];
+    const held = new Map();
+    const withdrawn = new Set();
     for (const answer of context.store.listRepliesTo([...names.keys()])) {
         const target = names.get(answer.inReplyTo ?? '');
         if (target === undefined || seen.has(answer.path))
             continue;
         const under = gather(context, answer, new Set([...seen, answer.path]));
         const top = (entry) => entry.inReplyTo === null ? { ...entry, inReplyTo: under.root } : entry;
-        written.push(replyPostInteraction(context, answer, under.root, target));
-        written.push(...under.written.map(top));
+        said.push(['written', replyPostInteraction(context, answer, under.root, target)]);
+        for (const entry of under.written)
+            said.push(['written', top(entry)]);
         for (const [id, entry] of under.held)
             held.set(id, top(entry));
         for (const id of under.withdrawn)
             withdrawn.add(id);
     }
-    // Sorted before threading rather than after, because a thread is built by
-    // walking this list: two sources' entries would otherwise interleave in the
-    // order the code happened to read them rather than in the order they were
-    // written.
-    written.sort(byPublished);
-    return { root, written, withdrawn, held, likes, boosts, mentions, answers };
+    return { said, held, withdrawn };
 }
 /**
  * One native comment's page: the comment, its replies threaded under it by
@@ -219,7 +310,7 @@ function commentThread(context, id) {
     };
 }
 function replyNamed(context, document, url) {
-    return namedIn(context, document, gather(context, document), url)?.id;
+    return namedIn(context, document, gather(context, document), url);
 }
 /** The entry of a gathered conversation a URL names, held ones included. */
 function namedIn(context, document, said, url) {
@@ -230,8 +321,8 @@ function namedIn(context, document, said, url) {
     catch {
         return undefined;
     }
-    const commentId = commentNamedBy(named, document, context.baseUrl);
-    return [...said.written, ...said.held.values()].find((reply) => reply.id === commentId ||
+    const key = keyNamedBy(named, document, context.baseUrl);
+    return [...said.written, ...said.held.values()].find((reply) => reply.key === key ||
         reply.id === named.href ||
         (reply.url !== null && absoluteUrl(reply.url, context.baseUrl) === named.href));
 }
@@ -249,35 +340,30 @@ function heldAt(context, url) {
     }
     return { kind: 'reply', post, reply };
 }
-function repliesTo(context, segment) {
-    if (!isRepliesKey(segment)) {
-        const stored = context.admin.getComment(segment);
-        if (stored?.source !== 'comment')
-            return undefined;
-        const post = context.store.getBySlug(stored.slug);
-        return post === undefined ? undefined : repliesIn(context, post, segment);
-    }
+function repliesTo(context, key) {
+    if (!isKey(key))
+        return undefined;
     // Each source's index is asked in turn, so a key naming nothing costs three
     // lookups and no more (TASK-327).
-    const [document] = context.store.listByRepliesKey(segment);
+    const [document] = context.store.listByRepliesKey(key);
     if (document !== undefined) {
-        if (repliesKey(feedGuid(document, context.baseUrl)) === segment) {
+        if (repliesKey(feedGuid(document, context.baseUrl)) === key) {
             return repliesIn(context, document, null);
         }
         const root = threadRootOf(context, document);
-        return root === undefined ? undefined : repliesIn(context, root, rootOf(context, document));
+        return root === undefined ? undefined : repliesIn(context, root, key);
     }
-    const [comment] = context.admin.listCommentsByRepliesKey(segment);
+    const comment = context.admin.getComment(key);
     if (comment !== undefined) {
         const post = context.store.getBySlug(comment.slug);
-        return post === undefined ? undefined : repliesIn(context, post, comment.id);
+        return post === undefined ? undefined : repliesIn(context, post, key);
     }
-    for (const activity of context.admin.listRepliesByKey(segment)) {
+    for (const activity of context.admin.listRepliesByKey(key)) {
         const reply = replyFrom(activity);
         if (reply === undefined)
             continue;
         const post = documentNamed(context, reply.id);
-        return post === undefined ? undefined : repliesIn(context, post, reply.id);
+        return post === undefined ? undefined : repliesIn(context, post, key);
     }
     return undefined;
 }
@@ -285,17 +371,17 @@ function repliesTo(context, segment) {
  * The direct replies of one reply in a document's thread, or of the document
  * itself, while the document is served and the reply is one a reader sees.
  */
-function repliesIn(context, post, id) {
+function repliesIn(context, post, key) {
     if (!isServed(post, context.store.now()))
         return undefined;
     const thread = postConversation(context, post).replies;
-    const reply = id === null ? null : visibleReply(thread, id);
+    const reply = key === null ? null : visibleReply(thread, key);
     if (reply === undefined)
         return undefined;
     return {
         post,
         reply,
-        replies: directReplies(reply?.replies ?? thread).map((entry) => ({ ...entry, parent: reply })),
+        replies: repliesFed(reply?.replies ?? thread).map((entry) => ({ ...entry, parent: reply })),
     };
 }
 function upstreamsOf(context, document) {
@@ -367,16 +453,16 @@ function documentNamed(context, url, depth = 0) {
         return undefined;
     }
     if (named.origin === new URL(context.baseUrl).origin) {
-        const id = commentIdAt(named.pathname);
-        if (id !== undefined) {
-            const comment = context.admin.getComment(id);
+        const key = commentKeyAt(named.pathname);
+        if (key !== undefined) {
+            const comment = context.admin.getComment(key);
             return comment === undefined ? undefined : context.store.getBySlug(comment.slug);
         }
         const permalink = permalinkOfObjectId(`${named.origin}${named.pathname}`, context.baseUrl);
         const found = permalink === undefined ? undefined : context.store.getByPermalink(permalink);
         return found ?? context.store.getByStoredObjectId(named.href);
     }
-    const [comment] = context.admin.listCommentsAt(named.href);
+    const comment = context.admin.listCommentsAt(named.href)[0] ?? heldComment(context.admin, named.href);
     if (comment !== undefined)
         return context.store.getBySlug(comment.slug);
     for (const activity of context.admin.listActivitiesAbout([named.href])) {
@@ -409,7 +495,7 @@ const MAXIMUM_NOTE_DEPTH = 32;
  * native comments, and they have to hang off something.
  */
 function rootOf(context, document) {
-    return activityStreamsId(document, context.baseUrl) ?? document.permalink;
+    return activityStreamsId(document, context.baseUrl, context.store.now()) ?? document.permalink;
 }
 /**
  * Every URL a reply post's `in-reply-to` could name something here by, and the
@@ -437,17 +523,10 @@ function namesOf(reply, permalink, baseUrl) {
         names.push(...commentNames(reply.id, permalink, baseUrl));
     return names;
 }
-/**
- * The URLs a reply post can answer a native comment by: its own page, and its
- * anchor on the post at this absolute permalink.
- */
-export function commentNames(id, permalink, baseUrl) {
-    return [absoluteUrl(commentPageHref(id), baseUrl), `${permalink}#${commentAnchor(id)}`];
-}
 /** A reply post as the thread's own shape, answering `inReplyTo`. */
 function replyPostInteraction(context, post, id, inReplyTo) {
     return {
-        id,
+        ...unstored(id),
         source: 'post',
         kind: 'reply',
         author: documentAuthor(context, post),
@@ -464,27 +543,32 @@ function documentAuthor(context, post) {
     const users = context.users();
     const site = readSiteSettings(context.contentDir);
     const author = authorContext(users, post.author) ?? siteAuthorContext(users, site.author);
+    return bylineAuthor(author, site.title);
+}
+/** A byline as the thread names its author, `fallback` when it names nobody. */
+function bylineAuthor(author, fallback) {
     return {
-        name: author?.name ?? site.title,
+        name: author?.name ?? fallback,
         handle: null,
         url: author?.url ?? null,
         avatar: author?.avatar ?? null,
         actorId: null,
         feed: author?.username === undefined ? null : authorFeedHref(author.username, 'rss'),
+        username: author?.username ?? null,
     };
 }
-/** The comment a URL on this site names by its page or by its anchor on the post. */
-function commentNamedBy(url, document, baseUrl) {
+/** The key a URL on this site names by a comment's page or by an anchor on the post. */
+function keyNamedBy(url, document, baseUrl) {
     const post = new URL(absoluteUrl(document.permalink, baseUrl));
     if (url.origin !== post.origin)
         return undefined;
-    const onItsPage = commentIdAt(url.pathname);
+    const onItsPage = commentKeyAt(url.pathname);
     if (onItsPage !== undefined)
         return onItsPage;
     const anchor = `#${commentAnchor('')}`;
     if (url.pathname !== post.pathname || !url.hash.startsWith(anchor))
         return undefined;
-    return decoded(url.hash.slice(anchor.length));
+    return url.hash.slice(anchor.length);
 }
 /**
  * What a reply answers, from the top of the thread down to its parent.
@@ -554,7 +638,7 @@ function siteConversation(context, limit) {
         offset += page.length;
         for (const activity of page) {
             const reply = replyFrom(activity);
-            if (reply === undefined)
+            if (reply === undefined || heldComment(context.admin, reply.id) !== undefined)
                 continue;
             // A note answering another note is as much this post's as one answering
             // the post, so the post is found the way a reply post finds its thread.
@@ -576,26 +660,31 @@ function siteConversation(context, limit) {
             said.push({ ...quote, post });
         }
     }
-    for (const stored of context.admin.listComments({
-        status: 'approved',
-        limit: limit * OVERSCAN,
-    })) {
-        const post = context.store.getBySlug(stored.slug);
-        if (!shown(post))
-            continue;
-        said.push({ ...interactionOf(stored, post.permalink), post });
-    }
     // Each post's thread, read once: where each reply sits and what it carries
     // is the thread's to say, so the site's feed and the post's agree.
     const threads = new Map();
     const placedOn = (post) => {
         let found = threads.get(post.path);
         if (found === undefined) {
-            found = new Map(placed(postConversation(context, post).replies).map((reply) => [reply.id, reply]));
+            found = new Map(saidIn(postConversation(context, post)).map((reply) => [reply.id, reply]));
             threads.set(post.path, found);
         }
         return found;
     };
+    // A stored comment is taken from its post's thread rather than read on its
+    // own, so a reaction or an event's RSVP, which the thread holds apart, is
+    // left out here as it is from the post's feed.
+    for (const stored of context.admin.listComments({
+        status: 'approved',
+        limit: limit * OVERSCAN,
+    })) {
+        const post = context.store.getBySlug(stored.slug);
+        if (!shown(post))
+            continue;
+        const entry = placedOn(post).get(stored.id);
+        if (entry !== undefined)
+            said.push({ ...entry, post });
+    }
     // A reply post is in the feed of the thread it is shown in, unlisted or
     // not: the thread is listed, and the reply post is one of its answers.
     for (const answer of context.store.listReplyPosts({ limit: limit * OVERSCAN })) {
@@ -606,7 +695,7 @@ function siteConversation(context, limit) {
         if (reply !== undefined)
             said.push({ ...reply, post });
     }
-    return newestFirst(said, limit).map((entry) => {
+    return newestFirst(said.filter(conversational), limit).map((entry) => {
         const thread = placedOn(entry.post);
         return {
             ...(thread.get(entry.id) ?? { ...entry, parent: null }),
@@ -619,7 +708,7 @@ function siteConversation(context, limit) {
 function directCounts(context, documents) {
     return new Map(documents.map((document) => [
         document.permalink,
-        directReplies(postConversation(context, document).replies).length,
+        repliesFed(postConversation(context, document).replies).length,
     ]));
 }
 /**
@@ -653,7 +742,7 @@ function quotesOf(admin, approvals, objectId, naming) {
             if (quote?.id !== approval.quote || quote.quoted !== objectId)
                 continue;
             quotes.push({
-                id: quote.id,
+                ...unstored(quote.id),
                 source: 'activitypub',
                 kind: 'mention',
                 author: naming(quote.actorId),
@@ -674,7 +763,7 @@ function quotesOf(admin, approvals, objectId, naming) {
 /** One logged fediverse reply as the thread's own shape. */
 function federatedInteraction(reply, author) {
     return {
-        id: reply.id,
+        ...unstored(reply.id),
         source: 'activitypub',
         kind: 'reply',
         author,
@@ -688,24 +777,33 @@ function federatedInteraction(reply, author) {
         replies: [],
     };
 }
+function unstored(id) {
+    return { id, key: repliesKey(id), guid: id, migrated: false };
+}
 /** One stored comment as the thread's own shape. */
-function interactionOf(comment, permalink) {
+function interactionOf(comment, permalink, baseUrl, users) {
+    // A user the site no longer has is named as the comment was signed.
+    const user = users.find((candidate) => candidate.username === comment.user);
     return {
         id: comment.id,
+        key: comment.id,
+        guid: comment.source === 'comment'
+            ? absoluteUrl(commentPageHref(comment.id), baseUrl)
+            : (comment.origin ?? comment.url ?? comment.id),
+        migrated: comment.migrated === true,
         source: comment.source,
         kind: comment.kind,
-        author: {
-            name: comment.author.name,
-            // A commenter has no fediverse identity: they gave a name, maybe a
-            // website, and nothing that names them anywhere else.
-            handle: null,
-            url: comment.author.url,
-            // Only a webmention has one: it came out of the source page's `h-card`,
-            // and a form asks nobody for a picture.
-            avatar: comment.author.avatar === null ? null : avatarHref(comment.author.avatar),
-            actorId: null,
-            feed: comment.source === 'webmention' ? comment.author.url : null,
-        },
+        author: user === undefined
+            ? {
+                name: comment.author.name,
+                handle: comment.actor === undefined ? null : (actorHandle(comment.actor) ?? null),
+                url: comment.author.url,
+                avatar: comment.author.avatar === null ? null : avatarHref(comment.author.avatar),
+                actorId: comment.actor ?? null,
+                feed: comment.source === 'webmention' ? comment.author.url : null,
+                username: null,
+            }
+            : bylineAuthor(profileContext(user), comment.author.name),
         // Where it can be read. A comment written here has a page of its own
         // (TASK-318); a webmention lives on the page it was sent from, and its
         // `url` says so. A theme that prints `url` for a fediverse reply prints a
@@ -724,47 +822,27 @@ function interactionOf(comment, permalink) {
             : { rsvp: { value: comment.rsvp, label: RSVP_LABELS[comment.rsvp] } }),
     };
 }
-/**
- * The `id` a comment is anchored at on the page.
- *
- * Prefixed rather than bare so a comment can never collide with a heading
- * anchor the post's own Markdown produced.
- */
-export function commentAnchor(id) {
-    return `comment-${id}`;
-}
-/** The id of the comment whose page a path is, or `undefined` (TASK-319). */
-export function commentIdAt(pathname) {
-    if (!pathname.startsWith(COMMENT_PAGE_PREFIX) || !pathname.endsWith('/'))
-        return undefined;
-    const encoded = pathname.slice(COMMENT_PAGE_PREFIX.length, -1);
-    if (encoded === '' || encoded.includes('/'))
-        return undefined;
-    return decoded(encoded);
-}
-function decoded(value) {
-    try {
-        return decodeURIComponent(value);
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Everything said in a conversation, at every depth and in no order: the
- * replies and the mentions.
- *
- * The likes and the boosts are left out because they say nothing. A feed item
- * is somebody's words, and "@ada liked this" has none to carry — a reader
- * polling a comments feed would get an entry with an empty body and no way to
- * tell what it was for.
- */
+/** What a post's comments feed carries, at every depth and in no order. */
 export function spokenIn(conversation) {
+    return saidIn(conversation).filter(conversational);
+}
+/** The mentions and every visible reply of a conversation, each with its parent. */
+function saidIn(conversation) {
     return [
         ...conversation.mentions.map((mention) => ({ ...mention, parent: null })),
         ...placed(conversation.replies),
     ];
 }
+/**
+ * Whether a feed carries it and a reply count counts it (TASK-335): somebody's
+ * words, a reply or a mention, said here. A like, a boost or a repost says
+ * nothing — "@ada liked this" would be an item with an empty body — and a
+ * migrated entry was published before the site came here, so a reader must
+ * not see it as new.
+ */
+function conversational(entry) {
+    return !entry.migrated && (entry.kind === 'reply' || entry.kind === 'mention');
+}
 /** Every visible reply of a thread at any depth, each with the reply it sits under. */
 function placed(replies, parent = null) {
     return directReplies(replies).flatMap((reply) => [
@@ -780,15 +858,9 @@ function placed(replies, parent = null) {
 function directReplies(replies) {
     return replies.flatMap((reply) => (isWithheld(reply) ? directReplies(reply.replies) : [reply]));
 }
-/**
- * The `/replies/` feed of one reply: a native comment's by its id, anything
- * else's by the key of its guid, as is a native comment whose id would read
- * as a key.
- */
-function repliesHrefOf(reply, baseUrl) {
-    return repliesFeedPath(reply.source === 'comment' && !isRepliesKey(reply.id)
-        ? reply.id
-        : repliesKey(replyGuid(reply, baseUrl)));
+/** The direct replies a feed carries and a count advertises. */
+function repliesFed(replies) {
+    return directReplies(replies).filter(conversational);
 }
 /**
  * Interactions as a comments feed carries them: newest first, at most `limit`,
@@ -807,10 +879,10 @@ export function feedComments(said, options) {
             ? thread === undefined
                 ? undefined
                 : feedGuid(thread, baseUrl)
-            : replyGuid(entry.parent, baseUrl);
-        const replies = directReplies(entry.replies);
+            : entry.parent.guid;
+        const replies = repliesFed(entry.replies);
         return {
-            id: replyGuid(entry, baseUrl),
+            id: entry.guid,
             url: absoluteUrl(entry.url ?? '/', baseUrl),
             author: entry.author.name,
             published: entry.published,
@@ -821,7 +893,7 @@ export function feedComments(said, options) {
                 : {
                     replies: {
                         count: replies.length,
-                        feed: absoluteUrl(repliesHrefOf(entry, baseUrl), baseUrl),
+                        feed: absoluteUrl(repliesFeedPath(entry.key), baseUrl),
                     },
                 }),
             ...(entry.author.feed === null
@@ -871,7 +943,7 @@ class PostsByObjectId {
         if (permalink !== undefined) {
             const document = this.#context.store.getByPermalink(permalink);
             if (document !== undefined &&
-                activityStreamsId(document, this.#context.baseUrl) === objectId) {
+                activityStreamsId(document, this.#context.baseUrl, this.#context.store.now()) === objectId) {
                 return document;
             }
         }
@@ -881,7 +953,7 @@ class PostsByObjectId {
         if (this.#all === undefined) {
             this.#all = new Map();
             for (const document of this.#context.store.listPosts()) {
-                const id = activityStreamsId(document, this.#context.baseUrl);
+                const id = activityStreamsId(document, this.#context.baseUrl, this.#context.store.now());
                 if (id !== undefined)
                     this.#all.set(id, document);
             }
@@ -955,7 +1027,8 @@ function threadOf(said, under = said.root) {
         const list = siblings(said.held.get(id)?.inReplyTo ?? said.root, id, true);
         if (list === undefined)
             return undefined;
-        const entry = { id, withheld: true, replies: [] };
+        const key = isKey(id) ? id : repliesKey(id);
+        const entry = { id, key, withheld: true, replies: [] };
         list.push(entry);
         withheld.set(id, entry);
         return entry;
@@ -965,20 +1038,6 @@ function threadOf(said, under = said.root) {
     }
     return top;
 }
-/** The entry of a thread with this id that a reader can see, at any depth. */
-export function visibleReply(replies, id) {
-    for (const reply of replies) {
-        if (!isWithheld(reply) && reply.id === id)
-            return reply;
-        const found = visibleReply(reply.replies, id);
-        if (found !== undefined)
-            return found;
-    }
-    return undefined;
-}
-export function isWithheld(reply) {
-    return 'withheld' in reply;
-}
 /** Oldest first, which is the order a conversation reads in. */
 function byPublished(left, right) {
     return left.published.getTime() - right.published.getTime();
@@ -1021,10 +1080,10 @@ const REACTIONS = {
  * stops when a round finds nothing new, which it must, because a row is
  * collected once and there are finitely many.
  */
-function activitiesAround(admin, objectId) {
+function activitiesAround(admin, objectIds) {
     const collected = new Map();
-    const asked = new Set([objectId]);
-    let frontier = [objectId];
+    const asked = new Set(objectIds);
+    let frontier = [...asked];
     while (frontier.length > 0) {
         const next = [];
         for (const activity of admin.listActivitiesAbout(frontier)) {
@@ -1106,6 +1165,7 @@ function authorNaming(admin) {
             avatar: icon === null ? null : avatarHref(icon),
             actorId,
             feed: null,
+            username: null,
         };
         known.set(actorId, author);
         return author;