diff --git a/apps/web/app/components/variants.tsx b/apps/web/app/components/copies.tsx
similarity index 57%
rename from apps/web/app/components/variants.tsx
rename to apps/web/app/components/copies.tsx
index f571c8c..edcbdf3 100644
--- a/apps/web/app/components/variants.tsx
+++ b/apps/web/app/components/copies.tsx
@@ -1,14 +1,14 @@
 import { useEffect, useSyncExternalStore } from "react";
 import { Link } from "react-router";
 import { keyTextColor } from "~/lib/color";
+import type { Copy } from "~/lib/copies";
 import { diffPath } from "~/lib/paths";
 import { authorName } from "~/lib/profile";
 import { authorsState, serverAuthorsState, subscribeAuthors, wantAuthors } from "~/lib/profiles";
-import type { Standing } from "~/lib/spots";
-import type { Variant } from "~/lib/variants";
+import { type Standing, standingKey } from "~/lib/spots";
 import { AuthorAvatar } from "./author-avatar";
 
-export const VARIANTS_ID = "under-this-name";
+export const COPIES_ID = "other-copies";
 
 const asDate = (seconds: number): string => new Date(seconds * 1000).toISOString().slice(0, 10);
 
@@ -24,16 +24,27 @@ const said = (standing: Standing): string => {
 };
 
 /**
- * The other documents published under this page's identifier. Drawn dashed like
- * everything on this site that is available rather than settled: nobody vouches
- * for these, they exist, and existing is the whole point.
+ * The other documents that are copies of this one.
+ *
+ * One list, not two. Some of these were found publishing at this address and
+ * some by the tag their author wrote saying they started here, and that
+ * difference is how they were found rather than anything about them. What
+ * separates a copy worth reading from a document that only shares a name is the
+ * standing on its row, which is measured against the text.
+ *
+ * No sentence under the heading. The heading names the list, each row carries
+ * its author, its standing and its address, and a paragraph saying this site
+ * vouches for none of them would answer a suspicion nobody arrived with.
+ *
+ * Drawn dashed like everything on this site that is available rather than
+ * settled: these exist, and existing is the whole point.
  */
-export const Variants = ({
-  variants,
+export const Copies = ({
+  copies,
   standings,
   from,
 }: {
-  variants: Variant[];
+  copies: Copy[];
   standings: Record<string, Standing>;
   /** The document whose page this section sits on, and a comparison's base side. */
   from: { npub: string; identifier: string };
@@ -41,60 +52,57 @@ export const Variants = ({
   const authors = useSyncExternalStore(subscribeAuthors, authorsState, serverAuthorsState);
 
   useEffect(() => {
-    if (variants.length > 0) wantAuthors(variants.map((variant) => variant.pubkey));
-  }, [variants]);
+    if (copies.length > 0) wantAuthors(copies.map((copy) => copy.pubkey));
+  }, [copies]);
 
-  if (variants.length === 0) return null;
+  if (copies.length === 0) return null;
 
   return (
-    <section id={VARIANTS_ID} className="mt-16 border-t border-rule pt-8">
+    <section id={COPIES_ID} className="mt-16 border-t border-rule pt-8">
       <h2 className="font-mono text-[0.6875rem] uppercase tracking-[0.18em] text-muted">
-        Under this name
+        Other copies
       </h2>
-      <p className="mt-3 font-serif text-[0.9375rem] leading-relaxed text-muted">
-        Anyone may publish a document under this name. These are the other keys that have.
-      </p>
       <ul className="mt-5 space-y-3">
-        {variants.map((variant) => {
-          const author = authors[variant.pubkey] ?? null;
-          const standing = standings[variant.pubkey];
+        {copies.map((copy) => {
+          const author = authors[copy.pubkey] ?? null;
+          const standing = standings[standingKey(copy)];
           return (
             <li
-              key={variant.pubkey}
+              key={standingKey(copy)}
               className="flex gap-4 rounded-sm border border-dashed border-rule p-4 hover:border-muted"
             >
               <span className="mt-0.5 shrink-0">
-                <AuthorAvatar pubkey={variant.pubkey} picture={author?.picture ?? null} size={28} />
+                <AuthorAvatar pubkey={copy.pubkey} picture={author?.picture ?? null} size={28} />
               </span>
               <div className="min-w-0 flex-1">
                 <div className="flex items-baseline justify-between gap-4">
                   <span
                     className="truncate font-mono text-sm font-medium"
-                    style={{ color: keyTextColor(variant.pubkey) }}
+                    style={{ color: keyTextColor(copy.pubkey) }}
                   >
-                    {authorName(author, variant.npub)}
+                    {authorName(author, copy.npub)}
                   </span>
                   <time
-                    dateTime={new Date(variant.revisedAt * 1000).toISOString()}
+                    dateTime={new Date(copy.revisedAt * 1000).toISOString()}
                     className="shrink-0 font-mono text-xs text-muted"
                   >
-                    {asDate(variant.revisedAt)}
+                    {asDate(copy.revisedAt)}
                   </time>
                 </div>
                 <Link
-                  to={variant.path}
+                  to={copy.path}
                   className="mt-1.5 block font-mono text-base font-medium hover:underline hover:decoration-1 hover:underline-offset-4"
                 >
-                  {variant.title}
+                  {copy.title}
                 </Link>
-                {variant.summary !== "" && (
+                {copy.summary !== "" && (
                   <p className="mt-1.5 line-clamp-2 max-w-[38rem] font-serif text-sm leading-snug text-muted">
-                    {variant.summary}
+                    {copy.summary}
                   </p>
                 )}
                 <div className="mt-3 flex flex-wrap items-baseline gap-x-3 gap-y-1">
                   <Link
-                    to={diffPath(from.npub, from.identifier, variant.npub)}
+                    to={diffPath(from.npub, from.identifier, copy.npub, copy.identifier)}
                     title="This document, marked with what their copy changes"
                     className="inline-block rounded-sm border border-rule px-2 py-1 font-mono text-[0.6875rem] uppercase tracking-[0.14em] text-muted hover:border-muted hover:text-ink"
                   >
@@ -103,6 +111,11 @@ export const Variants = ({
                   {standing !== undefined && (
                     <span className="font-mono text-xs text-muted">{said(standing)}</span>
                   )}
+                  {/* Only where it differs. A copy at this document's own address
+                      would be repeating the line at the top of the page. */}
+                  {!copy.sameName && (
+                    <span className="font-mono text-xs text-muted">{copy.identifier}</span>
+                  )}
                 </div>
               </div>
             </li>
diff --git a/apps/web/app/components/copy-button.tsx b/apps/web/app/components/copy-button.tsx
index 914672d..d6eb644 100644
--- a/apps/web/app/components/copy-button.tsx
+++ b/apps/web/app/components/copy-button.tsx
@@ -10,11 +10,14 @@ export const CopyButton = ({
   value,
   label,
   title,
+  className = "rounded-sm border border-rule px-2 py-1 text-muted hover:border-muted hover:text-ink",
 }: {
   /** A string, or a way to go and get one: the event is fetched, not held. */
   value: string | (() => Promise<string>);
   label: string;
   title?: string;
+  /** The face it wears, so the same button reads as a row inside a menu. */
+  className?: string;
 }) => {
   const [state, setState] = useState<State>("idle");
   const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -35,12 +38,7 @@ export const CopyButton = ({
   };
 
   return (
-    <button
-      type="button"
-      onClick={copy}
-      title={title}
-      className="rounded-sm border border-rule px-2 py-1 text-muted hover:border-muted hover:text-ink"
-    >
+    <button type="button" onClick={copy} title={title} className={className}>
       <span aria-live="polite">
         {state === "idle" ? label : state === "copied" ? "Copied" : "Copy failed"}
       </span>
diff --git a/apps/web/app/components/editor/spec-editor.tsx b/apps/web/app/components/editor/spec-editor.tsx
index 12ee23f..bd8b2ed 100644
--- a/apps/web/app/components/editor/spec-editor.tsx
+++ b/apps/web/app/components/editor/spec-editor.tsx
@@ -1,23 +1,37 @@
 import {
+  type EventDraft,
   editSpec,
+  type ForkOrigin,
   fetchSpec,
   firstHeading,
+  forkSpec,
   type NostrEvent,
   type SpecDraft,
   type SpecFault,
   specDraftOf,
   specFaults,
   specPath,
+  tagValue,
+  toCoordinate,
   toIdentifier,
+  toNpub,
 } from "@openspecs/nostr";
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Link } from "react-router";
 import { RelayReport } from "~/components/relay-results";
 import { rememberSpec } from "~/lib/corpus";
 import { specEditPath } from "~/lib/paths";
+import { authorName } from "~/lib/profile";
+import { authorsState, serverAuthorsState, subscribeAuthors, wantAuthors } from "~/lib/profiles";
 import { type RelayResult, signAndPublish } from "~/lib/publish";
 import { documentRelays } from "~/lib/relays";
-import { clearDraft, readDraft, type StoredDraft, writeDraft } from "~/lib/spec-draft-store";
+import {
+  clearDraft,
+  type DraftSlot,
+  readDraft,
+  type StoredDraft,
+  writeDraft,
+} from "~/lib/spec-draft-store";
 import {
   ACTION,
   DocumentField,
@@ -38,6 +52,9 @@ type State = "editing" | "sending" | "sent" | "failed";
 /** Long enough that a sentence is one write rather than forty. */
 const SAVE_AFTER_MS = 800;
 
+/** Long enough that typing an address is one question to the relays, not a dozen. */
+const ASK_AFTER_MS = 600;
+
 const SAYING: Record<SpecFault, string> = {
   "no-identifier": "A document needs an address to be found under.",
   "no-title": "A document needs a title. It is what every listing and link preview shows.",
@@ -92,6 +109,35 @@ const Held = ({
   </div>
 );
 
+/**
+ * Whose document this one is starting from, and nothing else. The form below is
+ * already full of somebody else's writing, so the one thing it does not show is
+ * whose. That a document signed by one key does not change another's needs no
+ * saying, and the tag recording it is not the reader's business.
+ */
+const ForkedFrom = ({ origin }: { origin: NostrEvent }) => {
+  const authors = useSyncExternalStore(subscribeAuthors, authorsState, serverAuthorsState);
+  const npub = toNpub(origin.pubkey);
+  const identifier = tagValue(origin, "d");
+
+  useEffect(() => {
+    wantAuthors([origin.pubkey]);
+  }, [origin.pubkey]);
+
+  return (
+    <p className={NOTE}>
+      Starting from{" "}
+      <Link
+        to={specPath({ pubkey: origin.pubkey, identifier })}
+        className="underline decoration-rule underline-offset-2 hover:decoration-current"
+      >
+        {tagValue(origin, "title") || identifier}
+      </Link>{" "}
+      by {authorName(authors[origin.pubkey] ?? null, npub)}.
+    </p>
+  );
+};
+
 /**
  * A document replaces the whole of its previous revision, so what is on screen
  * has to be what was published: the fields start filled from the live event, and
@@ -105,42 +151,95 @@ export const SpecEditor = ({
   me,
   npub,
   live: initial,
+  fork = null,
 }: {
   me: string;
   npub: string;
   /** The revision being edited, or null for a document nobody has published. */
   live: NostrEvent | null;
+  /** The document this one starts from, for a fork nobody has published yet. */
+  fork?: { origin: NostrEvent; relay: string | null } | null;
 }) => {
   const [live, setLive] = useState(initial);
-  const published = useMemo(() => specDraftOf(live), [live]);
+  // Read off `live` and never off the prop: publishing the fork makes it a
+  // document of its own, and every save after that is an ordinary revision.
+  const forking = live === null && fork !== null;
+  const origin = useMemo(
+    (): ForkOrigin | null =>
+      fork === null
+        ? null
+        : {
+            pubkey: fork.origin.pubkey,
+            // Read off the event rather than off the route, so the marker names
+            // what was actually signed.
+            identifier: tagValue(fork.origin, "d"),
+            relay: fork.relay,
+          },
+    [fork],
+  );
+  const published = useMemo(
+    () => (live === null && fork !== null ? specDraftOf(fork.origin) : specDraftOf(live)),
+    [live, fork],
+  );
   const [draft, setDraft] = useState<SpecDraft>(published);
-  // Only until somebody types one of their own. A published address never moves.
-  const [deriving, setDeriving] = useState(initial === null);
+  // Only until somebody types one of their own. A published address never moves,
+  // and neither does a fork's, which keeps the name it was forked from until its
+  // author decides otherwise.
+  const [deriving, setDeriving] = useState(initial === null && fork === null);
   const [state, setState] = useState<State>("editing");
   const [relays, setRelays] = useState<string[]>([]);
   const [results, setResults] = useState<RelayResult[]>([]);
   const [error, setError] = useState<string | null>(null);
   const [taken, setTaken] = useState<string | null>(null);
+  /**
+   * The last address found to already hold a document of the reader's own, asked
+   * of the relays as it is typed rather than when Publish is pressed. A fork
+   * arrives wearing the name it came from, so the collision is its ordinary case
+   * and not a slip, and an address is also the one field somebody changes to get
+   * out of trouble, which is no help if the trouble only shows at the end.
+   *
+   * Never a refusal by itself. The relays may be unreachable, in which case this
+   * stays quiet and the guard before the signer is what answers.
+   */
+  const [standing, setStanding] = useState<string | null>(null);
+  /** One question per address, however many times the editor comes back to it. */
+  const answered = useRef(new Map<string, boolean>());
   const [held, setHeld] = useState<StoredDraft | null>(null);
 
   const existing = live !== null;
   // The slot a draft is kept in, fixed for as long as this editor is open: a
   // first save turns a new document into an existing one, and the half written
   // draft it replaces is the one under the address it did not have yet.
-  const slot = useMemo(
-    () => (initial === null ? null : specDraftOf(initial).identifier),
-    [initial],
-  );
+  const slot = useMemo((): DraftSlot => {
+    if (initial !== null) return { of: "doc", identifier: specDraftOf(initial).identifier };
+    if (origin !== null) return { of: "fork", origin: toCoordinate(origin) };
+    return { of: "new" };
+  }, [initial, origin]);
+
+  /**
+   * The event this form would sign. A fork is built from the draft alone, never
+   * from the document it came from: see `forkSpec`. Only the first one is, and
+   * after it every revision is an ordinary edit that carries the marker through.
+   */
+  const build = (fields: SpecDraft): EventDraft =>
+    origin !== null && !existing ? forkSpec(origin, me, fields) : editSpec(live, fields);
 
   /**
    * Whether saving would say anything different, asked of the event rather than
    * of the form. A blank kind row, a repeated topic and a trailing space all
    * change the draft and none of them changes the document.
    */
-  const changed =
-    JSON.stringify(editSpec(live, draft)) !== JSON.stringify(editSpec(live, published));
+  const changed = JSON.stringify(build(draft)) !== JSON.stringify(build(published));
 
   const faults = specFaults(draft);
+  const wanted = draft.identifier.trim();
+  /**
+   * Known, not guessed: only an address the relays actually answered about. The
+   * guard before the signer would refuse this publish anyway, so an enabled
+   * button here promises a round trip that ends where the sentence beside the
+   * address already says it ends.
+   */
+  const clashes = standing !== null && wanted === standing;
   const suggested = toIdentifier(draft.title);
   // What the document is already shown under when it carries no title tag.
   const heading = draft.title === "" ? firstHeading(draft.content) : null;
@@ -156,6 +255,32 @@ export const SpecEditor = ({
     );
   }, [me, slot, published]);
 
+  useEffect(() => {
+    // A published address never moves, so there is nothing to ask about.
+    if (existing || wanted === "") return;
+
+    const known = answered.current.get(wanted);
+    if (known !== undefined) {
+      setStanding(known ? wanted : null);
+      return;
+    }
+
+    let live = true;
+    const timer = setTimeout(() => {
+      fetchSpec({ pubkey: me, identifier: wanted })
+        .then((found) => {
+          answered.current.set(wanted, found !== null);
+          if (live) setStanding(found === null ? null : wanted);
+        })
+        .catch(() => {});
+    }, ASK_AFTER_MS);
+
+    return () => {
+      live = false;
+      clearTimeout(timer);
+    };
+  }, [existing, me, wanted]);
+
   useEffect(() => {
     if (!changed) return;
     const timer = setTimeout(() => {
@@ -212,7 +337,7 @@ export const SpecEditor = ({
       const targets = documentRelays(me);
       targets.then(setRelays).catch(() => {});
 
-      const report = await signAndPublish(editSpec(live, draft), targets, (result) =>
+      const report = await signAndPublish(build(draft), targets, (result) =>
         setResults((answered) => [...answered, result]),
       );
 
@@ -246,6 +371,8 @@ export const SpecEditor = ({
      */
     <form className="lg:grid lg:grid-cols-[minmax(0,1fr)_16rem] lg:gap-12" onSubmit={save}>
       <div className="max-w-[40rem] space-y-4">
+        {forking && fork !== null && <ForkedFrom origin={fork.origin} />}
+
         {held !== null && (
           <Held
             held={held}
@@ -288,6 +415,16 @@ export const SpecEditor = ({
           }}
         />
 
+        {clashes && (
+          <p className={WRONG}>
+            You already publish a document at that address.{" "}
+            <Link to={specEditPath(npub, standing)} className="underline underline-offset-2">
+              Edit that one
+            </Link>
+            , or change the address above.
+          </p>
+        )}
+
         {/* Where the published page puts it: under the title, above the
             document, at the measure the rest of the prose is read at. */}
         <div className="pt-2">
@@ -317,16 +454,26 @@ export const SpecEditor = ({
           those pixels back and the padding puts the fields where they were. */}
       <aside className="mt-16 space-y-8 border-t border-rule pt-8 lg:-mx-1.5 lg:mt-0 lg:self-start lg:border-t-0 lg:px-1.5 lg:pt-0 lg:sticky lg:top-10 lg:max-h-[calc(100dvh-5rem)] lg:overflow-y-auto">
         <div className="space-y-3">
+          {/* A fork that changes nothing is still a real thing to publish: a copy
+              under your own key, which is what a mirror is. Everywhere else an
+              untouched form has nothing to send, and a blank one is refused by
+              its faults rather than by this. */}
           <button
             type="submit"
             className={ACTION}
-            disabled={!changed || faults.length > 0 || state === "sending"}
+            disabled={(!changed && !forking) || clashes || faults.length > 0 || state === "sending"}
           >
             {state === "sending" ? "Publishing" : existing ? "Publish revision" : "Publish"}
           </button>
 
           {!changed && state !== "sent" && (
-            <p className={NOTE}>{existing ? "Nothing to save yet." : "Nothing written yet."}</p>
+            <p className={NOTE}>
+              {forking
+                ? "Unchanged from the document you forked. Publishing it puts a copy of it under your key."
+                : existing
+                  ? "Nothing to save yet."
+                  : "Nothing written yet."}
+            </p>
           )}
           {state === "sent" && !changed && <p className={NOTE}>Published.</p>}
 
@@ -366,7 +513,9 @@ export const SpecEditor = ({
 
           {taken !== null && (
             <p className={WRONG}>
-              A document of yours is already published at that address.{" "}
+              {forking
+                ? "A fork keeps the name it was forked from, and this key already publishes a document under that name. "
+                : "A document of yours is already published at that address. "}
               <Link to={specEditPath(npub, taken)} className="underline underline-offset-2">
                 Edit that one
               </Link>
diff --git a/apps/web/app/components/moderation/more.tsx b/apps/web/app/components/moderation/more.tsx
index c691d3f..bd6da2b 100644
--- a/apps/web/app/components/moderation/more.tsx
+++ b/apps/web/app/components/moderation/more.tsx
@@ -1,12 +1,26 @@
+import { toNaddr, toNpub } from "@openspecs/nostr";
 import { useEffect, useState, useSyncExternalStore } from "react";
 import { CHROME } from "~/components/chrome";
+import { CopyButton } from "~/components/copy-button";
+import { Rebroadcast } from "~/components/rebroadcast";
 import { block, unblock, useBlocked } from "~/lib/blocked";
+import { eventPath } from "~/lib/paths";
 import { restoreSession, serverSessionState, sessionState, subscribeSession } from "~/lib/session";
 import { ReportForm } from "./report-form";
 import { SUGGESTION } from "./styles";
 
 export type MoreTarget =
-  | { kind: "document"; pubkey: string; id: string; coordinate: string; identifier: string }
+  | {
+      kind: "document";
+      pubkey: string;
+      id: string;
+      coordinate: string;
+      identifier: string;
+      /** This document's canonical URL, which the address bar already shows. */
+      canonical: string;
+      /** Where a republished copy of the event would be sent. */
+      relays: string[];
+    }
   | { kind: "comment"; pubkey: string; id: string }
   | { kind: "account"; pubkey: string };
 
@@ -19,15 +33,24 @@ const PANEL =
 const ROW = `${SUGGESTION} text-left`;
 
 /**
- * Report or block, behind one word, on a document, a comment and an account.
+ * Everything else there is to do with a document, a comment or an account,
+ * behind one word.
  *
- * Neither needs a key. Blocking is this browser deciding what it shows, and
- * the page or the comment flips to the notice that carries the undo, so the
- * menu closes on the click and says nothing more. A report from a reader with
- * no key is signed by one made for it; the form says what that is worth.
+ * A document's addresses and its signed event live here rather than in the row
+ * above it. Each of them serves whoever already knows what an naddr is, and a
+ * reading page that spends seven controls on that before its first paragraph is
+ * charging every reader for a few. The link is here too, because on a document's
+ * own page the address bar is already showing it.
  *
- * Nothing is offered on the reader's own words: a report on yourself is a
- * mistake and a block on yourself is a bug.
+ * Nothing here needs a key. Blocking is this browser deciding what it shows, and
+ * the page or the comment flips to the notice that carries the undo, so the menu
+ * closes on the click and says nothing more. A report from a reader with no key
+ * is signed by one made for it; the form says what that is worth.
+ *
+ * A report on yourself is a mistake and a block on yourself is a bug, so neither
+ * is offered on the reader's own words. On their own document the menu still
+ * opens, holding what is left: an author needs their document's address as much
+ * as anybody.
  */
 export const More = ({ target }: { target: MoreTarget }) => {
   useEffect(restoreSession, []);
@@ -36,7 +59,9 @@ export const More = ({ target }: { target: MoreTarget }) => {
   const [stage, setStage] = useState<Stage>("closed");
 
   const me = session.pubkey;
-  if (me !== null && me === target.pubkey) return null;
+  const mine = me !== null && me === target.pubkey;
+  // A comment or an account of the reader's own leaves nothing to put in it.
+  if (mine && target.kind !== "document") return null;
 
   const noun = target.kind;
   const accountBlocked = blocked.pubkeys.has(target.pubkey);
@@ -59,7 +84,11 @@ export const More = ({ target }: { target: MoreTarget }) => {
         type="button"
         onClick={() => setStage(stage === "closed" ? "menu" : "closed")}
         aria-expanded={stage !== "closed"}
-        title="Report or block"
+        title={
+          mine
+            ? "Addresses, and the signed event"
+            : "Addresses, republishing, reporting and blocking"
+        }
         className={CHROME}
       >
         More
@@ -67,7 +96,44 @@ export const More = ({ target }: { target: MoreTarget }) => {
 
       {stage === "menu" && (
         <div className={PANEL}>
-          <div className="flex flex-col items-start gap-2">
+          {target.kind === "document" && (
+            <div className="flex flex-col items-start gap-2">
+              <CopyButton
+                value={target.canonical}
+                label="Copy link"
+                title={target.canonical}
+                className={ROW}
+              />
+              <CopyButton
+                value={toNaddr({ pubkey: target.pubkey, identifier: target.identifier })}
+                label="Copy naddr"
+                title="The document's Nostr address, for any client"
+                className={ROW}
+              />
+              <CopyButton
+                value={() =>
+                  fetch(eventPath(toNpub(target.pubkey), target.identifier)).then((event) =>
+                    event.text(),
+                  )
+                }
+                label="Copy event"
+                title="The signed event, exactly as the relays serve it"
+                className={ROW}
+              />
+              <Rebroadcast
+                eventUrl={eventPath(toNpub(target.pubkey), target.identifier)}
+                relays={target.relays}
+                className={ROW}
+              />
+            </div>
+          )}
+
+          {/* Last, and behind a rule: the two that act on somebody rather than on
+              what this browser is holding. */}
+          <div
+            className={`flex flex-col items-start gap-2 ${target.kind === "document" && !mine ? "border-t border-rule pt-3" : ""}`}
+            hidden={mine}
+          >
             <button type="button" className={ROW} onClick={() => setStage("report")}>
               Report this {noun}
             </button>
diff --git a/apps/web/app/components/rebroadcast.tsx b/apps/web/app/components/rebroadcast.tsx
index 33ffe6c..54d03ca 100644
--- a/apps/web/app/components/rebroadcast.tsx
+++ b/apps/web/app/components/rebroadcast.tsx
@@ -9,7 +9,16 @@ type State = "idle" | "sending" | "done" | "failed";
  * every relay checks that signature itself. So this asks for no account, keeps
  * no session, and works the same in a private window.
  */
-export const Rebroadcast = ({ eventUrl, relays }: { eventUrl: string; relays: string[] }) => {
+export const Rebroadcast = ({
+  eventUrl,
+  relays,
+  className = "rounded-sm border border-rule px-2 py-1 text-muted hover:border-muted hover:text-ink disabled:hover:border-rule disabled:hover:text-muted",
+}: {
+  eventUrl: string;
+  relays: string[];
+  /** The face it wears, so the same button reads as a row inside a menu. */
+  className?: string;
+}) => {
   const [state, setState] = useState<State>("idle");
   const [results, setResults] = useState<RelayResult[]>([]);
 
@@ -35,7 +44,7 @@ export const Rebroadcast = ({ eventUrl, relays }: { eventUrl: string; relays: st
         onClick={send}
         disabled={state === "sending"}
         title={`Publish this event again to ${relays.length} relays`}
-        className="rounded-sm border border-rule px-2 py-1 text-muted hover:border-muted hover:text-ink disabled:hover:border-rule disabled:hover:text-muted"
+        className={className}
       >
         {state === "idle" ? "Rebroadcast" : state === "sending" ? "Sending" : "Rebroadcast again"}
       </button>
diff --git a/apps/web/app/lib/copies.test.ts b/apps/web/app/lib/copies.test.ts
new file mode 100644
index 0000000..b57d7b9
--- /dev/null
+++ b/apps/web/app/lib/copies.test.ts
@@ -0,0 +1,105 @@
+import { parseSpec, SPEC_KIND, type Spec, toNpub } from "@openspecs/nostr";
+import { describe, expect, it } from "vitest";
+import { selectCopies } from "./copies";
+
+const SHOWN = {
+  pubkey: "1336a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e",
+  identifier: "nip-07",
+};
+const OTHER = "2446a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
+const THIRD = "3556a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
+const HERE = `${SPEC_KIND}:${SHOWN.pubkey}:${SHOWN.identifier}`;
+
+const specOf = (
+  pubkey: string,
+  { identifier = SHOWN.identifier, content = "text", createdAt = 1, tags = [] as string[][] } = {},
+): Spec => {
+  const spec = parseSpec({
+    id: `${pubkey.slice(0, 4)}${createdAt}`.padEnd(64, "0"),
+    pubkey,
+    created_at: createdAt,
+    kind: SPEC_KIND,
+    tags: [["d", identifier], ["title", "NIP-07"], ...tags],
+    content,
+    sig: "b".repeat(128),
+  });
+  if (spec === null) throw new Error("the fixture does not parse as a document");
+  return spec;
+};
+
+const forkTag = (coordinate = HERE) => [["a", coordinate, "", "fork"]];
+
+describe("selectCopies", () => {
+  it("drops the key whose document the page already is", () => {
+    const copies = selectCopies([specOf(SHOWN.pubkey), specOf(OTHER)], SHOWN);
+    expect(copies.map((copy) => copy.pubkey)).toEqual([OTHER]);
+  });
+
+  it("drops blank records, the way listings do", () => {
+    expect(selectCopies([specOf(OTHER, { content: "  " })], SHOWN)).toEqual([]);
+  });
+
+  it("takes a copy that renamed itself, on the strength of its tag", () => {
+    const copies = selectCopies(
+      [specOf(OTHER, { identifier: "nip-07-mine", tags: forkTag() })],
+      SHOWN,
+    );
+    expect(copies.map((copy) => copy.identifier)).toEqual(["nip-07-mine"]);
+    expect(copies[0]?.sameName).toBe(false);
+  });
+
+  it("takes a renamed copy signed by this document's own key", () => {
+    const copies = selectCopies(
+      [specOf(SHOWN.pubkey, { identifier: "nip-07-again", tags: forkTag() })],
+      SHOWN,
+    );
+    expect(copies.map((copy) => copy.identifier)).toEqual(["nip-07-again"]);
+  });
+
+  it("lists a copy found both ways once", () => {
+    const both = specOf(OTHER, { tags: forkTag() });
+    expect(selectCopies([both, both], SHOWN).length).toBeGreaterThan(0);
+    const copies = selectCopies([both], SHOWN);
+    expect(copies).toHaveLength(1);
+    expect(copies[0]?.sameName).toBe(true);
+  });
+
+  it("keeps out what only cites the address", () => {
+    // Relays index an `a` tag's value and not the marker after it, so the query
+    // behind this hands back every one of these.
+    expect(
+      selectCopies([specOf(OTHER, { identifier: "x", tags: [["a", HERE, "", "update"]] })], SHOWN),
+    ).toEqual([]);
+    expect(selectCopies([specOf(OTHER, { identifier: "x", tags: [["a", HERE]] })], SHOWN)).toEqual(
+      [],
+    );
+  });
+
+  it("keeps out a fork of another document that shares this name", () => {
+    const elsewhere = `${SPEC_KIND}:${THIRD}:${SHOWN.identifier}`;
+    expect(
+      selectCopies([specOf(OTHER, { identifier: "x", tags: forkTag(elsewhere) })], SHOWN),
+    ).toEqual([]);
+  });
+
+  it("lists the newest revision first", () => {
+    const copies = selectCopies(
+      [specOf(OTHER, { createdAt: 1 }), specOf(THIRD, { createdAt: 2 })],
+      SHOWN,
+    );
+    expect(copies.map((copy) => copy.pubkey)).toEqual([THIRD, OTHER]);
+  });
+
+  it("carries what a row draws", () => {
+    const [copy] = selectCopies([specOf(OTHER, { createdAt: 7 })], SHOWN);
+    expect(copy).toMatchObject({
+      pubkey: OTHER,
+      npub: toNpub(OTHER),
+      identifier: "nip-07",
+      title: "NIP-07",
+      revisedAt: 7,
+      path: `/spec/${toNpub(OTHER)}/nip-07`,
+      sameName: true,
+    });
+  });
+});
diff --git a/apps/web/app/lib/copies.ts b/apps/web/app/lib/copies.ts
new file mode 100644
index 0000000..0a72636
--- /dev/null
+++ b/apps/web/app/lib/copies.ts
@@ -0,0 +1,165 @@
+import {
+  fetchSpecs,
+  latestByCoordinate,
+  type NostrEvent,
+  type Spec,
+  specPath,
+  toCoordinate,
+  toNpub,
+} from "@openspecs/nostr";
+import { useEffect, useState } from "react";
+import { eventPath } from "./paths";
+import { compareCopies, type Spot, type Standing } from "./spots";
+
+/** Another key's copy of this document, reduced to what its row draws. */
+export type Copy = {
+  pubkey: string;
+  npub: string;
+  identifier: string;
+  title: string;
+  summary: string;
+  revisedAt: number;
+  path: string;
+  /** True where it sits at this document's address too, which is how it was found. */
+  sameName: boolean;
+};
+
+/**
+ * Every other document that is a copy of this one, found two ways and listed
+ * once.
+ *
+ * A copy publishes at this address, or it says in an `a` tag that it started
+ * here, or both. Which of the two found it is bookkeeping: what a reader wants
+ * is the copy, and how it reads against this one, which the standing on its row
+ * answers by looking at the text rather than by believing a tag.
+ *
+ * The document itself is dropped because it is the page, and blank ones the way
+ * every listing drops them. Newest revision first, which is the order everything
+ * else on this site lists in: any other order would be a ranking, and ranking
+ * the versions of a document is the one call this site refuses to make.
+ */
+export const selectCopies = (
+  specs: Spec[],
+  shown: { pubkey: string; identifier: string },
+): Copy[] => {
+  const here = toCoordinate(shown);
+  return specs
+    .filter((spec) => {
+      if (spec.isEmpty) return false;
+      if (spec.pubkey === shown.pubkey && spec.identifier === shown.identifier) return false;
+      if (spec.identifier === shown.identifier) return true;
+      // Relays index an `a` tag's value and not the marker after it, so this is
+      // where a fork is told apart from an `update`, an `extends`, or a page of
+      // a documentation space.
+      return spec.forks.some((fork) => fork.type === "spec" && fork.coordinate === here);
+    })
+    .sort((a, b) => b.createdAt - a.createdAt)
+    .map((spec) => ({
+      pubkey: spec.pubkey,
+      npub: toNpub(spec.pubkey),
+      identifier: spec.identifier,
+      title: spec.title,
+      summary: spec.summary,
+      revisedAt: spec.createdAt,
+      path: specPath(spec),
+      sameName: spec.identifier === shown.identifier,
+    }));
+};
+
+export type Copies = {
+  copies: Copy[];
+  /** The places in the shown revision where those copies differ, for the margin. */
+  spots: Spot[];
+  /** Each copy's standing against the shown revision, by `standingKey`. */
+  standings: Record<string, Standing>;
+};
+
+const NOTHING: Copies = { copies: [], spots: [], standings: {} };
+
+/**
+ * The marks must sit on the text the reader is looking at, so the base source
+ * has to be the shown revision exactly. The relays usually hand it back in the
+ * same query that found the copies; when they hold another revision, the
+ * server's own copy of the event is the one the page was rendered from.
+ */
+const baseContentOf = async (
+  specs: Spec[],
+  shown: { pubkey: string; npub: string; identifier: string; eventId: string },
+): Promise<string | null> => {
+  const own = specs.find(
+    (spec) => spec.pubkey === shown.pubkey && spec.identifier === shown.identifier,
+  );
+  if (own !== undefined && own.event.id === shown.eventId) return own.content;
+  try {
+    const response = await fetch(eventPath(shown.npub, shown.identifier));
+    if (!response.ok) return null;
+    const event = (await response.json()) as NostrEvent;
+    return event.id === shown.eventId ? event.content : null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Asked by the browser after the page is on screen, like the discussion and for
+ * the same reason: the server renders the document for crawlers and cachers, and
+ * who else has written it is not part of the document. When the indexer backend
+ * exists, these two queries are what it replaces.
+ *
+ * Two questions because the relays answer two: who publishes at this address,
+ * and who cites it. They go out together and are folded into one list, because
+ * a copy found by both is one copy.
+ *
+ * The list is published first and the margin marks after: the section is a list
+ * to draw, the marks cost a comparison per copy, and neither should wait on the
+ * other.
+ */
+export const useCopies = (shown: {
+  pubkey: string;
+  npub: string;
+  identifier: string;
+  eventId: string;
+  title: string;
+}): Copies => {
+  const [found, setFound] = useState<Copies>(NOTHING);
+  const { pubkey, npub, identifier, eventId, title } = shown;
+
+  useEffect(() => {
+    let live = true;
+    setFound(NOTHING);
+
+    (async () => {
+      try {
+        // Caught one by one rather than together: the relays answer these
+        // separately and a reader is owed whichever of the two came back, not
+        // silence because the other did not.
+        const [byName, byCitation] = await Promise.all([
+          fetchSpecs({ identifiers: [identifier] }).catch(() => [] as Spec[]),
+          fetchSpecs({ cites: [toCoordinate({ pubkey, identifier })] }).catch(() => [] as Spec[]),
+        ]);
+        if (!live) return;
+        // One document answering both queries is one document, and the newer of
+        // the two revisions is the one that counts.
+        const specs = latestByCoordinate([...byName, ...byCitation]);
+        const copies = selectCopies(specs, { pubkey, identifier });
+        setFound({ copies, spots: [], standings: {} });
+        if (copies.length === 0) return;
+
+        const content = await baseContentOf(specs, { pubkey, npub, identifier, eventId });
+        if (!live || content === null) return;
+        const held = new Set(copies.map((copy) => `${copy.pubkey}:${copy.identifier}`));
+        const others = specs.filter((spec) => held.has(`${spec.pubkey}:${spec.identifier}`));
+        const { spots, standings } = compareCopies({ content, title, npub, identifier }, others);
+        if (live) setFound({ copies, spots, standings });
+      } catch {
+        // A page that could not learn who else has written this still has its document.
+      }
+    })();
+
+    return () => {
+      live = false;
+    };
+  }, [pubkey, npub, identifier, eventId, title]);
+
+  return found;
+};
diff --git a/apps/web/app/lib/paths.test.ts b/apps/web/app/lib/paths.test.ts
index c7a925d..f36b90b 100644
--- a/apps/web/app/lib/paths.test.ts
+++ b/apps/web/app/lib/paths.test.ts
@@ -1,5 +1,30 @@
 import { describe, expect, it } from "vitest";
-import { connectPath, returnTo } from "./paths";
+import { connectPath, diffPath, returnTo, specForkPath } from "./paths";
+
+describe("diffPath", () => {
+  it("says nothing about the other side's address where it is the same", () => {
+    expect(diffPath("npub1abc", "nip-07", "npub1def")).toBe("/spec/npub1abc/nip-07/diff/npub1def");
+    expect(diffPath("npub1abc", "nip-07", "npub1def", "nip-07")).toBe(
+      "/spec/npub1abc/nip-07/diff/npub1def",
+    );
+  });
+
+  it("carries the address of a copy that renamed itself", () => {
+    expect(diffPath("npub1abc", "nip-07", "npub1def", "nip-07 mine")).toBe(
+      "/spec/npub1abc/nip-07/diff/npub1def/nip-07%20mine",
+    );
+  });
+});
+
+describe("specForkPath", () => {
+  it("hangs off the document a fork starts from", () => {
+    expect(specForkPath("npub1abc", "nip-07")).toBe("/spec/npub1abc/nip-07/fork");
+  });
+
+  it("encodes an address that would otherwise read as a path", () => {
+    expect(specForkPath("npub1abc", "a b/c")).toBe("/spec/npub1abc/a%20b%2Fc/fork");
+  });
+});
 
 describe("connectPath", () => {
   it("is the bare address when nothing sent anybody there", () => {
diff --git a/apps/web/app/lib/paths.ts b/apps/web/app/lib/paths.ts
index 3007c03..10b30a5 100644
--- a/apps/web/app/lib/paths.ts
+++ b/apps/web/app/lib/paths.ts
@@ -73,9 +73,26 @@ export const oembedPath = (canonical: string): string =>
 export const eventPath = (npub: string, identifier: string): string =>
   `/spec/${npub}/${encodeURIComponent(identifier)}/event.json`;
 
-/** What another key's document under the same name changes against this one. */
-export const diffPath = (npub: string, identifier: string, otherNpub: string): string =>
-  `/spec/${npub}/${encodeURIComponent(identifier)}/diff/${otherNpub}`;
+/**
+ * What another key's copy changes against this one.
+ *
+ * The other side's address is left off when it is the same, which is the common
+ * case and the shorter link. A copy that renamed itself carries its own name in
+ * the last segment: the two documents are still the same writing, and a
+ * comparison that could only be drawn between matching names would refuse
+ * exactly the copies that moved furthest.
+ */
+export const diffPath = (
+  npub: string,
+  identifier: string,
+  otherNpub: string,
+  otherIdentifier?: string,
+): string => {
+  const base = `/spec/${npub}/${encodeURIComponent(identifier)}/diff/${otherNpub}`;
+  return otherIdentifier === undefined || otherIdentifier === identifier
+    ? base
+    : `${base}/${encodeURIComponent(otherIdentifier)}`;
+};
 
 /** What this site does with a document, for somebody who just met the word relay. */
 export const aboutPath = (): string => "/about";
@@ -129,3 +146,12 @@ export const blockedSettingsPath = (): string => "/settings/blocked";
  */
 export const specEditPath = (npub: string, identifier: string): string =>
   `/spec/${npub}/${encodeURIComponent(identifier)}/edit`;
+
+/**
+ * Writing somebody else's document again under your own key. It hangs off the
+ * document it starts from, like the edit above it and the comparison beside it,
+ * because that is the thing being acted on: the document it makes has no address
+ * until its author picks one.
+ */
+export const specForkPath = (npub: string, identifier: string): string =>
+  `/spec/${npub}/${encodeURIComponent(identifier)}/fork`;
diff --git a/apps/web/app/lib/spec-draft-store.test.ts b/apps/web/app/lib/spec-draft-store.test.ts
index 6ff12c0..4668abf 100644
--- a/apps/web/app/lib/spec-draft-store.test.ts
+++ b/apps/web/app/lib/spec-draft-store.test.ts
@@ -87,69 +87,93 @@ describe("parseStoredDraft", () => {
 describe("readDraft and writeDraft", () => {
   it("hands back what was written", () => {
     const record = stored();
-    writeDraft(ME, "a-document", record);
-    expect(readDraft(ME, "a-document")).toEqual(record);
+    writeDraft(ME, { of: "doc", identifier: "a-document" }, record);
+    expect(readDraft(ME, { of: "doc", identifier: "a-document" })).toEqual(record);
   });
 
   it("keeps the slot for a document apart from the one for a new document", () => {
-    writeDraft(ME, null, stored({ title: "Unaddressed" }));
-    writeDraft(ME, "a-document", stored({ title: "Addressed" }));
+    writeDraft(ME, { of: "new" }, stored({ title: "Unaddressed" }));
+    writeDraft(ME, { of: "doc", identifier: "a-document" }, stored({ title: "Addressed" }));
 
-    expect(readDraft(ME, null)?.draft.title).toBe("Unaddressed");
-    expect(readDraft(ME, "a-document")?.draft.title).toBe("Addressed");
+    expect(readDraft(ME, { of: "new" })?.draft.title).toBe("Unaddressed");
+    expect(readDraft(ME, { of: "doc", identifier: "a-document" })?.draft.title).toBe("Addressed");
   });
 
-  /** The one collision two prefixes exist to prevent. */
+  it("keeps a fork apart from both, so starting one eats neither", () => {
+    const origin = `30817:${OTHER}:a-document`;
+    writeDraft(ME, { of: "new" }, stored({ title: "Unaddressed" }));
+    writeDraft(ME, { of: "doc", identifier: "a-document" }, stored({ title: "Addressed" }));
+    writeDraft(ME, { of: "fork", origin }, stored({ title: "Forked" }));
+
+    expect(readDraft(ME, { of: "new" })?.draft.title).toBe("Unaddressed");
+    expect(readDraft(ME, { of: "doc", identifier: "a-document" })?.draft.title).toBe("Addressed");
+    expect(readDraft(ME, { of: "fork", origin })?.draft.title).toBe("Forked");
+  });
+
+  it("gives every origin a fork slot of its own", () => {
+    writeDraft(ME, { of: "fork", origin: `30817:${OTHER}:one` }, stored({ title: "One" }));
+    writeDraft(ME, { of: "fork", origin: `30817:${OTHER}:two` }, stored({ title: "Two" }));
+
+    expect(readDraft(ME, { of: "fork", origin: `30817:${OTHER}:one` })?.draft.title).toBe("One");
+    expect(readDraft(ME, { of: "fork", origin: `30817:${OTHER}:two` })?.draft.title).toBe("Two");
+  });
+
+  /** The collision the separate prefixes exist to prevent. */
   it("keeps a document identified as `new` apart from a new document", () => {
-    writeDraft(ME, null, stored({ title: "Unaddressed" }));
-    writeDraft(ME, "new", stored({ title: "A document called new" }));
+    writeDraft(ME, { of: "new" }, stored({ title: "Unaddressed" }));
+    writeDraft(ME, { of: "doc", identifier: "new" }, stored({ title: "A document called new" }));
 
-    expect(readDraft(ME, null)?.draft.title).toBe("Unaddressed");
-    expect(readDraft(ME, "new")?.draft.title).toBe("A document called new");
+    expect(readDraft(ME, { of: "new" })?.draft.title).toBe("Unaddressed");
+    expect(readDraft(ME, { of: "doc", identifier: "new" })?.draft.title).toBe(
+      "A document called new",
+    );
   });
 
   it("keeps one key's draft out of another's", () => {
-    writeDraft(ME, "a-document", stored({ title: "Mine" }));
-    expect(readDraft(OTHER, "a-document")).toBeNull();
+    writeDraft(ME, { of: "doc", identifier: "a-document" }, stored({ title: "Mine" }));
+    expect(readDraft(OTHER, { of: "doc", identifier: "a-document" })).toBeNull();
   });
 
   it("has nothing to offer where nothing was written", () => {
-    expect(readDraft(ME, "never-typed")).toBeNull();
+    expect(readDraft(ME, { of: "doc", identifier: "never-typed" })).toBeNull();
   });
 
   it("leaves a draft too large to store unsaved rather than throwing", () => {
     const huge = stored({ content: "x".repeat(MAX_DRAFT_BYTES + 1) });
-    expect(() => writeDraft(ME, "big", huge)).not.toThrow();
-    expect(readDraft(ME, "big")).toBeNull();
+    expect(() => writeDraft(ME, { of: "doc", identifier: "big" }, huge)).not.toThrow();
+    expect(readDraft(ME, { of: "doc", identifier: "big" })).toBeNull();
   });
 
   it("carries on where the browser refuses to store anything", () => {
     vi.stubGlobal("localStorage", fakeStorage(true));
-    expect(() => writeDraft(ME, "a-document", stored())).not.toThrow();
-    expect(readDraft(ME, "a-document")).toBeNull();
+    expect(() => writeDraft(ME, { of: "doc", identifier: "a-document" }, stored())).not.toThrow();
+    expect(readDraft(ME, { of: "doc", identifier: "a-document" })).toBeNull();
   });
 
   it("carries on where there is no storage at all", () => {
     vi.stubGlobal("localStorage", undefined);
-    expect(() => writeDraft(ME, "a-document", stored())).not.toThrow();
-    expect(readDraft(ME, "a-document")).toBeNull();
-    expect(() => clearDraft(ME, "a-document")).not.toThrow();
+    expect(() => writeDraft(ME, { of: "doc", identifier: "a-document" }, stored())).not.toThrow();
+    expect(readDraft(ME, { of: "doc", identifier: "a-document" })).toBeNull();
+    expect(() => clearDraft(ME, { of: "doc", identifier: "a-document" })).not.toThrow();
   });
 
   it("refuses to store a record it could not read back", () => {
-    writeDraft(ME, "a-document", { ...stored(), v: 2 } as unknown as StoredDraft);
-    expect(readDraft(ME, "a-document")).toBeNull();
+    writeDraft(ME, { of: "doc", identifier: "a-document" }, {
+      ...stored(),
+      v: 2,
+    } as unknown as StoredDraft);
+    expect(readDraft(ME, { of: "doc", identifier: "a-document" })).toBeNull();
   });
 });
 
 describe("clearDraft", () => {
   it("removes only the slot it was asked for", () => {
-    writeDraft(ME, null, stored({ title: "Unaddressed" }));
-    writeDraft(ME, "a-document", stored({ title: "Addressed" }));
+    writeDraft(ME, { of: "new" }, stored({ title: "Unaddressed" }));
+    writeDraft(ME, { of: "doc", identifier: "a-document" }, stored({ title: "Addressed" }));
 
-    clearDraft(ME, "a-document");
+    clearDraft(ME, { of: "doc", identifier: "a-document" });
 
-    expect(readDraft(ME, "a-document")).toBeNull();
-    expect(readDraft(ME, null)?.draft.title).toBe("Unaddressed");
+    expect(readDraft(ME, { of: "doc", identifier: "a-document" })).toBeNull();
+    expect(readDraft(ME, { of: "new" })?.draft.title).toBe("Unaddressed");
   });
 });
diff --git a/apps/web/app/lib/spec-draft-store.ts b/apps/web/app/lib/spec-draft-store.ts
index 0df5957..a961e12 100644
--- a/apps/web/app/lib/spec-draft-store.ts
+++ b/apps/web/app/lib/spec-draft-store.ts
@@ -2,14 +2,16 @@ import type { SpecDraft, SpecKindEntry } from "@openspecs/nostr";
 
 /**
  * Where a document waits while it is being written, so a closed tab is not a
- * lost afternoon. Two prefixes rather than one, or a document whose identifier
- * is literally `new` would share a slot with the one nobody has addressed yet.
+ * lost afternoon. Three prefixes rather than one, or a document whose identifier
+ * is literally `new` would share a slot with the one nobody has addressed yet,
+ * and starting a fork would eat whichever of those two it landed on.
  *
  * NIP-37 encrypted drafts replace this. Until then a draft never leaves the
  * browser it was typed in, which is worth saying on screen rather than hiding.
  */
 const NEW_PREFIX = "openspecs:draft:new:";
 const DOC_PREFIX = "openspecs:draft:doc:";
+const FORK_PREFIX = "openspecs:draft:fork:";
 
 export const DRAFT_VERSION = 1;
 
@@ -76,8 +78,21 @@ export const parseStoredDraft = (input: unknown): StoredDraft | null => {
   };
 };
 
-const slot = (pubkey: string, identifier: string | null): string =>
-  identifier === null ? `${NEW_PREFIX}${pubkey}` : `${DOC_PREFIX}${pubkey}:${identifier}`;
+/**
+ * Which of a key's drafts is meant. A fork waiting to be published is keyed on
+ * the document it came from, so forking the same origin twice picks the draft
+ * back up and forking another one does not.
+ */
+export type DraftSlot =
+  | { of: "new" }
+  | { of: "doc"; identifier: string }
+  | { of: "fork"; origin: string };
+
+const slot = (pubkey: string, at: DraftSlot): string => {
+  if (at.of === "new") return `${NEW_PREFIX}${pubkey}`;
+  if (at.of === "doc") return `${DOC_PREFIX}${pubkey}:${at.identifier}`;
+  return `${FORK_PREFIX}${pubkey}:${at.origin}`;
+};
 
 /**
  * Storage is an accelerator, never a dependency: a private window whose
@@ -87,30 +102,26 @@ const slot = (pubkey: string, identifier: string | null): string =>
 const local = (): Storage | undefined =>
   typeof localStorage === "undefined" ? undefined : localStorage;
 
-export const readDraft = (pubkey: string, identifier: string | null): StoredDraft | null => {
+export const readDraft = (pubkey: string, at: DraftSlot): StoredDraft | null => {
   try {
-    const raw = local()?.getItem(slot(pubkey, identifier));
+    const raw = local()?.getItem(slot(pubkey, at));
     return raw === null || raw === undefined ? null : parseStoredDraft(JSON.parse(raw));
   } catch {
     return null;
   }
 };
 
-export const writeDraft = (
-  pubkey: string,
-  identifier: string | null,
-  stored: StoredDraft,
-): void => {
+export const writeDraft = (pubkey: string, at: DraftSlot, stored: StoredDraft): void => {
   if (parseStoredDraft(stored) === null) return;
   try {
     const serialized = JSON.stringify(stored);
     if (serialized.length > MAX_DRAFT_BYTES) return;
-    local()?.setItem(slot(pubkey, identifier), serialized);
+    local()?.setItem(slot(pubkey, at), serialized);
   } catch {}
 };
 
-export const clearDraft = (pubkey: string, identifier: string | null): void => {
+export const clearDraft = (pubkey: string, at: DraftSlot): void => {
   try {
-    local()?.removeItem(slot(pubkey, identifier));
+    local()?.removeItem(slot(pubkey, at));
   } catch {}
 };
diff --git a/apps/web/app/lib/spec-page.test.ts b/apps/web/app/lib/spec-page.test.ts
index 9797fc5..d583108 100644
--- a/apps/web/app/lib/spec-page.test.ts
+++ b/apps/web/app/lib/spec-page.test.ts
@@ -4,16 +4,15 @@ import { toPage } from "./spec-page";
 
 const PUBKEY = "1336a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
 
-const specOf = (content: string) => {
+const ORIGIN = "2447a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
+
+const specWithTags = (tags: string[][], content = "") => {
   const spec = parseSpec({
     id: "a".repeat(64),
     pubkey: PUBKEY,
     created_at: 1,
     kind: SPEC_KIND,
-    tags: [
-      ["d", "bud-02"],
-      ["title", "BUD-02"],
-    ],
+    tags: [["d", "bud-02"], ["title", "BUD-02"], ...tags],
     content,
     sig: "b".repeat(128),
   });
@@ -21,6 +20,8 @@ const specOf = (content: string) => {
   return spec;
 };
 
+const specOf = (content: string) => specWithTags([], content);
+
 describe("toPage", () => {
   const naddr = toNaddr({ pubkey: PUBKEY, identifier: "bud-01" });
   const path = `/spec/${toNpub(PUBKEY)}/bud-01`;
@@ -39,3 +40,48 @@ describe("toPage", () => {
     expect(toPage(specOf(`as nostr:${naddr} says`)).html).toContain(`href="${path}"`);
   });
 });
+
+describe("toPage and where a document says it came from", () => {
+  const marker = (coordinate: string) => [["a", coordinate, "", "fork"]];
+
+  it("names the origin by its address, without asking a relay for it", () => {
+    expect(toPage(specWithTags(marker(`${SPEC_KIND}:${ORIGIN}:bud-02`))).forkedFrom).toEqual([
+      {
+        type: "spec",
+        npub: toNpub(ORIGIN),
+        identifier: "bud-02",
+        path: `/spec/${toNpub(ORIGIN)}/bud-02`,
+      },
+    ]);
+  });
+
+  it("drops a coordinate that addresses nothing", () => {
+    expect(toPage(specWithTags(marker("30817:not-a-key:bud-02"))).forkedFrom).toEqual([]);
+    expect(toPage(specWithTags(marker(`${SPEC_KIND}:${ORIGIN}:`))).forkedFrom).toEqual([]);
+  });
+
+  it("reads only an `a` tag marked as a fork", () => {
+    const coordinate = `${SPEC_KIND}:${ORIGIN}:bud-01`;
+    // An `a` tag is also how another client says `update` or `extends`, and how a
+    // documentation space names its pages.
+    expect(toPage(specWithTags([["a", coordinate]])).forkedFrom).toEqual([]);
+    expect(toPage(specWithTags([["a", coordinate, "", "update"]])).forkedFrom).toEqual([]);
+    // The marker sits at index 3 on an `a` tag, where index 2 is the relay hint.
+    expect(toPage(specWithTags([["a", coordinate, "fork"]])).forkedFrom).toEqual([]);
+  });
+
+  it("says nothing about a marker naming the document it sits on", () => {
+    expect(toPage(specWithTags(marker(`${SPEC_KIND}:${PUBKEY}:bud-02`))).forkedFrom).toEqual([]);
+  });
+
+  it("names an origin outside Nostr by its host, without the www", () => {
+    expect(
+      toPage(specWithTags([["i", "https://www.example.org/nips/47", "fork"]])).forkedFrom,
+    ).toEqual([{ type: "external", url: "https://www.example.org/nips/47", host: "example.org" }]);
+  });
+
+  it("drops an origin outside Nostr that no reader can open", () => {
+    expect(toPage(specWithTags([["i", "javascript:alert(1)", "fork"]])).forkedFrom).toEqual([]);
+    expect(toPage(specWithTags([["i", "not a url at all", "fork"]])).forkedFrom).toEqual([]);
+  });
+});
diff --git a/apps/web/app/lib/spec-page.ts b/apps/web/app/lib/spec-page.ts
index da8c23a..c4475a6 100644
--- a/apps/web/app/lib/spec-page.ts
+++ b/apps/web/app/lib/spec-page.ts
@@ -1,8 +1,58 @@
 import type { MarkdownHeading } from "@openspecs/markdown";
 import { renderMarkdown } from "@openspecs/markdown";
-import { type Spec, type SpecKindRef, toNaddr, toNpub } from "@openspecs/nostr";
+import {
+  parseCoordinate,
+  type Spec,
+  type SpecKindRef,
+  specPath,
+  toNaddr,
+  toNpub,
+} from "@openspecs/nostr";
 import { mentionResolver } from "./mention";
 
+/** One place a document says it was forked from, reduced to what the row drawing it needs. */
+export type ForkSource =
+  | { type: "spec"; npub: string; identifier: string; path: string }
+  | { type: "external"; url: string; host: string };
+
+/**
+ * Where a document says it came from, named by its address and never fetched.
+ * Reading the origin before this page could render would make the origin's
+ * availability a condition of the fork's page, which is the accelerator rule
+ * turned inside out. The address is what the tag actually says, and the link
+ * goes where the title is.
+ *
+ * A list, because a document may honestly say it came from two places. In
+ * practice there is one.
+ */
+const forkSourcesOf = (spec: Spec): ForkSource[] => {
+  const sources: ForkSource[] = [];
+  for (const fork of spec.forks) {
+    if (fork.type === "external") {
+      try {
+        const url = new URL(fork.url);
+        if (url.protocol !== "http:" && url.protocol !== "https:") continue;
+        sources.push({ type: "external", url: fork.url, host: url.host.replace(/^www\./, "") });
+      } catch {
+        // A document is not worth less for carrying an address nobody can open.
+      }
+      continue;
+    }
+    const pointer = parseCoordinate(fork.coordinate);
+    if (pointer === null) continue;
+    // A marker naming the document it sits on draws a link back to the page you
+    // are already reading, so it says nothing worth a row.
+    if (pointer.pubkey === spec.pubkey && pointer.identifier === spec.identifier) continue;
+    sources.push({
+      type: "spec",
+      npub: toNpub(pointer.pubkey),
+      identifier: pointer.identifier,
+      path: specPath(pointer),
+    });
+  }
+  return sources;
+};
+
 export type SpecPage = {
   kind: number;
   title: string;
@@ -18,6 +68,8 @@ export type SpecPage = {
   kinds: SpecKindRef[];
   publishedAt: number;
   revisedAt: number;
+  /** Named for where it points: `forks` here would read as the documents that forked this one. */
+  forkedFrom: ForkSource[];
   isEmpty: boolean;
   html: string;
   headings: MarkdownHeading[];
@@ -61,6 +113,7 @@ export const toPage = (spec: Spec): SpecPage => {
     kinds: spec.kinds,
     publishedAt: spec.publishedAt,
     revisedAt: spec.createdAt,
+    forkedFrom: forkSourcesOf(spec),
     isEmpty: spec.isEmpty,
     html,
     headings,
diff --git a/apps/web/app/lib/spots.test.ts b/apps/web/app/lib/spots.test.ts
index 2936dd4..e624f8a 100644
--- a/apps/web/app/lib/spots.test.ts
+++ b/apps/web/app/lib/spots.test.ts
@@ -1,6 +1,6 @@
 import { parseSpec, SPEC_KIND, toNpub } from "@openspecs/nostr";
 import { describe, expect, it } from "vitest";
-import { compareCopies, type SpotBase } from "./spots";
+import { compareCopies, type SpotBase, standingKey } from "./spots";
 
 const BASE_KEY = "1336a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
 const OTHER = "2446a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
@@ -57,7 +57,9 @@ describe("compareCopies", () => {
     const other = specOf(OTHER, "Entirely different words about an unrelated idea altogether.");
     const { spots, standings } = compareCopies(base, [other]);
     expect(spots).toEqual([]);
-    expect(standings[OTHER]).toEqual({ kind: "independent" });
+    expect(standings[standingKey({ pubkey: OTHER, identifier: "nip-00" })]).toEqual({
+      kind: "independent",
+    });
   });
 
   it("marks blocks added before everything at element minus one", () => {
@@ -89,7 +91,10 @@ describe("compareCopies", () => {
   it("tells a copy's standing: how many passages it changes", () => {
     const other = specOf(OTHER, CONTENT.replace("Two says", "Two now says"));
     const { standings } = compareCopies(base, [other]);
-    expect(standings[OTHER]).toEqual({ kind: "kin", places: 1 });
+    expect(standings[standingKey({ pubkey: OTHER, identifier: "nip-00" })]).toEqual({
+      kind: "kin",
+      places: 1,
+    });
   });
 
   it("tells a copy reading the same, even when only a link target differs", () => {
@@ -97,6 +102,8 @@ describe("compareCopies", () => {
     const other = specOf(OTHER, linked.replace("./a.md", "./b.md"));
     const { spots, standings } = compareCopies({ ...base, content: linked }, [other]);
     expect(spots).toEqual([]);
-    expect(standings[OTHER]).toEqual({ kind: "same" });
+    expect(standings[standingKey({ pubkey: OTHER, identifier: "nip-00" })]).toEqual({
+      kind: "same",
+    });
   });
 });
diff --git a/apps/web/app/lib/spots.ts b/apps/web/app/lib/spots.ts
index 6c0cf77..a4010ce 100644
--- a/apps/web/app/lib/spots.ts
+++ b/apps/web/app/lib/spots.ts
@@ -18,6 +18,13 @@ export type SpotEntry = {
   diffHref: string;
 };
 
+/**
+ * One key may hold two copies of a document, one at this name and one it renamed,
+ * so a standing is filed under both halves of the address rather than the key.
+ */
+export const standingKey = (of: { pubkey: string; identifier: string }): string =>
+  `${of.pubkey}:${of.identifier}`;
+
 /** One place in the document where other keys' copies differ, however many do. */
 export type Spot = {
   /**
@@ -60,7 +67,7 @@ export type Standing = { kind: "kin"; places: number } | { kind: "same" } | { ki
 
 export type CopiesComparison = {
   spots: Spot[];
-  /** By the copy's pubkey. A copy whose comparison never ran has no standing. */
+  /** By `standingKey`. A copy whose comparison never ran has no standing. */
   standings: Record<string, Standing>;
 };
 
@@ -80,11 +87,12 @@ export const compareCopies = (base: SpotBase, others: Spec[]): CopiesComparison
     const comparison = compareMarkdown(base.content, other.content, {
       mention: mentionResolver({}),
     });
+    const key = standingKey(other);
     if (comparison.similarity < KINSHIP_FLOOR) {
-      standings[other.pubkey] = { kind: "independent" };
+      standings[key] = { kind: "independent" };
       continue;
     }
-    standings[other.pubkey] =
+    standings[key] =
       comparison.changes.length === 0
         ? { kind: "same" }
         : { kind: "kin", places: comparison.changes.length };
@@ -98,7 +106,7 @@ export const compareCopies = (base: SpotBase, others: Spec[]): CopiesComparison
         pubkey: other.pubkey,
         npub,
         html: change.html,
-        diffHref: diffPath(base.npub, base.identifier, npub),
+        diffHref: diffPath(base.npub, base.identifier, npub, other.identifier),
       });
       spots.set(element, spot);
     }
diff --git a/apps/web/app/lib/variants.test.ts b/apps/web/app/lib/variants.test.ts
deleted file mode 100644
index 83541f5..0000000
--- a/apps/web/app/lib/variants.test.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { parseSpec, SPEC_KIND, toNpub } from "@openspecs/nostr";
-import { describe, expect, it } from "vitest";
-import { selectVariants } from "./variants";
-
-const SHOWN = "1336a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
-const OTHER = "2446a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
-const THIRD = "3556a17e161d0e8af2b68ee95ad2a479fc38bef96a17d6127ea02a40d28dd97e";
-
-const specOf = (pubkey: string, content = "text", createdAt = 1) => {
-  const spec = parseSpec({
-    id: "a".repeat(64),
-    pubkey,
-    created_at: createdAt,
-    kind: SPEC_KIND,
-    tags: [
-      ["d", "nip-07"],
-      ["title", "NIP-07"],
-    ],
-    content,
-    sig: "b".repeat(128),
-  });
-  if (spec === null) throw new Error("the fixture does not parse as a document");
-  return spec;
-};
-
-describe("selectVariants", () => {
-  it("drops the key whose document the page already is", () => {
-    const variants = selectVariants([specOf(SHOWN), specOf(OTHER)], SHOWN);
-    expect(variants.map((variant) => variant.pubkey)).toEqual([OTHER]);
-  });
-
-  it("drops blank records, the way listings do", () => {
-    expect(selectVariants([specOf(OTHER, "  ")], SHOWN)).toEqual([]);
-  });
-
-  it("lists the newest revision first", () => {
-    const variants = selectVariants([specOf(OTHER, "text", 1), specOf(THIRD, "text", 2)], SHOWN);
-    expect(variants.map((variant) => variant.pubkey)).toEqual([THIRD, OTHER]);
-  });
-
-  it("carries what a row draws", () => {
-    const [variant] = selectVariants([specOf(OTHER, "text", 7)], SHOWN);
-    expect(variant).toMatchObject({
-      pubkey: OTHER,
-      npub: toNpub(OTHER),
-      title: "NIP-07",
-      revisedAt: 7,
-      path: `/spec/${toNpub(OTHER)}/nip-07`,
-    });
-  });
-});
diff --git a/apps/web/app/lib/variants.ts b/apps/web/app/lib/variants.ts
deleted file mode 100644
index baa4e79..0000000
--- a/apps/web/app/lib/variants.ts
+++ /dev/null
@@ -1,116 +0,0 @@
-import { fetchSpecs, type NostrEvent, type Spec, specPath, toNpub } from "@openspecs/nostr";
-import { useEffect, useState } from "react";
-import { eventPath } from "./paths";
-import { compareCopies, type Spot, type Standing } from "./spots";
-
-/** Another key's document under the same identifier, reduced to what its row draws. */
-export type Variant = {
-  pubkey: string;
-  npub: string;
-  title: string;
-  summary: string;
-  revisedAt: number;
-  path: string;
-};
-
-/**
- * The other keys publishing under this identifier. The one on the page is
- * dropped because its document is the page, and blank records are dropped the
- * way listings drop them. Newest revision first, which is the order everything
- * else on this site lists in: any other order would be a ranking, and ranking
- * the versions of a name is the one call this site refuses to make.
- */
-export const selectVariants = (specs: Spec[], shownPubkey: string): Variant[] =>
-  specs
-    .filter((spec) => spec.pubkey !== shownPubkey && !spec.isEmpty)
-    .sort((a, b) => b.createdAt - a.createdAt)
-    .map((spec) => ({
-      pubkey: spec.pubkey,
-      npub: toNpub(spec.pubkey),
-      title: spec.title,
-      summary: spec.summary,
-      revisedAt: spec.createdAt,
-      path: specPath(spec),
-    }));
-
-export type UnderThisName = {
-  variants: Variant[];
-  /** The places in the shown revision where those copies differ, for the margin. */
-  spots: Spot[];
-  /** Each copy's standing against the shown revision, for its card. */
-  standings: Record<string, Standing>;
-};
-
-const NOTHING: UnderThisName = { variants: [], spots: [], standings: {} };
-
-/**
- * The marks must sit on the text the reader is looking at, so the base source
- * has to be the shown revision exactly. The relays usually hand it back in the
- * same query that found the variants; when they hold another revision, the
- * server's own copy of the event is the one the page was rendered from.
- */
-const baseContentOf = async (
-  specs: Spec[],
-  shown: { pubkey: string; npub: string; identifier: string; eventId: string },
-): Promise<string | null> => {
-  const own = specs.find((spec) => spec.pubkey === shown.pubkey);
-  if (own !== undefined && own.event.id === shown.eventId) return own.content;
-  try {
-    const response = await fetch(eventPath(shown.npub, shown.identifier));
-    if (!response.ok) return null;
-    const event = (await response.json()) as NostrEvent;
-    return event.id === shown.eventId ? event.content : null;
-  } catch {
-    return null;
-  }
-};
-
-/**
- * Asked by the browser after the page is on screen, like the discussion and for
- * the same reason: the server renders the document for crawlers and cachers, and
- * who else signs its name is not part of the document. When the indexer backend
- * exists, this one query is what it replaces.
- *
- * The variants are published first and the margin marks after: the section is a
- * list to draw, the marks cost a comparison per copy, and neither should wait
- * on the other.
- */
-export const useVariants = (shown: {
-  pubkey: string;
-  npub: string;
-  identifier: string;
-  eventId: string;
-  title: string;
-}): UnderThisName => {
-  const [found, setFound] = useState<UnderThisName>(NOTHING);
-  const { pubkey, npub, identifier, eventId, title } = shown;
-
-  useEffect(() => {
-    let live = true;
-    setFound(NOTHING);
-
-    (async () => {
-      try {
-        const specs = await fetchSpecs({ identifiers: [identifier] });
-        if (!live) return;
-        const variants = selectVariants(specs, pubkey);
-        setFound({ variants, spots: [], standings: {} });
-        if (variants.length === 0) return;
-
-        const content = await baseContentOf(specs, { pubkey, npub, identifier, eventId });
-        if (!live || content === null) return;
-        const others = specs.filter((spec) => spec.pubkey !== pubkey && !spec.isEmpty);
-        const { spots, standings } = compareCopies({ content, title, npub, identifier }, others);
-        if (live) setFound({ variants, spots, standings });
-      } catch {
-        // A page that could not learn who else signs this name still has its document.
-      }
-    })();
-
-    return () => {
-      live = false;
-    };
-  }, [pubkey, npub, identifier, eventId, title]);
-
-  return found;
-};
diff --git a/apps/web/app/routes.ts b/apps/web/app/routes.ts
index feea2c7..35bcbd8 100644
--- a/apps/web/app/routes.ts
+++ b/apps/web/app/routes.ts
@@ -19,7 +19,13 @@ export default [
   route("atom.xml", "routes/atom.ts"),
   route("spec/:author/:identifier", "routes/spec.tsx"),
   route("spec/:author/:identifier/edit", "routes/spec-edit.tsx"),
-  route("spec/:author/:identifier/diff/:other", "routes/spec-diff.tsx"),
+  route("spec/:author/:identifier/fork", "routes/spec-fork.tsx"),
+  route("spec/:author/:identifier/diff/:other", "routes/spec-diff.tsx", {
+    id: "spec-diff",
+  }),
+  route("spec/:author/:identifier/diff/:other/:otherIdentifier", "routes/spec-diff.tsx", {
+    id: "spec-diff-renamed",
+  }),
   route("spec/:author/:identifier/event.json", "routes/event.ts"),
   route("og/:author/:identifier", "routes/og.ts"),
   route("og/:author", "routes/og-author.ts"),
diff --git a/apps/web/app/routes/spec-diff.tsx b/apps/web/app/routes/spec-diff.tsx
index 9774aad..78c5a3b 100644
--- a/apps/web/app/routes/spec-diff.tsx
+++ b/apps/web/app/routes/spec-diff.tsx
@@ -20,17 +20,23 @@ export async function loader({ params }: Route.LoaderArgs) {
     throw data({ missing: "address" }, { status: 404, headers: NOT_FOUND_HEADERS });
   }
 
+  // Left off where the other side kept this document's name, which is the common
+  // case and what every link built before renaming was possible still says.
+  const otherIdentifier = params.otherIdentifier ?? params.identifier;
+
   // A document diffed against itself is the document, which has its own page.
-  if (pubkey === otherPubkey) throw redirect(specPath({ pubkey, identifier: params.identifier }));
+  if (pubkey === otherPubkey && otherIdentifier === params.identifier) {
+    throw redirect(specPath({ pubkey, identifier: params.identifier }));
+  }
 
-  const path = diffPath(toNpub(pubkey), params.identifier, toNpub(otherPubkey));
+  const path = diffPath(toNpub(pubkey), params.identifier, toNpub(otherPubkey), otherIdentifier);
   if (params.author !== toNpub(pubkey) || params.other !== toNpub(otherPubkey)) {
     throw redirect(path, 301);
   }
 
   const [base, other] = await Promise.all([
     loadSpec(pubkey, params.identifier),
-    loadSpec(otherPubkey, params.identifier),
+    loadSpec(otherPubkey, otherIdentifier),
   ]);
   if (base === null || other === null) {
     throw data({ missing: "document" }, { status: 404, headers: NOT_FOUND_HEADERS });
@@ -133,7 +139,7 @@ export default function SpecDiff({ loaderData }: Route.ComponentProps) {
             )}
             <span className="text-muted">sharing {shared}% of their words</span>
             <Link
-              to={diffPath(other.npub, other.identifier, base.npub)}
+              to={diffPath(other.npub, other.identifier, base.npub, base.identifier)}
               className="text-muted underline decoration-rule underline-offset-2 hover:text-ink hover:decoration-current"
             >
               Swap sides
diff --git a/apps/web/app/routes/spec-fork.tsx b/apps/web/app/routes/spec-fork.tsx
new file mode 100644
index 0000000..c5d0452
--- /dev/null
+++ b/apps/web/app/routes/spec-fork.tsx
@@ -0,0 +1,184 @@
+import { fetchSpecEvent, type NostrEvent, parsePubkey, parseSpec, toNpub } from "@openspecs/nostr";
+import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
+import { SpecEditor } from "~/components/editor/spec-editor";
+import { MakeKey } from "~/components/make-key";
+import { Shell } from "~/components/shell";
+import { SignInDialog } from "~/components/sign-in-dialog";
+import { Unlock } from "~/components/unlock";
+import { PAGE_HEADERS } from "~/lib/http";
+import { eventPath } from "~/lib/paths";
+import { restoreSession, serverSessionState, sessionState, subscribeSession } from "~/lib/session";
+import type { Route } from "./+types/spec-fork";
+
+type Reading = "reading" | "read" | "missing" | "failed";
+
+const NOTE = "font-serif text-[0.9375rem] leading-relaxed text-muted";
+
+const WRONG = "font-serif text-[0.9375rem] leading-relaxed text-signal-closed";
+
+const ACTION =
+  "rounded-sm border border-rule px-3 py-1.5 font-mono text-[0.6875rem] uppercase tracking-[0.14em] text-muted hover:border-muted hover:text-ink";
+
+export function meta(_: Route.MetaArgs) {
+  return [
+    { title: "Fork a document | Open Specs" },
+    // The document being forked has its own page, and this one holds a form
+    // nobody but its reader can use.
+    { name: "robots", content: "noindex, nofollow" },
+  ];
+}
+
+export function headers(_: Route.HeadersArgs) {
+  return PAGE_HEADERS;
+}
+
+/**
+ * Writing somebody else's document again, under the reader's own key.
+ *
+ * The document is read before the form is offered, the way editing one is, but
+ * for the opposite reason: nothing here is at risk of being written over, and
+ * what a fork starts from is the whole of the origin, tags included, so a form
+ * filled from a revision this page never managed to read would be a fork of
+ * nothing.
+ *
+ * The reading starts as soon as the address resolves, without waiting for a key.
+ * The origin is public, and somebody who arrives with no key and connects one
+ * here already has the document in hand when the form appears. Making a key is
+ * offered on the page rather than in the header for the same reason: whoever
+ * clicked Fork on a document is often somebody who has never signed anything.
+ */
+/**
+ * The document as this server last read it, which is the copy the page offering
+ * Fork was rendered from and is already in its cache. Asked first because the
+ * relays are six sockets and a four second window from a cold browser, and this
+ * is one request to the origin the reader is already on.
+ *
+ * Safe here and nowhere near the editor of one's own document: a fork replaces
+ * nothing, so a revision a minute old costs a sentence somebody retypes, where
+ * an edit built on one would publish over whatever came since. Null rather than
+ * an error when there is nothing here to serve, and the relays are then asked
+ * properly: this backend is an accelerator, and a build without one still works.
+ */
+const fromServer = async (pubkey: string, identifier: string): Promise<NostrEvent | null> => {
+  try {
+    const response = await fetch(eventPath(toNpub(pubkey), identifier));
+    if (!response.ok) return null;
+    const spec = parseSpec(await response.json());
+    return spec !== null && spec.pubkey === pubkey && spec.identifier === identifier
+      ? spec.event
+      : null;
+  } catch {
+    return null;
+  }
+};
+
+/** `"unreachable"` is not `null`: nothing came back is not the same as nothing is there. */
+const fromRelays = async (
+  pubkey: string,
+  identifier: string,
+): Promise<NostrEvent | null | "unreachable"> => {
+  try {
+    return await fetchSpecEvent({ pubkey, identifier });
+  } catch {
+    return "unreachable";
+  }
+};
+
+export default function SpecForkRoute({ params }: Route.ComponentProps) {
+  const session = useSyncExternalStore(subscribeSession, sessionState, serverSessionState);
+  useEffect(restoreSession, []);
+  const [making, setMaking] = useState(false);
+
+  const me = session.pubkey;
+  const locked = session.status === "locked" && session.method === "key";
+  const pubkey = parsePubkey(params.author);
+  const identifier = params.identifier;
+
+  const [reading, setReading] = useState<Reading>("reading");
+  const [event, setEvent] = useState<NostrEvent | null>(null);
+
+  // The effect itself, so that trying again is running it again rather than
+  // nudging a counter it happens to depend on.
+  const read = useCallback(() => {
+    if (pubkey === null) return;
+
+    let live = true;
+    setReading("reading");
+
+    (async () => {
+      const found =
+        (await fromServer(pubkey, identifier)) ?? (await fromRelays(pubkey, identifier));
+      if (!live) return;
+      if (found === "unreachable") {
+        setReading("failed");
+        return;
+      }
+      setEvent(found);
+      setReading(found === null ? "missing" : "read");
+    })();
+
+    return () => {
+      live = false;
+    };
+  }, [pubkey, identifier]);
+
+  useEffect(read, [read]);
+
+  return (
+    <Shell>
+      {/* The editor draws its own title at the size the published page uses, so
+          the page's own heading steps back to a line naming where you are. */}
+      <main className="mx-auto max-w-5xl px-6 py-12 sm:py-16">
+        <h1 className="font-mono text-[0.6875rem] uppercase tracking-[0.18em] text-muted">
+          Forking
+        </h1>
+
+        {pubkey === null ? (
+          <p className={`mt-8 ${WRONG}`}>That is not the address of a document.</p>
+        ) : reading === "reading" ? (
+          <p className={`mt-8 ${NOTE}`}>Reading the document to start from.</p>
+        ) : reading !== "read" || event === null ? (
+          <div className="mt-8 space-y-3">
+            <p className={WRONG}>
+              {reading === "missing"
+                ? "Nothing came back at this address. Either no document was published here, or no relay answered just now."
+                : "Could not reach the relays, so there is nothing to start from yet."}
+            </p>
+            <button type="button" className={ACTION} onClick={() => read()}>
+              Try again
+            </button>
+          </div>
+        ) : me === null || making ? (
+          // Making a key signs its reader in halfway through, so the step showing
+          // them their key has to outlive that: the way in holds the page until
+          // it says it is done, rather than until a key exists.
+          <div className="mt-8 max-w-sm space-y-4">
+            <p className={NOTE}>Connect a key to publish this document under it.</p>
+            {making ? (
+              <MakeKey onDone={() => setMaking(false)} />
+            ) : (
+              <SignInDialog onDone={() => {}} onMake={() => setMaking(true)} />
+            )}
+          </div>
+        ) : locked ? (
+          <div className="mt-8 max-w-sm">
+            <Unlock />
+          </div>
+        ) : (
+          /* Nothing said here about forking your own document. The editor asks the
+             relays what this key already publishes at that address the moment it
+             opens, and answers that and a collision with somebody else's name in
+             the same words, beside the address they are about. */
+          <div className="mt-10">
+            <SpecEditor
+              me={me}
+              npub={toNpub(me)}
+              live={null}
+              fork={{ origin: event, relay: null }}
+            />
+          </div>
+        )}
+      </main>
+    </Shell>
+  );
+}
diff --git a/apps/web/app/routes/spec.tsx b/apps/web/app/routes/spec.tsx
index 509fd19..de9cf63 100644
--- a/apps/web/app/routes/spec.tsx
+++ b/apps/web/app/routes/spec.tsx
@@ -11,7 +11,8 @@ import { useState } from "react";
 import { data, Link, redirect } from "react-router";
 import { AnnotatedDoc } from "~/components/annotated-doc";
 import { AuthorAvatar } from "~/components/author-avatar";
-import { CopyButton } from "~/components/copy-button";
+import { CHROME } from "~/components/chrome";
+import { COPIES_ID, Copies } from "~/components/copies";
 import { Discussion } from "~/components/discussion/discussion";
 import { LikeButton } from "~/components/discussion/like-button";
 import { EditLink } from "~/components/editor/edit-link";
@@ -19,16 +20,15 @@ import { Withdraw } from "~/components/editor/withdraw";
 import { ErrorPage } from "~/components/error-page";
 import { BlockedNotice } from "~/components/moderation/blocked-notice";
 import { More } from "~/components/moderation/more";
-import { Rebroadcast } from "~/components/rebroadcast";
 import { Shell } from "~/components/shell";
 import { SpecTags } from "~/components/spec-tags";
-import { VARIANTS_ID, Variants } from "~/components/variants";
 import { hidesSpec, unblock, useBlocked } from "~/lib/blocked";
 import { keyTextColor } from "~/lib/color";
+import { useCopies } from "~/lib/copies";
 import { NOT_FOUND_HEADERS, PAGE_HEADERS } from "~/lib/http";
 import { useLiveRevision } from "~/lib/live-revision";
 import { publicOrigin } from "~/lib/origin.server";
-import { DISCUSSION_ID, eventPath, oembedPath, ogImagePath } from "~/lib/paths";
+import { DISCUSSION_ID, eventPath, oembedPath, ogImagePath, specForkPath } from "~/lib/paths";
 import type { LinkPreview } from "~/lib/preview";
 import { loadLinkPreviews } from "~/lib/preview.server";
 import { type Author, shortNpub } from "~/lib/profile";
@@ -36,7 +36,6 @@ import { loadAuthor } from "~/lib/profile.server";
 import { discussionRelays, rebroadcastRelays } from "~/lib/relays.server";
 import type { SpecPage } from "~/lib/spec-page";
 import { loadSpec } from "~/lib/specs.server";
-import { useVariants } from "~/lib/variants";
 import type { Route } from "./+types/spec";
 
 export async function loader({ params, request }: Route.LoaderArgs) {
@@ -167,13 +166,7 @@ const Field = ({ label, children }: { label: string; children: React.ReactNode }
   </div>
 );
 
-const Contents = ({
-  headings,
-  variantCount,
-}: {
-  headings: MarkdownHeading[];
-  variantCount: number;
-}) => (
+const Contents = ({ headings, copyCount }: { headings: MarkdownHeading[]; copyCount: number }) => (
   <nav
     aria-label="Contents"
     /* The negative margin and the padding are one pair: scrolling this rail
@@ -201,9 +194,9 @@ const Contents = ({
       {/* Part of the page rather than an appendix to it: what was said about a
           specification is one of the things a reader comes here to find. */}
       <li className="mt-4 border-t border-rule pt-3">
-        {variantCount > 0 && (
-          <a href={`#${VARIANTS_ID}`} className="mb-2 block text-muted hover:text-ink">
-            Under this name
+        {copyCount > 0 && (
+          <a href={`#${COPIES_ID}`} className="mb-2 block text-muted hover:text-ink">
+            Other copies
           </a>
         )}
         <a href={`#${DISCUSSION_ID}`} className="text-muted hover:text-ink">
@@ -219,14 +212,14 @@ const Masthead = ({
   author,
   canonical,
   relays,
-  variantCount,
+  copyCount,
   spotCount,
 }: {
   spec: SpecPage;
   author: Author | null;
   canonical: string;
   relays: string[];
-  variantCount: number;
+  copyCount: number;
   spotCount: number;
 }) => (
   <header>
@@ -234,13 +227,13 @@ const Masthead = ({
       {spec.kind}:{spec.identifier}
       {/* Growing sideways rather than down: this arrives after the page is on
           screen, and text under the reader's eye must not move for it. */}
-      {variantCount > 0 && (
+      {copyCount > 0 && (
         <a
-          href={`#${VARIANTS_ID}`}
-          title={`Other documents published as ${spec.identifier}`}
+          href={`#${COPIES_ID}`}
+          title="Other keys have written this document too"
           className="ml-3 underline decoration-rule underline-offset-2 hover:text-ink hover:decoration-current"
         >
-          also under {variantCount} other {variantCount === 1 ? "key" : "keys"}
+          {copyCount} other {copyCount === 1 ? "copy" : "copies"}
           {spotCount > 0 &&
             `, differing in ${spotCount} ${spotCount === 1 ? "place" : "places"} below`}
         </a>
@@ -284,6 +277,29 @@ const Masthead = ({
               {shorten(spec.npub, 10, 6)}
             </Link>
           </Field>
+          {spec.forkedFrom.map((source) => (
+            <Field key={source.type === "spec" ? source.path : source.url} label="forked from">
+              {source.type === "spec" ? (
+                <>
+                  <Link
+                    to={source.path}
+                    className="underline decoration-rule underline-offset-2 hover:decoration-current"
+                  >
+                    {source.identifier}
+                  </Link>{" "}
+                  <span className="text-muted">{shorten(source.npub, 10, 6)}</span>
+                </>
+              ) : (
+                <a
+                  href={source.url}
+                  rel="nofollow noopener noreferrer"
+                  className="underline decoration-rule underline-offset-2 hover:decoration-current"
+                >
+                  {source.host}
+                </a>
+              )}
+            </Field>
+          ))}
           <Field label="published">{asDate(spec.publishedAt)}</Field>
           {spec.revisedAt > spec.publishedAt && (
             <Field label="revised">{asDate(spec.revisedAt)}</Field>
@@ -302,18 +318,26 @@ const Masthead = ({
 
     <div className="mt-4 flex flex-wrap items-center gap-2 font-mono text-[0.6875rem] uppercase tracking-[0.14em]">
       <LikeButton coordinate={toCoordinate(spec)} specEventId={spec.eventId} pubkey={spec.pubkey} />
-      <CopyButton value={canonical} label="Copy link" title={canonical} />
-      <CopyButton
-        value={spec.naddr}
-        label="Copy naddr"
-        title="The document's Nostr address, for any client"
-      />
-      <CopyButton
-        value={() => fetch(eventPath(spec.npub, spec.identifier)).then((event) => event.text())}
-        label="Copy event"
-        title="The signed event, exactly as the relays serve it"
-      />
-      <Rebroadcast eventUrl={eventPath(spec.npub, spec.identifier)} relays={relays} />
+      {/* Beside the reaction, because those two are what a reader does with the
+          document itself. Everything else it has to offer is one word further on.
+
+          Drawn on the server for everybody, with no session gating: the page it
+          leads to offers the ways in, and a control appearing a tick after paint
+          for the already connected would hide this from the readers most likely
+          to have never signed anything. */}
+      <Link
+        to={specForkPath(spec.npub, spec.identifier)}
+        title="Write your own from this one"
+        className={CHROME}
+      >
+        Fork
+      </Link>
+      {/* Before the menu, though both arrive a tick after paint and push it
+          along when they do. A named action sitting after a catch-all reads as
+          something that fell out of it, and that misreading is on the page for
+          as long as an author is looking at their own document. */}
+      <EditLink pubkey={spec.pubkey} npub={spec.npub} identifier={spec.identifier} />
+      <Withdraw pubkey={spec.pubkey} identifier={spec.identifier} />
       <More
         target={{
           kind: "document",
@@ -321,10 +345,10 @@ const Masthead = ({
           id: spec.eventId,
           coordinate: toCoordinate(spec),
           identifier: spec.identifier,
+          canonical,
+          relays,
         }}
       />
-      <EditLink pubkey={spec.pubkey} npub={spec.npub} identifier={spec.identifier} />
-      <Withdraw pubkey={spec.pubkey} identifier={spec.identifier} />
     </div>
   </header>
 );
@@ -405,13 +429,11 @@ const Article = ({
 }) => {
   const { shown, fresher, show } = useLiveRevision(served);
   // On the shown revision, not the served one: the marks sit on the text on screen.
-  const { variants: every, spots, standings } = useVariants(shown);
+  const { copies: every, spots, standings } = useCopies(shown);
 
   const blocked = useBlocked();
   const [shownAnyway, setShownAnyway] = useState(false);
-  const variants = every.filter(
-    (variant) => !hidesSpec(blocked, { pubkey: variant.pubkey, identifier: shown.identifier }),
-  );
+  const copies = every.filter((copy) => !hidesSpec(blocked, copy));
 
   // A preview was fetched for the links the served revision cited. One that no
   // longer appears in the document has no business under it.
@@ -450,12 +472,12 @@ const Article = ({
         author={author}
         canonical={canonical}
         relays={relays}
-        variantCount={variants.length}
+        copyCount={copies.length}
         spotCount={spots.length}
       />
 
       <div className="mt-14 lg:grid lg:grid-cols-[13rem_minmax(0,1fr)] lg:gap-14">
-        <Contents headings={shown.headings} variantCount={variants.length} />
+        <Contents headings={shown.headings} copyCount={copies.length} />
         <div className="max-w-[40rem]">
           {shown.isEmpty ? (
             <p className="font-serif text-lg text-muted">
@@ -469,8 +491,8 @@ const Article = ({
             <AnnotatedDoc key={shown.eventId} html={shown.html} spots={spots} />
           )}
           {cited.length > 0 && <CitedLinks previews={cited} />}
-          <Variants
-            variants={variants}
+          <Copies
+            copies={copies}
             standings={standings}
             from={{ npub: shown.npub, identifier: shown.identifier }}
           />
diff --git a/packages/nostr/src/index.ts b/packages/nostr/src/index.ts
index 03b37c2..436e799 100644
--- a/packages/nostr/src/index.ts
+++ b/packages/nostr/src/index.ts
@@ -238,6 +238,8 @@ export {
   buildSpec,
   buildSpecDeletion,
   editSpec,
+  type ForkOrigin,
+  forkSpec,
   parseSpec,
   type Spec,
   type SpecDraft,
diff --git a/packages/nostr/src/relay.ts b/packages/nostr/src/relay.ts
index 28de521..47a4906 100644
--- a/packages/nostr/src/relay.ts
+++ b/packages/nostr/src/relay.ts
@@ -46,6 +46,13 @@ export type SpecQuery = {
   topics?: string[];
   /** Event kinds the document is about, matched on its `k` tags. */
   covers?: number[];
+  /**
+   * Documents naming one of these coordinates in an `a` tag. Relays index the
+   * tag's value and nothing else, so this also returns whatever cites the
+   * coordinate as an `update`, an `extends` or a page of a documentation space:
+   * the marker at index 3 is the caller's to check.
+   */
+  cites?: string[];
   since?: number;
   until?: number;
   limit?: number;
@@ -135,6 +142,7 @@ export const fetchSpecs = async (
   if (specQuery.identifiers?.length) filter["#d"] = specQuery.identifiers;
   if (specQuery.topics?.length) filter["#t"] = specQuery.topics;
   if (specQuery.covers?.length) filter["#k"] = specQuery.covers.map(String);
+  if (specQuery.cites?.length) filter["#a"] = specQuery.cites;
   if (specQuery.since !== undefined) filter.since = specQuery.since;
   if (specQuery.until !== undefined) filter.until = specQuery.until;
   if (specQuery.limit !== undefined) filter.limit = specQuery.limit;
diff --git a/packages/nostr/src/spec.ts b/packages/nostr/src/spec.ts
index b91a15f..64e00dd 100644
--- a/packages/nostr/src/spec.ts
+++ b/packages/nostr/src/spec.ts
@@ -1,3 +1,4 @@
+import { toCoordinate } from "./address";
 import {
   allTags,
   type EventDraft,
@@ -270,6 +271,45 @@ export const editSpec = (live: NostrEvent | null, draft: SpecDraft): EventDraft
 /** The same, for a document nobody has published yet: there is no live revision to read first. */
 export const buildSpec = (draft: SpecDraft): EventDraft => editSpec(null, draft);
 
+/** The document a fork came from, as the marker naming it will be written. */
+export type ForkOrigin = {
+  pubkey: string;
+  identifier: string;
+  /** A relay it is known to sit on. The slot is positional, so an empty one is still written. */
+  relay?: string | null;
+};
+
+/**
+ * A document somebody starts from another key's, carrying one tag that says
+ * where it came from.
+ *
+ * Built from the draft and never from the origin's event. `editSpec(origin, draft)`
+ * looks like the way to do this and is the trap: it hands back every tag it does
+ * not own, so the other author's `published_at` and whatever else they wrote
+ * would travel into a document signed by somebody else.
+ *
+ * The marker is written here and never again. Every later revision of the fork
+ * goes through `editSpec`, which copies an `a` tag through with everything else
+ * this editor has no opinion about, so a fork renamed a year later still names
+ * the document it came from rather than the name it used to have.
+ */
+export const forkSpec = (origin: ForkOrigin, forker: string, draft: SpecDraft): EventDraft => {
+  const event = buildSpec(draft);
+  const pubkey = origin.pubkey.trim();
+  const identifier = origin.identifier.trim();
+  // A marker pointing at the document being built says nothing, and drawn on a
+  // page it is a link back to the page you are on.
+  const itself = pubkey === forker && identifier === draft.identifier.trim();
+  if (pubkey === "" || identifier === "" || itself) return event;
+
+  const marker = ["a", toCoordinate({ pubkey, identifier }), origin.relay?.trim() ?? "", "fork"];
+  // Where `editSpec` puts the foreign tags it carries through, so a fork and its
+  // own later revisions order their tags the same way.
+  const alt = event.tags.findIndex((tag) => tag[0] === "alt");
+  const at = alt === -1 ? event.tags.length : alt;
+  return { ...event, tags: [...event.tags.slice(0, at), marker, ...event.tags.slice(at)] };
+};
+
 /**
  * The empty revision an author replaces their own document with, and the first
  * half of withdrawing it.
diff --git a/packages/nostr/test/spec.test.ts b/packages/nostr/test/spec.test.ts
index 7e3e133..10e26b0 100644
--- a/packages/nostr/test/spec.test.ts
+++ b/packages/nostr/test/spec.test.ts
@@ -7,6 +7,7 @@ import {
   buildSpec,
   buildSpecDeletion,
   editSpec,
+  forkSpec,
   parseSpec,
   type Spec,
   type SpecDraft,
@@ -472,6 +473,72 @@ describe("buildSpec", () => {
   });
 });
 
+describe("forkSpec", () => {
+  const originKey = getPublicKey(generateSecretKey());
+  const origin = { pubkey: originKey, identifier: "nip-01" };
+  const copy = draftOf({ identifier: "nip-01", title: "NIP-01" });
+
+  it("writes the marker, empty relay slot included", () => {
+    expect(named(forkSpec(origin, author, copy), "a")).toEqual([
+      ["a", `${SPEC_KIND}:${originKey}:nip-01`, "", "fork"],
+    ]);
+  });
+
+  it("writes a relay hint when it is given one", () => {
+    const draft = forkSpec({ ...origin, relay: " wss://relay.example  " }, author, copy);
+    expect(named(draft, "a")).toEqual([
+      ["a", `${SPEC_KIND}:${originKey}:nip-01`, "wss://relay.example", "fork"],
+    ]);
+  });
+
+  it("says where it came from once it has been through the parser again", () => {
+    expect(parseSpec(sign(forkSpec(origin, author, copy)))?.forks).toEqual([
+      { type: "spec", coordinate: `${SPEC_KIND}:${originKey}:nip-01`, relay: null },
+    ]);
+  });
+
+  it("carries nothing of the origin's own event", () => {
+    const live = specEvent([
+      ["d", "nip-01"],
+      ["title", "NIP-01"],
+      ["published_at", "1600000000"],
+      ["icon", "https://example.com/i.png"],
+    ]);
+    const draft = forkSpec(origin, author, specDraftOf(live));
+    expect(named(draft, "published_at")).toEqual([]);
+    expect(named(draft, "icon")).toEqual([]);
+  });
+
+  it("does not point at the document it is building", () => {
+    expect(named(forkSpec({ pubkey: author, identifier: "nip-01" }, author, copy), "a")).toEqual(
+      [],
+    );
+  });
+
+  it("points at the origin again once the fork moves to a name of its own", () => {
+    const forked = forkSpec({ pubkey: author, identifier: "nip-01" }, author, copy);
+    expect(named(forked, "a")).toEqual([]);
+    const renamed = forkSpec(
+      { pubkey: author, identifier: "nip-01" },
+      author,
+      draftOf({ identifier: "nip-01-mine", title: "NIP-01" }),
+    );
+    expect(named(renamed, "a")).toEqual([["a", `${SPEC_KIND}:${author}:nip-01`, "", "fork"]]);
+  });
+
+  it("keeps the marker through a later revision that renames the fork", () => {
+    const live = sign(forkSpec(origin, author, copy));
+    const renamed = editSpec(live, { ...specDraftOf(live), identifier: "nip-01-mine" });
+    expect(named(renamed, "a")).toEqual([["a", `${SPEC_KIND}:${originKey}:nip-01`, "", "fork"]]);
+    expect(named(renamed, "d")).toEqual([["d", "nip-01-mine"]]);
+  });
+
+  it("writes the marker where an edit would carry it, before the alt", () => {
+    const names = forkSpec(origin, author, copy).tags.map((tag) => tag[0]);
+    expect(names).toEqual(["d", "title", "a", "alt", "client"]);
+  });
+});
+
 describe("withdrawSpec", () => {
   it("writes an address and nothing that was ever the document", () => {
     expect(withdrawSpec("x")).toEqual({