handle pub and post urls in bsky post editor

app/[leaflet_id]/publish/BskyPostEditorProsemirror.tsx

···
 
   const handleMentionSelect = useCallback(
     (mention: Mention) => {
-      if (mention.type !== "did") return;
       if (!viewRef.current || mentionInsertPos === null) return;
       const view = viewRef.current;
       const from = mentionInsertPos - 1;
···
       // Delete the @ symbol
       tr.delete(from, to);
 
-      // Insert @handle
-      const mentionText = "@" + mention.handle;
-      tr.insertText(mentionText, from);
-
-      // Apply mention mark
-      tr.addMark(
-        from,
-        from + mentionText.length,
-        bskyPostSchema.marks.mention.create({ did: mention.did }),
-      );
-
-      // Add a space after the mention
-      tr.insertText(" ", from + mentionText.length);
+      if (mention.type === "did") {
+        // Insert @handle with mention mark
+        const mentionText = "@" + mention.handle;
+        tr.insertText(mentionText, from);
+        tr.addMark(
+          from,
+          from + mentionText.length,
+          bskyPostSchema.marks.mention.create({ did: mention.did }),
+        );
+        tr.insertText(" ", from + mentionText.length);
+      } else if (mention.type === "publication") {
+        // Insert publication name as a link
+        const linkText = mention.name;
+        tr.insertText(linkText, from);
+        tr.addMark(
+          from,
+          from + linkText.length,
+          bskyPostSchema.marks.link.create({ href: mention.url }),
+        );
+        tr.insertText(" ", from + linkText.length);
+      } else if (mention.type === "post") {
+        // Insert post title as a link
+        const linkText = mention.title;
+        tr.insertText(linkText, from);
+        tr.addMark(
+          from,
+          from + linkText.length,
+          bskyPostSchema.marks.link.create({ href: mention.url }),
+        );
+        tr.insertText(" ", from + linkText.length);
+      }
 
       view.dispatch(tr);
       view.focus();

app/api/rpc/[command]/search_publication_documents.ts

···
+import { AtUri } from "@atproto/api";
 import { z } from "zod";
 import { makeRoute } from "../lib";
 import type { Env } from "./route";
+import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
 
 export type SearchPublicationDocumentsReturnType = Awaited<
   ReturnType<(typeof search_publication_documents)["handler"]>
···
     { supabase }: Pick<Env, "supabase">,
   ) => {
     // Get documents in the publication, filtering by title using JSON operator
+    // Also join with publications to get the record for URL construction
     const { data: documents, error } = await supabase
       .from("documents_in_publications")
-      .select("document, documents!inner(uri, data)")
+      .select(
+        "document, documents!inner(uri, data), publications!inner(uri, record)",
+      )
       .eq("publication", publication_uri)
       .ilike("documents.data->>title", `%${query}%`)
       .limit(limit);
···
       );
     }
 
-    const result = documents.map((d) => ({
-      uri: d.documents.uri,
-      title: (d.documents.data as { title?: string })?.title || "Untitled",
-    }));
+    const result = documents.map((d) => {
+      const docUri = new AtUri(d.documents.uri);
+      const pubUrl = getPublicationURL(d.publications);
+
+      return {
+        uri: d.documents.uri,
+        title: (d.documents.data as { title?: string })?.title || "Untitled",
+        url: `${pubUrl}/${docUri.rkey}`,
+      };
+    });
 
     return { result: { documents: result } };
   },

app/api/rpc/[command]/search_publication_names.ts

···
 import { z } from "zod";
 import { makeRoute } from "../lib";
 import type { Env } from "./route";
+import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
 
 export type SearchPublicationNamesReturnType = Awaited<
   ReturnType<(typeof search_publication_names)["handler"]>
···
     query: z.string(),
     limit: z.number().optional().default(10),
   }),
-  handler: async (
-    { query, limit },
-    { supabase }: Pick<Env, "supabase">,
-  ) => {
+  handler: async ({ query, limit }, { supabase }: Pick<Env, "supabase">) => {
     // Search publications by name in record (case-insensitive partial match)
     const { data: publications, error } = await supabase
       .from("publications")
···
       throw new Error(`Failed to search publications: ${error.message}`);
     }
 
-    const result = publications.map((p) => ({
-      uri: p.uri,
-      name: (p.record as { name?: string })?.name || "Untitled",
-    }));
+    const result = publications.map((p) => {
+      const record = p.record as { name?: string };
+      return {
+        uri: p.uri,
+        name: record.name || "Untitled",
+        url: getPublicationURL(p),
+      };
+    });
 
     return { result: { publications: result } };
   },

components/Mention.tsx

···
       displayName?: string;
       avatar?: string;
     }
-  | { type: "publication"; uri: string; name: string }
-  | { type: "post"; uri: string; title: string };
+  | { type: "publication"; uri: string; name: string; url: string }
+  | { type: "post"; uri: string; title: string; url: string };
 
 export type MentionScope =
   | { type: "default" }
···
             type: "post" as const,
             uri: d.uri,
             title: d.title,
+            url: d.url,
           })),
         );
       } else {
···
             type: "publication" as const,
             uri: p.uri,
             name: p.name,
+            url: p.url,
           })),
         ]);
       }