@geekity/cms 0.28.0 → 0.30.0

package/dist/web/conversation.js

@@ -1,9 +1,14 @@
+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 { activityStreamsId, isListed, permalinkOfObjectId } from './documents.js';
+import { authorContext, authorFeedHref, profileContext, siteAuthorContext } from './authors.js';
+import { activityStreamsId, isListed, isServed, permalinkOfObjectId } from './documents.js';
+import { isKey, repliesFeedPath, repliesKey } from './feed-source.js';
+import { COMMENT_PAGE_PREFIX, commentPageHref, feedGuid } from './guids.js';
 import { absoluteUrl } from './negotiate.js';
 import { sanitizeCommentHtml } from './sanitize.js';
 const RSVP_GROUP_ORDER = ['yes', 'maybe', 'interested', 'no'];
@@ -23,19 +28,16 @@ const RSVP_ACTIVITIES = {
 export function createConversation(context) {
     return {
         thread: (document) => postConversation(context, document),
-        counts: (documents) => commentCounts(context, documents),
+        counts: (documents) => directCounts(context, documents),
         latest: (limit) => siteConversation(context, limit),
+        comment: (id) => commentThread(context, id),
+        replyNamed: (document, url) => replyNamed(context, document, url),
+        heldAt: (url) => heldAt(context, url),
+        repliesTo: (segment) => repliesTo(context, segment),
+        documentOf: (url) => documentNamed(context, url),
+        upstreams: (document) => upstreamsOf(context, document),
     };
 }
-/** A conversation with nothing in it, which is what most posts have. */
-const NOTHING = {
-    replies: [],
-    likes: [],
-    boosts: [],
-    mentions: [],
-    rsvps: [],
-    counts: { replies: 0, likes: 0, boosts: 0, mentions: 0, rsvps: 0, total: 0 },
-};
 /**
  * The conversation under one post: everything said about it, from every source
  * the site has, threaded into one.
@@ -45,26 +47,57 @@ const NOTHING = {
  * can still have native comments, which hang off its permalink instead.
  */
 function postConversation(context, document) {
+    const said = gather(context, document);
+    const replies = threadOf(said);
+    sortThread(replies);
+    const { likes, boosts, mentions } = said;
+    likes.sort(byPublished);
+    boosts.sort(byPublished);
+    mentions.sort(byPublished);
+    const counted = countReplies(replies);
+    const rsvps = rsvpGroups(said.answers);
+    const answered = rsvps.reduce((sum, group) => sum + group.people.length, 0);
+    return {
+        replies,
+        likes,
+        boosts,
+        mentions,
+        rsvps,
+        counts: {
+            replies: counted,
+            likes: likes.length,
+            boosts: boosts.length,
+            mentions: mentions.length,
+            rsvps: answered,
+            total: counted + likes.length + boosts.length + mentions.length + answered,
+        },
+    };
+}
+function gather(context, document, seen = new Set([document.path])) {
     const objectId = activityStreamsId(document, context.baseUrl);
-    // What a top-level answer names. The object id when the post has one, and
-    // the permalink otherwise: a post that has never been delivered can still
-    // have native comments, and they have to hang off something.
-    const root = objectId ?? document.permalink;
-    const activities = objectId === undefined ? [] : activitiesAround(context.admin, objectId);
-    const native = approvedComments(context.admin, document);
+    const root = rootOf(context, document);
+    const stored = context.admin.listCommentsFor(document.slug);
+    const users = context.users();
+    // 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 = objectId === undefined ? [] : activitiesAround(context.admin, [objectId, ...origins]);
     const naming = authorNaming(context.admin);
     const quotes = objectId === undefined
         ? []
         : quotesOf(context.admin, readAllQuoteAuthorizations(context.contentDir), objectId, naming);
-    if (activities.length === 0 && native.length === 0 && quotes.length === 0)
-        return NOTHING;
     const withdrawn = withdrawnBy(activities);
     const written = [];
     const likes = [];
     const boosts = [];
     const mentions = [...quotes];
     const answers = [];
-    const reacted = new Set();
+    const held = new Map();
+    // 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(({ kind, actor }) => actor === undefined || (kind !== 'like' && kind !== 'boost' && kind !== 'repost')
+        ? []
+        : [`${kind === 'like' ? 'like' : 'boost'}\0${actor}`]));
     const isEvent = postTypeOf(document) === 'event';
     for (const activity of activities) {
         const answer = isEvent ? RSVP_ACTIVITIES[activity.activityType] : undefined;
@@ -75,7 +108,7 @@ function postConversation(context, document) {
                 continue;
             const author = naming(activity.actorId);
             answers.push({
-                id: activity.activityId ?? `${activity.actorId}#rsvp`,
+                ...unstored(activity.activityId ?? `${activity.actorId}#rsvp`),
                 source: 'activitypub',
                 kind: 'reply',
                 author,
@@ -95,17 +128,21 @@ function postConversation(context, document) {
             // 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.
+            // 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))
                 continue;
             if (activity.activityId !== null && withdrawn.has(activity.activityId))
                 continue;
+            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}`,
+                ...unstored(activity.activityId ?? `${activity.actorId}#${kind}`),
                 source: 'activitypub',
                 kind,
                 author,
@@ -119,11 +156,17 @@ function postConversation(context, document) {
             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);
+        written.push(federatedInteraction(parent === undefined ? reply : { ...reply, inReplyTo: parent.id }, naming(activity.actorId)));
     }
-    for (const comment of native) {
+    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.
@@ -138,35 +181,353 @@ function postConversation(context, document) {
                         : boosts;
         group.push({ ...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()]);
+    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));
+        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);
-    const replies = threadOf(written, root, withdrawn);
+    return { root, written, withdrawn, held, likes, boosts, mentions, answers };
+}
+/**
+ * One native comment's page: the comment, its replies threaded under it by
+ * the rule the post's thread uses, and the chain from it up to the post.
+ *
+ * Its replies are the same list threaded from the comment rather than from
+ * the post, so a reply the post's thread shows is shown here, and one it
+ * leaves out is left out here.
+ */
+function commentThread(context, id) {
+    const stored = context.admin.getComment(id);
+    if (stored?.source !== 'comment' || stored.status !== 'approved')
+        return undefined;
+    const post = context.store.getBySlug(stored.slug);
+    if (post === undefined)
+        return undefined;
+    const said = gather(context, post);
+    const comment = said.written.find((reply) => reply.id === id);
+    if (comment === undefined)
+        return undefined;
+    const replies = threadOf(said, id);
     sortThread(replies);
-    likes.sort(byPublished);
-    boosts.sort(byPublished);
-    mentions.sort(byPublished);
-    const counted = countReplies(replies);
-    const rsvps = rsvpGroups(answers);
-    const answered = rsvps.reduce((sum, group) => sum + group.people.length, 0);
     return {
-        replies,
-        likes,
-        boosts,
-        mentions,
-        rsvps,
-        counts: {
-            replies: counted,
-            likes: likes.length,
-            boosts: boosts.length,
-            mentions: mentions.length,
-            rsvps: answered,
-            total: counted + likes.length + boosts.length + mentions.length + answered,
-        },
+        post,
+        comment: { ...comment, replies },
+        ancestors: ancestorsOf(said, comment),
     };
 }
+function replyNamed(context, document, url) {
+    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) {
+    let named;
+    try {
+        named = new URL(url, context.baseUrl);
+    }
+    catch {
+        return undefined;
+    }
+    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));
+}
+function heldAt(context, url) {
+    const post = documentNamed(context, url);
+    if (post === undefined || !isServed(post, context.store.now()))
+        return undefined;
+    if (url === absoluteUrl(post.permalink, context.baseUrl) || url === rootOf(context, post)) {
+        return { kind: 'document', post, author: documentAuthor(context, post) };
+    }
+    const said = gather(context, post);
+    const reply = namedIn(context, post, said, url);
+    if (reply === undefined || said.withdrawn.has(reply.id) || said.held.has(reply.id)) {
+        return undefined;
+    }
+    return { kind: 'reply', post, reply };
+}
+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(key);
+    if (document !== undefined) {
+        if (repliesKey(feedGuid(document, context.baseUrl)) === key) {
+            return repliesIn(context, document, null);
+        }
+        const root = threadRootOf(context, document);
+        return root === undefined ? undefined : repliesIn(context, root, key);
+    }
+    const comment = context.admin.getComment(key);
+    if (comment !== undefined) {
+        const post = context.store.getBySlug(comment.slug);
+        return post === undefined ? undefined : repliesIn(context, post, key);
+    }
+    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, key);
+    }
+    return undefined;
+}
+/**
+ * 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, key) {
+    if (!isServed(post, context.store.now()))
+        return undefined;
+    const thread = postConversation(context, post).replies;
+    const reply = key === null ? null : visibleReply(thread, key);
+    if (reply === undefined)
+        return undefined;
+    return {
+        post,
+        reply,
+        replies: repliesFed(reply?.replies ?? thread).map((entry) => ({ ...entry, parent: reply })),
+    };
+}
+function upstreamsOf(context, document) {
+    const top = threadRootOf(context, document) ?? document;
+    if (!isServed(top, context.store.now()))
+        return [];
+    const said = gather(context, top);
+    const site = new URL(context.baseUrl).origin;
+    const elsewhere = (url) => {
+        if (url === null || url === undefined)
+            return false;
+        try {
+            return new URL(url).origin !== site;
+        }
+        catch {
+            return false;
+        }
+    };
+    const found = [];
+    const posts = [
+        top,
+        ...said.written.flatMap((entry) => {
+            const post = entry.source === 'post' ? context.store.getByPermalink(entry.url ?? '') : undefined;
+            return post === undefined ? [] : [post];
+        }),
+    ];
+    for (const post of posts) {
+        if (!elsewhere(post.inReplyTo))
+            continue;
+        found.push({
+            post,
+            source: absoluteUrl(post.permalink, context.baseUrl),
+            target: post.inReplyTo,
+            replies: postConversation(context, post).replies,
+        });
+    }
+    const entries = new Map(said.written.map((entry) => [entry.id, entry]));
+    for (const entry of said.written) {
+        if (entry.source !== 'comment' || entry.inReplyTo === null)
+            continue;
+        const parent = entries.get(entry.inReplyTo);
+        if (parent?.source !== 'webmention' || !elsewhere(parent.url))
+            continue;
+        const page = commentThread(context, entry.id);
+        if (page === undefined)
+            continue;
+        found.push({
+            post: page.post,
+            source: absoluteUrl(commentPageHref(entry.id), context.baseUrl),
+            target: parent.url,
+            replies: page.comment.replies,
+        });
+    }
+    return found;
+}
+/**
+ * The document whose conversation a URL is in: the post a comment's page or
+ * anchor is on, the post a webmention was sent to, the post a fediverse reply
+ * answers however deep, or the document at the URL itself.
+ */
+function documentNamed(context, url, depth = 0) {
+    if (depth > MAXIMUM_NOTE_DEPTH)
+        return undefined;
+    let named;
+    try {
+        named = new URL(url);
+    }
+    catch {
+        return undefined;
+    }
+    if (named.origin === new URL(context.baseUrl).origin) {
+        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)[0] ?? heldComment(context.admin, named.href);
+    if (comment !== undefined)
+        return context.store.getBySlug(comment.slug);
+    for (const activity of context.admin.listActivitiesAbout([named.href])) {
+        const reply = replyFrom(activity);
+        if (reply?.id !== named.href)
+            continue;
+        return documentNamed(context, reply.inReplyTo, depth + 1);
+    }
+    return context.store.getByStoredObjectId(named.href);
+}
+/**
+ * The document at the top of the conversation a reply post is in: what its
+ * `in-reply-to` names, and what that one is in when it is a reply post too.
+ * `undefined` for a reply post answering nothing on this site.
+ */
+function threadRootOf(context, document, seen = new Set()) {
+    seen.add(document.path);
+    if (document.inReplyTo === undefined)
+        return undefined;
+    const named = documentNamed(context, document.inReplyTo);
+    if (named === undefined || seen.has(named.path))
+        return undefined;
+    return threadRootOf(context, named, seen) ?? named;
+}
+/** How many notes deep a reply is followed back to the post it is about. */
+const MAXIMUM_NOTE_DEPTH = 32;
+/**
+ * What a top-level answer names. The object id when the post has one, and the
+ * permalink otherwise: a post that has never been delivered can still have
+ * native comments, and they have to hang off something.
+ */
+function rootOf(context, document) {
+    return activityStreamsId(document, context.baseUrl) ?? document.permalink;
+}
+/**
+ * Every URL a reply post's `in-reply-to` could name something here by, and the
+ * id each one names: the post by its permalink, every URL it used to live at
+ * and its object id, and every entry by its id, its url and, for a comment
+ * written here, its page and its anchor.
+ */
+function namesIn(context, document, root, replies) {
+    const permalink = absoluteUrl(document.permalink, context.baseUrl);
+    const former = (document.redirectFrom ?? []).map((url) => absoluteUrl(url, context.baseUrl));
+    const names = new Map([permalink, ...former, root].map((url) => [url, root]));
+    for (const reply of replies) {
+        for (const name of namesOf(reply, permalink, context.baseUrl)) {
+            if (!names.has(name))
+                names.set(name, reply.id);
+        }
+    }
+    return names;
+}
+function namesOf(reply, permalink, baseUrl) {
+    const names = [reply.id];
+    if (reply.url !== null)
+        names.push(absoluteUrl(reply.url, baseUrl));
+    if (reply.source === 'comment')
+        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 {
+        ...unstored(id),
+        source: 'post',
+        kind: 'reply',
+        author: documentAuthor(context, post),
+        url: post.permalink,
+        content: post.html,
+        published: new Date(post.date ?? post.updated ?? 0),
+        inReplyTo,
+        status: 'published',
+        replies: [],
+    };
+}
+/** Who a post or page on this site is by: its author, else the site's. */
+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 ?? 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 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 = commentKeyAt(url.pathname);
+    if (onItsPage !== undefined)
+        return onItsPage;
+    const anchor = `#${commentAnchor('')}`;
+    if (url.pathname !== post.pathname || !url.hash.startsWith(anchor))
+        return undefined;
+    return url.hash.slice(anchor.length);
+}
+/**
+ * What a reply answers, from the top of the thread down to its parent.
+ *
+ * An ancestor a reader may not see is a `null`, and the walk goes on through
+ * what that one answered when the site still knows it: a pending or spam
+ * comment is in the index, and a withdrawn note is still in the log. A deleted
+ * comment is known by nothing, so the chain stops at it and goes straight to
+ * the post. Each id is visited once, so a cycle ends.
+ */
+function ancestorsOf(said, reply) {
+    const all = new Map(said.written.map((entry) => [entry.id, entry]));
+    const chain = [];
+    const seen = new Set([reply.id]);
+    for (let target = reply.inReplyTo; target !== null && target !== said.root;) {
+        if (seen.has(target))
+            break;
+        seen.add(target);
+        const known = all.get(target);
+        if (known !== undefined && !said.withdrawn.has(target)) {
+            chain.unshift(known);
+            target = known.inReplyTo;
+            continue;
+        }
+        chain.unshift(null);
+        target = (known ?? said.held.get(target))?.inReplyTo ?? null;
+    }
+    return chain;
+}
 function rsvpGroups(answers) {
     const people = latestAnswerPerPerson(answers);
     return RSVP_GROUP_ORDER.map((value) => ({
@@ -196,6 +557,9 @@ function siteConversation(context, limit) {
     const naming = authorNaming(context.admin);
     const posts = new PostsByObjectId(context);
     const now = context.store.now();
+    const policy = commentPolicyOf(readSiteJson(context.contentDir));
+    // A page that takes no comments shows none, so the site's feed has none of its.
+    const shown = (post) => post !== undefined && isListed(post, now) && answerable(post, policy, now);
     const said = [];
     for (let offset = 0; said.length < limit;) {
         const page = context.admin.listReplies({ limit: limit * OVERSCAN, offset });
@@ -204,10 +568,12 @@ 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;
-            const post = posts.get(reply.inReplyTo);
-            if (post === undefined || !isListed(post, now))
+            // 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.
+            const post = documentNamed(context, reply.inReplyTo);
+            if (!shown(post))
                 continue;
             said.push({ ...federatedInteraction(reply, naming(activity.actorId)), post });
             if (said.length === limit)
@@ -218,37 +584,62 @@ function siteConversation(context, limit) {
     // approval per quote, and a site has few enough to read whole.
     for (const approval of readAllQuoteAuthorizations(context.contentDir)) {
         const post = posts.get(approval.post);
-        if (post === undefined || !isListed(post, now))
+        if (!shown(post))
             continue;
         for (const quote of quotesOf(context.admin, [approval], approval.post, naming)) {
             said.push({ ...quote, 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(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 (post === undefined || !isListed(post, now))
+        if (!shown(post))
             continue;
-        said.push({ ...interactionOf(stored, post.permalink), post });
+        const entry = placedOn(post).get(stored.id);
+        if (entry !== undefined)
+            said.push({ ...entry, post });
     }
-    return newestFirst(said, limit);
-}
-/** How many answers each of these posts has, by permalink. */
-function commentCounts(context, documents) {
-    const counts = new Map();
-    const approvals = readAllQuoteAuthorizations(context.contentDir);
-    const naming = authorNaming(context.admin);
-    for (const document of documents) {
-        const objectId = activityStreamsId(document, context.baseUrl);
-        const federated = objectId === undefined
-            ? 0
-            : context.admin.countRepliesTo(objectId) +
-                quotesOf(context.admin, approvals, objectId, naming).length;
-        counts.set(document.permalink, federated + context.admin.countCommentsFor(document.slug, 'approved'));
+    // 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 })) {
+        const post = threadRootOf(context, answer);
+        if (!shown(post))
+            continue;
+        const reply = placedOn(post).get(rootOf(context, answer));
+        if (reply !== undefined)
+            said.push({ ...reply, post });
     }
-    return counts;
+    return newestFirst(said.filter(conversational), limit).map((entry) => {
+        const thread = placedOn(entry.post);
+        return {
+            ...(thread.get(entry.id) ?? { ...entry, parent: null }),
+            post: entry.post,
+            replyingTo: entry.inReplyTo === null ? null : (thread.get(entry.inReplyTo)?.author.name ?? null),
+        };
+    });
+}
+/** How many visible replies answer each of these documents directly, by permalink. */
+function directCounts(context, documents) {
+    return new Map(documents.map((document) => [
+        document.permalink,
+        repliesFed(postConversation(context, document).replies).length,
+    ]));
 }
 /**
  * How many candidates a site-wide page reads for each one it keeps.
@@ -281,7 +672,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),
@@ -302,7 +693,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,
@@ -316,42 +707,41 @@ function federatedInteraction(reply, author) {
         replies: [],
     };
 }
-/**
- * The approved native comments on a post, as interactions, oldest first.
- *
- * Only approved ones. A comment waiting for a moderator and one filed as spam
- * are both in the file and both in the index, and neither is anything a reader
- * should be shown — which is the whole difference between this and what the
- * moderation screen asks for.
- */
-function approvedComments(admin, document) {
-    return admin
-        .listCommentsFor(document.slug)
-        .filter((comment) => comment.status === 'approved')
-        .map((comment) => interactionOf(comment, document.permalink));
+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,
-        },
-        // Where it can be read. A comment written here lives here, at its own
-        // anchor; 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
+        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
         // working link for either, and so does a feed.
-        url: comment.url ?? `${permalink}#${commentAnchor(comment.id)}`,
+        url: comment.url ??
+            (comment.source === 'comment'
+                ? commentPageHref(comment.id)
+                : `${permalink}#${commentAnchor(comment.id)}`),
         content: comment.content.html,
         published: new Date(comment.submitted),
         inReplyTo: comment.inReplyTo,
@@ -363,33 +753,71 @@ function interactionOf(comment, permalink) {
     };
 }
 /**
- * The `id` a comment is anchored at on the page.
+ * The stored comment holding a fediverse note or activity id as its origin:
+ * one imported from the site this one replaced, keyed by that id as it would
+ * have been had it arrived here (TASK-336). A delivery or a fetch of the same
+ * id is that comment again, and the stored one wins, since it is the one the
+ * moderator decided on and the thread anchors.
+ */
+export function heldComment(admin, id) {
+    const comment = admin.getComment(repliesKey(id));
+    return comment?.origin === id ? comment : undefined;
+}
+/**
+ * The `id` a thread entry is anchored at on the page, by its key.
  *
  * 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}`;
+export function commentAnchor(key) {
+    return `comment-${key}`;
+}
+/** The key of the comment whose page a path is, or `undefined` (TASK-319). */
+export function commentKeyAt(pathname) {
+    if (!pathname.startsWith(COMMENT_PAGE_PREFIX) || !pathname.endsWith('/'))
+        return undefined;
+    const key = pathname.slice(COMMENT_PAGE_PREFIX.length, -1);
+    return isKey(key) ? key : undefined;
+}
+/** 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),
+    ];
 }
 /**
- * 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.
+ * 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.
  */
-export function spokenIn(conversation) {
-    const said = [...conversation.mentions];
-    const walk = (replies) => {
-        for (const reply of replies) {
-            said.push(reply);
-            walk(reply.replies);
-        }
-    };
-    walk(conversation.replies);
-    return said;
+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) => [
+        { ...reply, parent },
+        ...placed(reply.replies, reply),
+    ]);
+}
+/**
+ * The visible replies directly under an entry of a thread (TASK-324): a
+ * hidden comment's visible replies count as its parent's, as {@link Placed}
+ * says, so every visible reply is directly under exactly one thing.
+ */
+function directReplies(replies) {
+    return replies.flatMap((reply) => (isWithheld(reply) ? directReplies(reply.replies) : [reply]));
+}
+/** 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`,
@@ -401,16 +829,43 @@ export function spokenIn(conversation) {
  * moment before it becomes bytes this site publishes.
  */
 export function feedComments(said, options) {
-    return newestFirst([...said], options.limit).map((entry) => ({
-        id: entry.id,
-        url: absoluteUrl(entry.url ?? '/', options.baseUrl),
-        author: entry.author.name,
-        published: entry.published,
-        html: entry.content,
-        ...(entry.post === undefined
-            ? {}
-            : { post: { title: postLabel(entry.post, options.cited), permalink: entry.post.permalink } }),
-    }));
+    const { baseUrl } = options;
+    return newestFirst([...said], options.limit).map((entry) => {
+        const thread = entry.post ?? options.post;
+        const answered = entry.parent === null
+            ? thread === undefined
+                ? undefined
+                : feedGuid(thread, baseUrl)
+            : entry.parent.guid;
+        const replies = repliesFed(entry.replies);
+        return {
+            id: entry.guid,
+            url: absoluteUrl(entry.url ?? '/', baseUrl),
+            author: entry.author.name,
+            published: entry.published,
+            html: entry.content,
+            ...(answered === undefined ? {} : { inReplyTo: answered }),
+            ...(replies.length === 0
+                ? {}
+                : {
+                    replies: {
+                        count: replies.length,
+                        feed: absoluteUrl(repliesFeedPath(entry.key), baseUrl),
+                    },
+                }),
+            ...(entry.author.feed === null
+                ? {}
+                : { authorFeed: absoluteUrl(entry.author.feed, baseUrl) }),
+            ...(entry.post === undefined
+                ? {}
+                : {
+                    post: { title: postLabel(entry.post, options.cited), permalink: entry.post.permalink },
+                }),
+            ...(entry.replyingTo === undefined || entry.replyingTo === null
+                ? {}
+                : { replyingTo: entry.replyingTo }),
+        };
+    });
 }
 /** The newest `limit` of a mixed list, which is the order every feed shows. */
 function newestFirst(said, limit) {
@@ -464,80 +919,121 @@ class PostsByObjectId {
     }
 }
 /**
- * The replies as a thread: those answering the post at the top, each carrying
- * the replies that answer it, oldest first at every level.
+ * The replies as a thread: those answering `under` at the top, each carrying
+ * the replies that answer it, oldest first at every level. `under` is the
+ * post, or one reply for that reply's own page.
  *
- * Three things decide where a reply goes, and all three are what somebody
+ * Four things decide where a reply goes, and all four are what somebody
  * reading the page would expect:
  *
  * - A reply whose target is gone — deleted by its author — is shown under
  *   whatever *that* was answering, rather than disappearing with it. The
  *   conversation stays readable and only the withdrawn note is missing.
+ * - A reply answering a native comment a reader may not see (TASK-325) is
+ *   shown under a placeholder for it, the way the reply's own page shows it.
+ *   A comment waiting for a moderator or filed as spam still says what it
+ *   answers, and the placeholder goes there; a deleted one is known by
+ *   nothing, so its placeholder goes under the post. A hidden comment nobody
+ *   visible answered gets no placeholder at all.
  * - A reply answering something that is no part of this conversation is left
  *   out. The log holds it because it named something this walk asked about — a
  *   note answering the like of a post is the shape of that — but the post is
  *   not what it is talking about.
  * - A note the site was told about twice is one reply, because the map is
  *   keyed by the note's own id.
+ *
+ * The walk is bounded by the number of notes, and a placeholder is made once,
+ * so a log carrying a cycle — two notes each claiming to answer the other,
+ * which nothing stops a remote server from sending — ends rather than hangs.
  */
-function threadOf(written, objectId, withdrawn) {
-    const byId = new Map();
+function threadOf(said, under = said.root) {
+    const shown = new Map();
     const targets = new Map();
-    for (const reply of written) {
-        targets.set(reply.id, reply.inReplyTo ?? objectId);
-        if (!withdrawn.has(reply.id))
-            byId.set(reply.id, reply);
+    for (const reply of said.written) {
+        targets.set(reply.id, reply.inReplyTo ?? said.root);
+        if (!said.withdrawn.has(reply.id))
+            shown.set(reply.id, reply);
     }
     const top = [];
-    for (const reply of byId.values()) {
-        const parent = surviving(reply, targets, byId, objectId);
-        if (parent === undefined)
-            continue;
-        (parent === null ? top : parent.replies).push(reply);
+    const withheld = new Map();
+    // The list an entry answering `target` joins, or `undefined` for one that
+    // belongs somewhere else. Only a native entry can answer a deleted comment:
+    // a fediverse note naming an unknown id is answering something else.
+    const siblings = (target, self, native) => {
+        for (let step = 0; step <= targets.size; step += 1) {
+            if (target === undefined)
+                return undefined;
+            if (target === under)
+                return top;
+            if (target === said.root)
+                return undefined;
+            const parent = shown.get(target);
+            if (parent !== undefined)
+                return parent.id === self ? undefined : parent.replies;
+            if (said.held.has(target) || (native && !targets.has(target))) {
+                return placeholder(target)?.replies;
+            }
+            target = targets.get(target);
+        }
+        return undefined;
+    };
+    const placeholder = (id) => {
+        if (withheld.has(id))
+            return withheld.get(id);
+        withheld.set(id, undefined);
+        const list = siblings(said.held.get(id)?.inReplyTo ?? said.root, id, true);
+        if (list === undefined)
+            return undefined;
+        const key = isKey(id) ? id : repliesKey(id);
+        const entry = { id, key, withheld: true, replies: [] };
+        list.push(entry);
+        withheld.set(id, entry);
+        return entry;
+    };
+    for (const reply of shown.values()) {
+        siblings(targets.get(reply.id), reply.id, reply.source !== 'activitypub')?.push(reply);
     }
     return top;
 }
-/**
- * The reply a reply hangs under: `null` for the post itself, the nearest
- * surviving ancestor for one whose own target was deleted, and `undefined` for
- * a note that is answering something else entirely.
- *
- * The walk is bounded by the number of notes, so a log carrying a cycle — two
- * notes each claiming to answer the other, which nothing stops a remote server
- * from sending — ends rather than hangs.
- */
-function surviving(reply, targets, byId, objectId) {
-    let target = targets.get(reply.id);
-    for (let step = 0; step <= targets.size; step += 1) {
-        if (target === undefined)
-            return undefined;
-        if (target === objectId)
-            return null;
-        const parent = byId.get(target);
-        if (parent !== undefined)
-            return parent === reply ? undefined : parent;
-        // The target is not a reply the site is showing: either a note its author
-        // deleted, whose own target this reply moves to, or nothing to do with the
-        // post at all.
-        target = targets.get(target);
+/** The entry of a thread with this key that a reader can see, at any depth. */
+export function visibleReply(replies, key) {
+    for (const reply of replies) {
+        if (!isWithheld(reply) && reply.key === key)
+            return reply;
+        const found = visibleReply(reply.replies, key);
+        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();
 }
+/**
+ * When a thread entry starts: a reply's own date, and a placeholder's first
+ * visible reply's, since the date of a hidden comment is not the reader's.
+ */
+function startOf(reply) {
+    if (!isWithheld(reply))
+        return reply.published.getTime();
+    const [first] = reply.replies;
+    return first === undefined ? 0 : startOf(first);
+}
 /** Put every level of a thread in time order, all the way down. */
 function sortThread(replies) {
-    replies.sort(byPublished);
     for (const reply of replies)
         sortThread(reply.replies);
+    replies.sort((left, right) => startOf(left) - startOf(right));
 }
-/** How many replies a thread holds, counting all the way down. */
+/** How many visible replies a thread holds, counting all the way down. */
 function countReplies(replies) {
     let total = 0;
     for (const reply of replies)
-        total += 1 + countReplies(reply.replies);
+        total += (isWithheld(reply) ? 0 : 1) + countReplies(reply.replies);
     return total;
 }
 /** The two reactions, as the activity types they arrive as. */
@@ -555,10 +1051,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)) {
@@ -639,6 +1135,8 @@ function authorNaming(admin) {
             url: profile?.url ?? actorId,
             avatar: icon === null ? null : avatarHref(icon),
             actorId,
+            feed: null,
+            username: null,
         };
         known.set(actorId, author);
         return author;