diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index 69f8d90a..0570cca4 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import Link from "next/link";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useAccount, useConfig } from "wagmi";
 import { getWalletClient } from "wagmi/actions";
 import WalletAvatar from "@/components/WalletAvatar";
@@ -10,6 +10,7 @@ import { useLive } from "./LiveProvider";
 import { toast } from "./TxToasts";
 import { btn } from "@/components/ui";
 import { buildModMessage, buildPostMessage, buildReportMessage, POST_MAX, REPORT_REASONS, validateBody, type ReportReason } from "@/lib/launchpad/posts";
+import { COMMENTS_PAGE, clearDraft, groupReplies, initialPostsLoadState, loadCommentDraft, nextPostsLoadState, resolveReplyTarget, saveDraft, shouldIgnoreLoad, visibleTopIds } from "@/lib/launchpad/post-threads";
 import type { PostRow } from "@/lib/launchpad/postsServer";
 import { ago, nowMs } from "@/lib/launchpad/time";
 import { CHAINS, CHAIN_SHORT, shortAddr, type ChainKey } from "@/lib/chainPublic";
@@ -51,25 +52,79 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   const [busy, setBusy] = useState(false);
   const [err, setErr] = useState<string | null>(null);
   const [now, setNow] = useState(0);
+  const [shownCount, setShownCount] = useState(COMMENTS_PAGE);
+  // True once the first load() for the current chain/token has settled.
+  // A restored replyTo cannot be validated until then: posts starts empty, so
+  // an empty list must not read as "parent missing" before the fetch, nor as
+  // "parent exists" for signing. Submit of a restored reply blocks meanwhile.
+  // loadError arms the Retry button; postsLoaded stays false on failure so a
+  // restored reply keeps pending and the draft is never silently top-level.
+  const [{ postsLoaded, loadError }, setLoadState] = useState(initialPostsLoadState);
+  // Draft restores async after hydration so server and client render the same empty composer first.
+  // The loaded value is always assigned (even when empty) so text typed for one
+  // token can never leak into — and be submitted from — another token's composer.
+  // The reply destination restores with the body: otherwise a reload turns a
+  // reply draft into a top-level post (parentId: null).
+  useEffect(() => {
+    const t = setTimeout(() => {
+      const d = loadCommentDraft(chain, token);
+      setBody(d.body.slice(0, POST_MAX));
+      setReplyTo(d.parentId);
+      setShownCount(COMMENTS_PAGE);
+      setPosts([]);
+      setLoadState(initialPostsLoadState);
+      setErr(null);
+    }, 0);
+    return () => clearTimeout(t);
+  }, [chain, token]);
   const seenPosts = useRef<string>("");
   const isCreator = Boolean(address && address.toLowerCase() === launcher.toLowerCase());
+  // Guard against stale loads: a fetch for token A resolving after the switch
+  // to token B must not overwrite B's posts or unblock B's reply validation.
+  // Same generation + AbortController pattern as PriceChart.
+  const request = useRef<AbortController | null>(null);
+  const generation = useRef(0);
 
   const load = useCallback(async () => {
+    const id = ++generation.current;
+    request.current?.abort();
+    const controller = new AbortController();
+    request.current = controller;
+    const ignored = () => shouldIgnoreLoad(id, generation.current, controller.signal.aborted);
     try {
-      const res = await fetch(`/api/posts?chain=${chain}&token=${token}`, { cache: "no-store" });
-      if (!res.ok) return;
+      const res = await fetch(`/api/posts?chain=${chain}&token=${token}`, { cache: "no-store", signal: controller.signal });
+      if (ignored()) return;
+      if (!res.ok) {
+        // Failure, not proof of anything: keep postsLoaded false so a restored
+        // reply stays pending (submit blocks) and the draft keeps its destination.
+        setLoadState((prev) => nextPostsLoadState(prev, { kind: "http-error", status: res.status }));
+        return;
+      }
       const d = (await res.json()) as { posts: PostRow[]; muted: boolean };
+      if (!Array.isArray(d.posts)) {
+        if (ignored()) return;
+        setLoadState((prev) => nextPostsLoadState(prev, { kind: "invalid" }));
+        return;
+      }
+      if (ignored()) return;
       setPosts(d.posts);
       setMuted(d.muted);
       setNow(nowMs());
+      setLoadState((prev) => nextPostsLoadState(prev, { kind: "ok" }));
     } catch {
-      /* keep */
+      if (ignored()) return;
+      setLoadState((prev) => nextPostsLoadState(prev, { kind: "network-error" }));
     }
   }, [chain, token]);
 
   useEffect(() => {
-    const id = setTimeout(() => void load(), 0);
-    return () => clearTimeout(id);
+    const lifetime = generation;
+    const timer = setTimeout(() => void load(), 0);
+    return () => {
+      clearTimeout(timer);
+      lifetime.current++;
+      request.current?.abort();
+    };
   }, [load]);
   // refresh when the shared poller says there is a newer post on this token
   useEffect(
@@ -85,6 +140,13 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
     [subscribe, chain, token, load],
   );
 
+  // A restored reply target is validated only after the first successful load.
+  // Before that a restored reply is pending and submit blocks instead of signing
+  // an unvalidated parent. After load the truncated posts window (latest 100) is
+  // not authoritative — a missing id there does not mean the parent is gone, so
+  // we preserve the target and let the server decide (no silent top-level fallback).
+  const { target: effectiveReplyTo, pending: validationPending } = resolveReplyTarget(replyTo, postsLoaded);
+
   async function submit() {
     if (!address) return;
     const v = validateBody(body);
@@ -92,18 +154,26 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       setErr(v.error);
       return;
     }
+    // Re-resolve here: posts may have changed since the last render.
+    const resolved = resolveReplyTarget(replyTo, postsLoaded);
+    if (resolved.pending) {
+      setErr("Loading comments — please try again in a moment.");
+      return;
+    }
+    const target = resolved.target;
     setBusy(true);
     setErr(null);
     try {
       const n = nonce();
       const ts = nowMs();
-      const message = buildPostMessage({ chain, token, wallet: address, nonce: n, ts, parentId: replyTo, body: v.body });
+      const message = buildPostMessage({ chain, token, wallet: address, nonce: n, ts, parentId: target, body: v.body });
       const { signature } = await signed(config, chain, message);
-      const res = await fetch("/api/posts", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ chain, token, wallet: address, parentId: replyTo, body: v.body, nonce: n, ts, signature }) });
+      const res = await fetch("/api/posts", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ chain, token, wallet: address, parentId: target, body: v.body, nonce: n, ts, signature }) });
       const d = (await res.json()) as { ok?: boolean; post?: PostRow; error?: string };
       if (!res.ok || !d.post) throw new Error(d.error ?? "post rejected");
       setPosts((cur) => [d.post!, ...cur]);
       setBody("");
+      clearDraft(chain, token);
       setReplyTo(null);
     } catch (e) {
       setErr(friendlyError(e));
@@ -145,8 +215,9 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
     }
   }
 
-  const top = posts.filter((p) => p.parent_id === null);
-  const replies = (id: number) => posts.filter((p) => p.parent_id === id).slice().reverse();
+  const { top, repliesById } = useMemo(() => groupReplies(posts), [posts]);
+  const visibleTop = useMemo(() => visibleTopIds(top, shownCount), [top, shownCount]);
+  const remaining = top.length - visibleTop.length;
 
   return (
     <section className={embedded ? "overflow-hidden bg-paper" : "rounded-2xl bg-card border border-line overflow-hidden"} id="comments">
@@ -172,39 +243,72 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
           </div>
         ) : (
           <div className="space-y-2">
-            {replyTo !== null ? (
+            {validationPending ? (
+              <div className="space-y-1">
+                <p className="text-[11px] text-muted" role="status">
+                  Checking reply target…
+                </p>
+                {replyTo !== null ? (
+                  <p className="text-[11px] text-muted">
+                    Replying to #{replyTo}{" "}
+                    <button type="button" className="underline hover:text-ink" onClick={() => { setReplyTo(null); saveDraft(chain, token, body, null); }}>
+                      cancel
+                    </button>
+                  </p>
+                ) : null}
+                {loadError ? (
+                  <p className="text-[11px] text-down-ink" role="alert">
+                    {loadError}{" "}
+                    <button type="button" className="underline hover:text-ink" onClick={() => { setLoadState((prev) => ({ ...prev, loadError: null })); void load(); }}>
+                      Try again
+                    </button>
+                  </p>
+                ) : null}
+              </div>
+            ) : effectiveReplyTo !== null ? (
               <p className="text-[11px] text-muted">
-                Replying to #{replyTo}{" "}
-                <button type="button" className="underline hover:text-ink" onClick={() => setReplyTo(null)}>
+                Replying to #{effectiveReplyTo}{" "}
+                <button type="button" className="underline hover:text-ink" onClick={() => { setReplyTo(null); saveDraft(chain, token, body, null); }}>
                   cancel
                 </button>
               </p>
             ) : null}
             <textarea
               value={body}
-              onChange={(e) => setBody(e.target.value.slice(0, POST_MAX))}
+              onChange={(e) => {
+                const next = e.target.value.slice(0, POST_MAX);
+                setBody(next);
+                saveDraft(chain, token, next, effectiveReplyTo);
+              }}
               placeholder={`Say something about ${symbol}…`}
+              aria-label={`Comment about ${symbol}`}
+              aria-describedby={`comment-count-${chain}`}
               className="w-full rounded-xl bg-card border border-line-strong focus:border-brand focus:ring-4 focus:ring-brand/10 outline-none px-3 py-2 text-sm text-ink placeholder:text-faint min-h-16 resize-y"
             />
             <div className="flex items-center justify-between gap-3">
-              <span className="text-[11px] text-muted font-mono tnum">{POST_MAX - body.length}</span>
-              <button type="button" onClick={() => void submit()} disabled={busy || !body.trim()} className={btn.primarySm}>
-                {busy ? "Sign in wallet…" : replyTo !== null ? "Reply" : "Post"}
+              <span id={`comment-count-${chain}`} className="text-[11px] text-muted font-mono tnum">{POST_MAX - body.length}</span>
+              <button type="button" onClick={() => void submit()} disabled={busy || !body.trim() || validationPending} className={btn.primarySm}>
+                {busy ? "Sign in wallet…" : validationPending ? "Checking…" : effectiveReplyTo !== null ? "Reply" : "Post"}
               </button>
             </div>
-            {err ? <p className="text-xs text-down-ink">{err}</p> : null}
+            {POST_MAX - body.length <= 50 ? (
+              <p className="sr-only" role="status">{POST_MAX - body.length} characters remaining</p>
+            ) : null}
+            {err ? <p className="text-xs text-down-ink" role="alert">{err}</p> : null}
           </div>
         )}
       </div>
 
       <ul className="divide-y divide-line">
         {top.length === 0 ? <li className="px-4 py-8 text-center text-sm text-muted">No comments yet.</li> : null}
-        {top.map((p) => (
+        {visibleTop.map((p) => {
+          const thread = repliesById.get(p.id) ?? [];
+          return (
           <li key={p.id} className="px-4 py-3">
-            <PostItem p={p} now={now} canReply={isConnected && !muted} onReply={() => setReplyTo(p.id)} onReport={address && p.wallet !== address.toLowerCase() ? (r) => void report(p, r) : undefined} />
-            {replies(p.id).length ? (
+            <PostItem p={p} now={now} canReply={isConnected && !muted} onReply={() => { setReplyTo(p.id); if (body) saveDraft(chain, token, body, p.id); }} onReport={address && p.wallet !== address.toLowerCase() ? (r) => void report(p, r) : undefined} />
+            {thread.length ? (
               <ul className="mt-2 ml-6 pl-3 border-l border-line space-y-2">
-                {replies(p.id).map((r) => (
+                {thread.map((r) => (
                   <li key={r.id}>
                     <PostItem p={r} now={now} canReply={false} onReport={address && r.wallet !== address.toLowerCase() ? (x) => void report(r, x) : undefined} />
                   </li>
@@ -212,8 +316,22 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
               </ul>
             ) : null}
           </li>
-        ))}
+          );
+        })}
       </ul>
+      {remaining > 0 ? (
+        <div className="border-t border-line px-4 py-3 text-center">
+          <button
+            type="button"
+            onClick={() => setShownCount((n) => n + COMMENTS_PAGE)}
+            aria-label={`Show more comments, ${remaining} remaining, showing ${visibleTop.length} of ${top.length}`}
+            className="min-h-10 rounded-xl border border-line-strong px-4 text-sm font-medium text-ink hover:bg-card"
+          >
+            Show more
+          </button>
+          <p className="mt-1 text-[11px] text-muted" role="status">Showing {visibleTop.length} of {top.length} comments</p>
+        </div>
+      ) : null}
     </section>
   );
 }
diff --git a/app/src/lib/launchpad/post-threads.test.ts b/app/src/lib/launchpad/post-threads.test.ts
new file mode 100644
index 00000000..7a517aaf
--- /dev/null
+++ b/app/src/lib/launchpad/post-threads.test.ts
@@ -0,0 +1,136 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, initialPostsLoadState, loadCommentDraft, nextPostsLoadState, resolveReplyTarget, saveDraft, shouldIgnoreLoad, visibleTopIds } from "./post-threads.ts";
+import type { PostRow } from "./postsServer.ts";
+
+const post = (id: number, parent_id: number | null): PostRow => ({ id, chain: "base", token: "0xtoken", wallet: "0xwallet", parent_id, body: `body ${id}`, tag: null, created_at: "2026-01-01T00:00:00.000Z", reports: 0, hidden: false });
+
+test("groupReplies splits top-level from one-level replies, newest reply last", () => {
+  const posts = [post(3, null), post(2, 3), post(1, 3), post(4, null)];
+  const { top, repliesById } = groupReplies(posts);
+  assert.deepEqual(top.map((p) => p.id), [3, 4]);
+  assert.deepEqual(repliesById.get(3)!.map((p) => p.id), [1, 2], "server order (newest first) reverses to oldest-first under the comment");
+  assert.equal(repliesById.get(4), undefined);
+});
+
+test("groupReplies on empty / replies-only input", () => {
+  assert.deepEqual(groupReplies([]).top, []);
+  const { top, repliesById } = groupReplies([post(9, 7)]);
+  assert.deepEqual(top, []);
+  assert.deepEqual(repliesById.get(7)!.map((p) => p.id), [9]);
+});
+
+test("visibleTopIds paginates the top level", () => {
+  const top = [post(1, null), post(2, null), post(3, null)];
+  assert.deepEqual(visibleTopIds(top, 2).map((p) => p.id), [1, 2]);
+  assert.deepEqual(visibleTopIds(top, 99).map((p) => p.id), [1, 2, 3]);
+  assert.deepEqual(visibleTopIds(top, 0), []);
+  assert.equal(COMMENTS_PAGE, 20);
+});
+
+test("draft key is per token and lowercase; node loads empty and saves are no-ops", () => {
+  assert.equal(draftKey("base", "0xABC"), "ol:comment-draft:base:0xabc");
+  assert.notEqual(draftKey("base", "0xabc"), draftKey("robinhood", "0xabc"));
+  assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
+  saveDraft("base", "0xabc", "hello");
+  clearDraft("base", "0xabc");
+  assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null }, "no localStorage in node: always empty, never throws");
+});
+
+function withMemoryStorage(): Map<string, string> {
+  const store = new Map<string, string>();
+  const g = globalThis as Record<string, unknown>;
+  g.localStorage = {
+    getItem: (k: string) => (store.has(k) ? store.get(k)! : null),
+    setItem: (k: string, v: string) => void store.set(k, String(v)),
+    removeItem: (k: string) => void store.delete(k),
+  };
+  return store;
+}
+
+function withoutStorage(): void {
+  const g = globalThis as Record<string, unknown>;
+  delete g.localStorage;
+}
+
+test("draft restores both a top-level draft and a reply draft", () => {
+  const store = withMemoryStorage();
+  try {
+    saveDraft("base", "0xabc", "top-level hello");
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "top-level hello", parentId: null });
+
+    saveDraft("base", "0xabc", "reply hello", 42);
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "reply hello", parentId: 42 });
+
+    clearDraft("base", "0xabc");
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
+    assert.equal(store.size, 0);
+  } finally {
+    withoutStorage();
+  }
+});
+
+test("draft ignores non-JSON content and rejects bad parent ids; empty body stores nothing", () => {
+  const store = withMemoryStorage();
+  try {
+    store.set(draftKey("base", "0xabc"), "legacy hello");
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
+
+    store.set(draftKey("base", "0xabc"), JSON.stringify({ body: "x", parentId: -7 }));
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "x", parentId: null });
+
+    store.set(draftKey("base", "0xabc"), JSON.stringify({ body: "x", parentId: "42" }));
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "x", parentId: null });
+
+    // Clicking Reply with an empty composer must not leave "Replying to #x" behind.
+    saveDraft("base", "0xabc", "", 42);
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
+    assert.equal(store.has(draftKey("base", "0xabc")), false);
+
+    store.set(draftKey("base", "0xabc"), JSON.stringify({ body: "", parentId: 42 }));
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
+  } finally {
+    withoutStorage();
+  }
+});
+
+test("resolveReplyTarget blocks before first load and preserves reply after load", () => {
+  assert.deepEqual(resolveReplyTarget(null, false), { target: null, pending: false }, "top-level never blocks");
+  assert.deepEqual(resolveReplyTarget(null, true), { target: null, pending: false });
+  assert.deepEqual(resolveReplyTarget(42, false), { target: 42, pending: true }, "restored reply is pending before validation, never signed");
+  // After a successful load the posts window is truncated (latest 100). Absence there is not proof the parent was deleted.
+  assert.deepEqual(resolveReplyTarget(42, true), { target: 42, pending: false }, "preserve after load; server rejects if truly gone");
+});
+
+test("resolveReplyTarget preserves reply when validation has not completed", () => {
+  // Before validation (postsLoaded false) the draft stays pending even on failure (503 / network rejection) — no silent fallback
+  assert.deepEqual(resolveReplyTarget(100, false), { target: 100, pending: true }, "failed/no-load keeps pending so draft isn't lost");
+});
+
+test("shouldIgnoreLoad drops stale/aborted responses so token A cannot overwrite token B", () => {
+  // Token A starts load id 1; switching to B bumps generation to 2 and aborts A.
+  assert.equal(shouldIgnoreLoad(1, 1, false), false, "current generation, live request: apply");
+  assert.equal(shouldIgnoreLoad(1, 2, false), true, "older request resolving after token switch: ignore");
+  assert.equal(shouldIgnoreLoad(1, 2, true), true, "aborted request: ignore");
+  assert.equal(shouldIgnoreLoad(2, 2, true), true, "current generation but aborted: ignore");
+  assert.equal(shouldIgnoreLoad(2, 2, false), false, "newer request for the current token: apply");
+});
+
+test("nextPostsLoadState keeps a restored reply pending with Retry after 503/network failure", () => {
+  // Initial 503: postsLoaded stays false (reply stays pending, submit blocks), error arms Retry.
+  const after503 = nextPostsLoadState(initialPostsLoadState, { kind: "http-error", status: 503 });
+  assert.deepEqual(after503, { postsLoaded: false, loadError: "Could not load comments (503)." });
+  assert.deepEqual(resolveReplyTarget(42, after503.postsLoaded), { target: 42, pending: true }, "draft destination preserved, still pending — never silently top-level");
+
+  // Network rejection: same shape, connection hint.
+  const afterNet = nextPostsLoadState(initialPostsLoadState, { kind: "network-error" });
+  assert.deepEqual(afterNet, { postsLoaded: false, loadError: "Could not load comments. Check your connection." });
+  assert.deepEqual(resolveReplyTarget(42, afterNet.postsLoaded), { target: 42, pending: true });
+
+  // Retry succeeding clears the error and unblocks validation.
+  const recovered = nextPostsLoadState(after503, { kind: "ok" });
+  assert.deepEqual(recovered, { postsLoaded: true, loadError: null });
+
+  // Abort/stale completion leaves failure state untouched (no error wipe, no phantom load).
+  assert.equal(nextPostsLoadState(after503, { kind: "ignored" }), after503, "ignored outcomes return prev state");
+});
diff --git a/app/src/lib/launchpad/post-threads.ts b/app/src/lib/launchpad/post-threads.ts
new file mode 100644
index 00000000..02706c3e
--- /dev/null
+++ b/app/src/lib/launchpad/post-threads.ts
@@ -0,0 +1,165 @@
+import type { PostRow } from "./postsServer";
+
+/**
+ * Token-page comment threading + composer helpers (pure; unit-tested).
+ *
+ * TokenComments rendered every reply list with `posts.filter(p => p.parent_id
+ * === id)` per top-level post: O(n²) per render on a viral token. These
+ * helpers build the reply map once (O(n)) and own client pagination + draft
+ * persistence so the component stays thin.
+ */
+
+/** How many top-level comments render before "Show more". */
+export const COMMENTS_PAGE = 20;
+
+export function groupReplies(posts: PostRow[]): { top: PostRow[]; repliesById: Map<number, PostRow[]> } {
+  const top: PostRow[] = [];
+  const repliesById = new Map<number, PostRow[]>();
+  for (const p of posts) {
+    if (p.parent_id === null) top.push(p);
+    else {
+      const list = repliesById.get(p.parent_id);
+      if (list) list.push(p);
+      else repliesById.set(p.parent_id, [p]);
+    }
+  }
+  // Newest reply last under each comment (server sends newest first).
+  for (const list of repliesById.values()) list.reverse();
+  return { top, repliesById };
+}
+
+export function visibleTopIds(top: PostRow[], shownCount: number): PostRow[] {
+  return top.slice(0, Math.max(0, shownCount));
+}
+
+export function draftKey(chain: string, token: string): string {
+  return `ol:comment-draft:${chain}:${token.toLowerCase()}`;
+}
+
+/** Composer draft: body plus the reply destination (null = top-level post). */
+export type CommentDraft = { body: string; parentId: number | null };
+
+function cleanParentId(v: unknown): number | null {
+  return typeof v === "number" && Number.isInteger(v) && v > 0 ? v : null;
+}
+
+/** Load the full draft (body + reply target). Only the JSON shape is read; anything else is treated as no draft. */
+export function loadCommentDraft(chain: string, token: string): CommentDraft {
+  try {
+    if (typeof localStorage === "undefined") return { body: "", parentId: null };
+    const raw = localStorage.getItem(draftKey(chain, token));
+    if (!raw) return { body: "", parentId: null };
+    try {
+      const parsed = JSON.parse(raw) as { body?: unknown; parentId?: unknown };
+      if (parsed && typeof parsed === "object" && typeof parsed.body === "string") {
+        if (!parsed.body) return { body: "", parentId: null };
+        return { body: parsed.body, parentId: cleanParentId(parsed.parentId) };
+      }
+    } catch {
+      /* not a draft we wrote: ignore */
+    }
+    return { body: "", parentId: null };
+  } catch {
+    return { body: "", parentId: null };
+  }
+}
+
+export function saveDraft(chain: string, token: string, body: string, parentId: number | null = null): void {
+  try {
+    if (typeof localStorage === "undefined") return;
+    // An empty body stores nothing: clicking Reply alone must not leave a
+    // "Replying to #x" draft behind after a reload.
+    if (!body) {
+      localStorage.removeItem(draftKey(chain, token));
+      return;
+    }
+    const pid = cleanParentId(parentId);
+    localStorage.setItem(draftKey(chain, token), JSON.stringify({ body: body.slice(0, 2000), parentId: pid }));
+  } catch {
+    /* storage blocked: the in-memory textarea state is what survives */
+  }
+}
+
+export function clearDraft(chain: string, token: string): void {
+  try {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(draftKey(chain, token));
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Resolve a restored reply target against the loaded posts.
+ *
+ * Draft restoration and the initial posts fetch race: posts starts empty, so
+ * an empty list must not read as "parent missing" before the fetch, nor as
+ * "parent exists" for signing. While !postsLoaded a non-null replyTo is
+ * pending (caller blocks submit instead of signing an unvalidated parent).
+ *
+ * After loading the posts window is truncated (latest 100 rows). Absence in
+ * that window is not authoritative evidence the parent was deleted/hidden, so
+ * we preserve the saved destination and let the server reject it if truly gone.
+ * No silent top-level fallback — the user keeps their intended reply target
+ * unless we have checked it authoritatively.
+ */
+export function resolveReplyTarget(
+  replyTo: number | null,
+  postsLoaded: boolean,
+): { target: number | null; pending: boolean } {
+  if (replyTo === null) return { target: null, pending: false };
+  if (!postsLoaded) return { target: replyTo, pending: true };
+  // Window is truncated: missing from the latest 100 does not mean deleted.
+  // Preserve the target; server will return 404 if truly gone and the UI will
+  // surface that error instead of silently changing the destination.
+  return { target: replyTo, pending: false };
+}
+
+/**
+ * Stale-load guard for TokenComments.
+ *
+ * A fetch for token A resolving after the switch to token B must not touch
+ * B's posts or postsLoaded. The component bumps a generation counter on every
+ * token switch / cleanup and aborts the previous request; each load captures
+ * its id up front and checks this predicate before any state update. Pure so
+ * the out-of-order scenario is unit-testable without mounting the component
+ * (the repo harness is node:test on pure helpers, no React/jsdom setup).
+ */
+export function shouldIgnoreLoad(entryId: number, currentGeneration: number, aborted: boolean): boolean {
+  return aborted || entryId !== currentGeneration;
+}
+
+/** First-load status for the comments list. loadError set => Retry shown; postsLoaded stays false so a restored reply keeps pending (never silently top-level). */
+export type PostsLoadState = { postsLoaded: boolean; loadError: string | null };
+
+export const initialPostsLoadState: PostsLoadState = { postsLoaded: false, loadError: null };
+
+export type PostsLoadOutcome =
+  | { kind: "ok" }
+  | { kind: "http-error"; status: number }
+  | { kind: "invalid" }
+  | { kind: "network-error" }
+  | { kind: "ignored" };
+
+/**
+ * Reducer for the initial comments fetch.
+ *
+ * Failure paths preserve the draft and its reply destination: postsLoaded
+ * stays false (restored reply keeps pending, submit keeps blocking) and a
+ * loadError message arms the Retry button. Only "ok" flips postsLoaded and
+ * clears the error; "ignored" (abort/stale) leaves state untouched.
+ */
+export function nextPostsLoadState(prev: PostsLoadState, outcome: PostsLoadOutcome): PostsLoadState {
+  switch (outcome.kind) {
+    case "ok":
+      return { postsLoaded: true, loadError: null };
+    case "http-error":
+      return { postsLoaded: false, loadError: `Could not load comments (${outcome.status}).` };
+    case "invalid":
+      return { postsLoaded: false, loadError: "Could not load comments." };
+    case "network-error":
+      return { postsLoaded: false, loadError: "Could not load comments. Check your connection." };
+    case "ignored":
+      return prev;
+  }
+}