Merge branch 'main' into feature/page-blocks

actions/getIdentityData.ts

···
           identities(
             *,
             bsky_profiles(*),
-            subscribers_to_publications(*),
+            publication_subscriptions(*),
             custom_domains!custom_domains_identity_id_fkey(publication_domains(*), *),
             home_leaflet:permission_tokens!identities_home_page_fkey(*, permission_token_rights(*)),
             permission_token_on_homepage(

app/[leaflet_id]/publish/BskyPostEditorProsemirror.tsx

···
+"use client";
+import { Agent, AppBskyRichtextFacet, UnicodeString } from "@atproto/api";
+import {
+  useState,
+  useCallback,
+  useRef,
+  useLayoutEffect,
+  useEffect,
+} from "react";
+import { createPortal } from "react-dom";
+import { useDebouncedEffect } from "src/hooks/useDebouncedEffect";
+import * as Popover from "@radix-ui/react-popover";
+import { EditorState, TextSelection, Plugin } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { Schema, MarkSpec, Mark } from "prosemirror-model";
+import { baseKeymap } from "prosemirror-commands";
+import { keymap } from "prosemirror-keymap";
+import { history, undo, redo } from "prosemirror-history";
+import { inputRules, InputRule } from "prosemirror-inputrules";
+import { autolink } from "components/Blocks/TextBlock/autolink-plugin";
+import { IOSBS } from "app/lish/[did]/[publication]/[rkey]/Interactions/Comments/CommentBox";
+
+// Schema with only links, mentions, and hashtags marks
+const bskyPostSchema = new Schema({
+  nodes: {
+    doc: { content: "block+" },
+    paragraph: {
+      content: "inline*",
+      group: "block",
+      parseDOM: [{ tag: "p" }],
+      toDOM: () => ["p", 0] as const,
+    },
+    text: {
+      group: "inline",
+    },
+  },
+  marks: {
+    link: {
+      attrs: {
+        href: {},
+      },
+      inclusive: false,
+      parseDOM: [
+        {
+          tag: "a[href]",
+          getAttrs(dom: HTMLElement) {
+            return {
+              href: dom.getAttribute("href"),
+            };
+          },
+        },
+      ],
+      toDOM(node) {
+        let { href } = node.attrs;
+        return ["a", { href, target: "_blank", class: "text-accent" }, 0];
+      },
+    } as MarkSpec,
+    mention: {
+      attrs: {
+        did: {},
+      },
+      inclusive: false,
+      parseDOM: [
+        {
+          tag: "span.mention",
+          getAttrs(dom: HTMLElement) {
+            return {
+              did: dom.getAttribute("data-did"),
+            };
+          },
+        },
+      ],
+      toDOM(node) {
+        let { did } = node.attrs;
+        return [
+          "span",
+          {
+            class: "mention text-accent-contrast",
+            "data-did": did,
+          },
+          0,
+        ];
+      },
+    } as MarkSpec,
+    hashtag: {
+      attrs: {
+        tag: {},
+      },
+      inclusive: false,
+      parseDOM: [
+        {
+          tag: "span.hashtag",
+          getAttrs(dom: HTMLElement) {
+            return {
+              tag: dom.getAttribute("data-tag"),
+            };
+          },
+        },
+      ],
+      toDOM(node) {
+        let { tag } = node.attrs;
+        return [
+          "span",
+          {
+            class: "hashtag text-accent-contrast",
+            "data-tag": tag,
+          },
+          0,
+        ];
+      },
+    } as MarkSpec,
+  },
+});
+
+// Input rule to automatically apply hashtag mark
+function createHashtagInputRule() {
+  return new InputRule(/#([\w]+)\s$/, (state, match, start, end) => {
+    const [fullMatch, tag] = match;
+    const tr = state.tr;
+
+    // Replace the matched text (including space) with just the hashtag and space
+    tr.replaceWith(start, end, [
+      state.schema.text("#" + tag),
+      state.schema.text(" "),
+    ]);
+
+    // Apply hashtag mark to # and tag text only (not the space)
+    tr.addMark(
+      start,
+      start + tag.length + 1,
+      bskyPostSchema.marks.hashtag.create({ tag }),
+    );
+
+    return tr;
+  });
+}
+
+export function BlueskyPostEditorProsemirror(props: {
+  editorStateRef: React.MutableRefObject<EditorState | null>;
+  initialContent?: string;
+  onCharCountChange?: (count: number) => void;
+}) {
+  const mountRef = useRef<HTMLDivElement | null>(null);
+  const viewRef = useRef<EditorView | null>(null);
+  const [editorState, setEditorState] = useState<EditorState | null>(null);
+  const [mentionState, setMentionState] = useState<{
+    active: boolean;
+    range: { from: number; to: number } | null;
+    selectedMention: { handle: string; did: string } | null;
+  }>({ active: false, range: null, selectedMention: null });
+
+  const handleMentionSelect = useCallback(
+    (
+      mention: { handle: string; did: string },
+      range: { from: number; to: number },
+    ) => {
+      if (!viewRef.current) return;
+      const view = viewRef.current;
+      const { from, to } = range;
+      const tr = view.state.tr;
+
+      // Delete the query text (keep the @)
+      tr.delete(from + 1, to);
+
+      // Insert the mention text after the @
+      const mentionText = mention.handle;
+      tr.insertText(mentionText, from + 1);
+
+      // Apply mention mark to @ and handle
+      tr.addMark(
+        from,
+        from + 1 + mentionText.length,
+        bskyPostSchema.marks.mention.create({ did: mention.did }),
+      );
+
+      // Add a space after the mention
+      tr.insertText(" ", from + 1 + mentionText.length);
+
+      view.dispatch(tr);
+      view.focus();
+    },
+    [],
+  );
+
+  const mentionStateRef = useRef(mentionState);
+  mentionStateRef.current = mentionState;
+
+  useLayoutEffect(() => {
+    if (!mountRef.current) return;
+
+    const initialState = EditorState.create({
+      schema: bskyPostSchema,
+      doc: props.initialContent
+        ? bskyPostSchema.nodeFromJSON({
+            type: "doc",
+            content: props.initialContent.split("\n").map((line) => ({
+              type: "paragraph",
+              content: line ? [{ type: "text", text: line }] : undefined,
+            })),
+          })
+        : undefined,
+      plugins: [
+        inputRules({ rules: [createHashtagInputRule()] }),
+        keymap({
+          "Mod-z": undo,
+          "Mod-y": redo,
+          "Shift-Mod-z": redo,
+          Enter: (state, dispatch) => {
+            // Check if mention autocomplete is active
+            const currentMentionState = mentionStateRef.current;
+            if (
+              currentMentionState.active &&
+              currentMentionState.selectedMention &&
+              currentMentionState.range
+            ) {
+              handleMentionSelect(
+                currentMentionState.selectedMention,
+                currentMentionState.range,
+              );
+              return true;
+            }
+            // Otherwise let the default Enter behavior happen (new paragraph)
+            return false;
+          },
+        }),
+        keymap(baseKeymap),
+        autolink({
+          type: bskyPostSchema.marks.link,
+          shouldAutoLink: () => true,
+          defaultProtocol: "https",
+        }),
+        history(),
+      ],
+    });
+
+    setEditorState(initialState);
+    props.editorStateRef.current = initialState;
+
+    const view = new EditorView(
+      { mount: mountRef.current },
+      {
+        state: initialState,
+        dispatchTransaction(tr) {
+          const newState = view.state.apply(tr);
+          view.updateState(newState);
+          setEditorState(newState);
+          props.editorStateRef.current = newState;
+          props.onCharCountChange?.(newState.doc.textContent.length);
+        },
+      },
+    );
+
+    viewRef.current = view;
+
+    return () => {
+      view.destroy();
+      viewRef.current = null;
+    };
+  }, [handleMentionSelect]);
+
+  return (
+    <div className="relative w-full h-full group">
+      {editorState && (
+        <MentionAutocomplete
+          editorState={editorState}
+          view={viewRef}
+          onSelect={handleMentionSelect}
+          onMentionStateChange={(active, range, selectedMention) => {
+            setMentionState({ active, range, selectedMention });
+          }}
+        />
+      )}
+      {editorState?.doc.textContent.length === 0 && (
+        <div className="italic text-tertiary absolute top-0 left-0 pointer-events-none">
+          Write a post to share your writing!
+        </div>
+      )}
+      <div
+        ref={mountRef}
+        className="border-none outline-none whitespace-pre-wrap min-h-[80px] max-h-[200px] overflow-y-auto prose-sm"
+        style={{
+          wordWrap: "break-word",
+          overflowWrap: "break-word",
+        }}
+      />
+      <IOSBS view={viewRef} />
+    </div>
+  );
+}
+
+function MentionAutocomplete(props: {
+  editorState: EditorState;
+  view: React.RefObject<EditorView | null>;
+  onSelect: (
+    mention: { handle: string; did: string },
+    range: { from: number; to: number },
+  ) => void;
+  onMentionStateChange: (
+    active: boolean,
+    range: { from: number; to: number } | null,
+    selectedMention: { handle: string; did: string } | null,
+  ) => void;
+}) {
+  const [mentionQuery, setMentionQuery] = useState<string | null>(null);
+  const [mentionRange, setMentionRange] = useState<{
+    from: number;
+    to: number;
+  } | null>(null);
+  const [mentionCoords, setMentionCoords] = useState<{
+    top: number;
+    left: number;
+  } | null>(null);
+
+  const { suggestionIndex, setSuggestionIndex, suggestions } =
+    useMentionSuggestions(mentionQuery);
+
+  // Check for mention pattern whenever editor state changes
+  useEffect(() => {
+    const { $from } = props.editorState.selection;
+    const textBefore = $from.parent.textBetween(
+      Math.max(0, $from.parentOffset - 50),
+      $from.parentOffset,
+      null,
+      "\ufffc",
+    );
+
+    // Look for @ followed by word characters before cursor
+    const match = textBefore.match(/@([\w.]*)$/);
+
+    if (match && props.view.current) {
+      const queryBefore = match[1];
+      const from = $from.pos - queryBefore.length - 1;
+
+      // Get text after cursor to find the rest of the handle
+      const textAfter = $from.parent.textBetween(
+        $from.parentOffset,
+        Math.min($from.parent.content.size, $from.parentOffset + 50),
+        null,
+        "\ufffc",
+      );
+
+      // Match word characters after cursor until space or end
+      const afterMatch = textAfter.match(/^([\w.]*)/);
+      const queryAfter = afterMatch ? afterMatch[1] : "";
+
+      // Combine the full handle
+      const query = queryBefore + queryAfter;
+      const to = $from.pos + queryAfter.length;
+
+      setMentionQuery(query);
+      setMentionRange({ from, to });
+
+      // Get coordinates for the autocomplete popup
+      const coords = props.view.current.coordsAtPos(from);
+      setMentionCoords({
+        top: coords.bottom + window.scrollY,
+        left: coords.left + window.scrollX,
+      });
+      setSuggestionIndex(0);
+    } else {
+      setMentionQuery(null);
+      setMentionRange(null);
+      setMentionCoords(null);
+    }
+  }, [props.editorState, props.view, setSuggestionIndex]);
+
+  // Update parent's mention state
+  useEffect(() => {
+    const active = mentionQuery !== null && suggestions.length > 0;
+    const selectedMention =
+      active && suggestions[suggestionIndex]
+        ? suggestions[suggestionIndex]
+        : null;
+    props.onMentionStateChange(active, mentionRange, selectedMention);
+  }, [mentionQuery, suggestions, suggestionIndex, mentionRange]);
+
+  // Handle keyboard navigation for arrow keys only
+  useEffect(() => {
+    if (!mentionQuery || !props.view.current) return;
+
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (suggestions.length === 0) return;
+
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        if (suggestionIndex > 0) {
+          setSuggestionIndex((i) => i - 1);
+        }
+      } else if (e.key === "ArrowDown") {
+        e.preventDefault();
+        if (suggestionIndex < suggestions.length - 1) {
+          setSuggestionIndex((i) => i + 1);
+        }
+      }
+    };
+
+    const dom = props.view.current.dom;
+    dom.addEventListener("keydown", handleKeyDown);
+
+    return () => {
+      dom.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [
+    mentionQuery,
+    suggestions,
+    suggestionIndex,
+    props.view,
+    setSuggestionIndex,
+  ]);
+
+  if (!mentionCoords || suggestions.length === 0) return null;
+
+  // The styles in this component should match the Menu styles in components/Layout.tsx
+  return (
+    <Popover.Root open>
+      {createPortal(
+        <Popover.Anchor
+          style={{
+            top: mentionCoords.top,
+            left: mentionCoords.left,
+            position: "absolute",
+          }}
+        />,
+        document.body,
+      )}
+      <Popover.Portal>
+        <Popover.Content
+          side="bottom"
+          align="start"
+          sideOffset={4}
+          collisionPadding={20}
+          onOpenAutoFocus={(e) => e.preventDefault()}
+          className={`dropdownMenu z-20 bg-bg-page flex flex-col py-1 gap-0.5 border border-border rounded-md shadow-md`}
+        >
+          <ul className="list-none p-0 text-sm">
+            {suggestions.map((result, index) => {
+              return (
+                <div
+                  className={`
+                    MenuItem
+                    font-bold z-10 py-1 px-3
+                    text-left text-secondary
+                    flex gap-2
+                    ${index === suggestionIndex ? "bg-border-light data-[highlighted]:text-secondary" : ""}
+                    hover:bg-border-light hover:text-secondary
+                    outline-none
+                    `}
+                  key={result.did}
+                  onClick={() => {
+                    if (mentionRange) {
+                      props.onSelect(result, mentionRange);
+                      setMentionQuery(null);
+                      setMentionRange(null);
+                      setMentionCoords(null);
+                    }
+                  }}
+                  onMouseDown={(e) => e.preventDefault()}
+                >
+                  @{result.handle}
+                </div>
+              );
+            })}
+          </ul>
+        </Popover.Content>
+      </Popover.Portal>
+    </Popover.Root>
+  );
+}
+
+function useMentionSuggestions(query: string | null) {
+  const [suggestionIndex, setSuggestionIndex] = useState(0);
+  const [suggestions, setSuggestions] = useState<
+    { handle: string; did: string }[]
+  >([]);
+
+  useDebouncedEffect(
+    async () => {
+      if (!query) {
+        setSuggestions([]);
+        return;
+      }
+
+      const agent = new Agent("https://public.api.bsky.app");
+      const result = await agent.searchActorsTypeahead({
+        q: query,
+        limit: 8,
+      });
+      setSuggestions(
+        result.data.actors.map((actor) => ({
+          handle: actor.handle,
+          did: actor.did,
+        })),
+      );
+    },
+    300,
+    [query],
+  );
+
+  useEffect(() => {
+    if (suggestionIndex > suggestions.length - 1) {
+      setSuggestionIndex(Math.max(0, suggestions.length - 1));
+    }
+  }, [suggestionIndex, suggestions.length]);
+
+  return {
+    suggestions,
+    suggestionIndex,
+    setSuggestionIndex,
+  };
+}
+
+/**
+ * Converts a ProseMirror editor state to Bluesky post facets.
+ * Extracts mentions, links, and hashtags from the editor state and returns them
+ * as an array of Bluesky richtext facets with proper byte positions.
+ */
+export function editorStateToFacetedText(
+  state: EditorState,
+): [string, AppBskyRichtextFacet.Main[]] {
+  let fullText = "";
+  let facets: AppBskyRichtextFacet.Main[] = [];
+  let byteOffset = 0;
+
+  // Iterate through each paragraph in the document
+  state.doc.forEach((paragraph) => {
+    if (paragraph.type.name !== "paragraph") return;
+
+    // Process each inline node in the paragraph
+    paragraph.forEach((node) => {
+      if (node.isText) {
+        const text = node.text || "";
+        const unicodeString = new UnicodeString(text);
+
+        // If this text node has marks, create a facet
+        if (node.marks.length > 0) {
+          const facet: AppBskyRichtextFacet.Main = {
+            index: {
+              byteStart: byteOffset,
+              byteEnd: byteOffset + unicodeString.length,
+            },
+            features: marksToFeatures(node.marks),
+          };
+
+          if (facet.features.length > 0) {
+            facets.push(facet);
+          }
+        }
+
+        fullText += text;
+        byteOffset += unicodeString.length;
+      }
+    });
+
+    // Add newline between paragraphs (except after the last one)
+    if (paragraph !== state.doc.lastChild) {
+      const newline = "\n";
+      const unicodeNewline = new UnicodeString(newline);
+      fullText += newline;
+      byteOffset += unicodeNewline.length;
+    }
+  });
+
+  return [fullText, facets];
+}
+
+function marksToFeatures(marks: readonly Mark[]) {
+  const features: AppBskyRichtextFacet.Main["features"] = [];
+
+  for (const mark of marks) {
+    switch (mark.type.name) {
+      case "mention": {
+        features.push({
+          $type: "app.bsky.richtext.facet#mention",
+          did: mark.attrs.did,
+        });
+        break;
+      }
+      case "hashtag": {
+        features.push({
+          $type: "app.bsky.richtext.facet#tag",
+          tag: mark.attrs.tag,
+        });
+        break;
+      }
+      case "link":
+        features.push({
+          $type: "app.bsky.richtext.facet#link",
+          uri: mark.attrs.href as string,
+        });
+        break;
+    }
+  }
+
+  return features;
+}

app/[leaflet_id]/publish/PublishPost.tsx

···
 "use client";
 import { publishToPublication } from "actions/publishToPublication";
 import { DotLoader } from "components/utils/DotLoader";
-import { useState } from "react";
+import { useState, useRef } from "react";
 import { ButtonPrimary } from "components/Buttons";
 import { Radio } from "components/Checkbox";
 import { useParams } from "next/navigation";
···
 import { AtUri } from "@atproto/syntax";
 import { PublishIllustration } from "./PublishIllustration/PublishIllustration";
 import { useReplicache } from "src/replicache";
+import {
+  BlueskyPostEditorProsemirror,
+  editorStateToFacetedText,
+} from "./BskyPostEditorProsemirror";
+import { EditorState } from "prosemirror-state";
 
 type Props = {
   title: string;
···
   } & Props,
 ) => {
   let [shareOption, setShareOption] = useState<"bluesky" | "quiet">("bluesky");
-  let [postContent, setPostContent] = useState("");
+  let editorStateRef = useRef<EditorState | null>(null);
   let [isLoading, setIsLoading] = useState(false);
+  let [charCount, setCharCount] = useState(0);
   let params = useParams();
   let { rep } = useReplicache();
 
···
     if (!doc) return;
 
     let post_url = `https://${props.record?.base_path}/${doc.rkey}`;
+    let [text, facets] = editorStateRef.current
+      ? editorStateToFacetedText(editorStateRef.current)
+      : [];
     if (shareOption === "bluesky")
       await publishPostToBsky({
-        text: postContent,
+        facets: facets || [],
+        text: text || "",
         title: props.title,
         url: post_url,
         description: props.description,
···
                     <p className="text-tertiary">@{props.profile.handle}</p>
                   </div>
                   <div className="flex flex-col">
-                    <AutosizeTextarea
-                      value={postContent}
-                      onChange={(e) =>
-                        setPostContent(e.currentTarget.value.slice(0, 300))
-                      }
-                      placeholder="Write a post to share your writing!"
+                    <BlueskyPostEditorProsemirror
+                      editorStateRef={editorStateRef}
+                      onCharCountChange={setCharCount}
                     />
                   </div>
                   <div className="opaque-container overflow-hidden flex flex-col mt-4 w-full">
···
                     </div>
                   </div>
                   <div className="text-xs text-secondary italic place-self-end pt-2">
-                    {postContent.length}/300
+                    {charCount}/300
                   </div>
                 </div>
               </div>
···
             >
               Back
             </Link>
-            <ButtonPrimary type="submit" className="place-self-end h-[30px]">
+            <ButtonPrimary
+              type="submit"
+              className="place-self-end h-[30px]"
+              disabled={charCount > 300}
+            >
               {isLoading ? <DotLoader /> : "Publish this Post!"}
             </ButtonPrimary>
           </div>

app/[leaflet_id]/publish/publishBskyPost.ts

···
 "use server";
 
-import { Agent as BskyAgent } from "@atproto/api";
+import {
+  AppBskyRichtextFacet,
+  Agent as BskyAgent,
+  UnicodeString,
+} from "@atproto/api";
 import sharp from "sharp";
 import { TID } from "@atproto/common";
 import { getIdentityData } from "actions/getIdentityData";
···
   description: string;
   document_record: PubLeafletDocument.Record;
   rkey: string;
+  facets: AppBskyRichtextFacet.Main[];
 }) {
   const oauthClient = await createOauthClient();
   let identity = await getIdentityData();
···
     {
       text: args.text,
       createdAt: new Date().toISOString(),
+      facets: args.facets,
       embed: {
         $type: "app.bsky.embed.external",
         external: {

app/api/inngest/client.ts

···
 import { EventSchemas } from "inngest";
 
 export type Events = {
+  "feeds/index-follows": {
+    data: {
+      did: string;
+    };
+  };
   "appview/profile-update": {
     data: {
       record: any;

app/api/inngest/functions/index_follows.ts

···
+import { supabaseServerClient } from "supabase/serverClient";
+import { AtpAgent, AtUri } from "@atproto/api";
+import { createIdentity } from "actions/createIdentity";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { inngest } from "../client";
+import { pool } from "supabase/pool";
+
+export const index_follows = inngest.createFunction(
+  {
+    id: "index_follows",
+    throttle: {
+      limit: 1,
+      period: "5m",
+      key: "event.data.did",
+    },
+  },
+  { event: "feeds/index-follows" },
+  async ({ event, step }) => {
+    let follows: string[] = [];
+    let cursor: null | string = null;
+    let hasMore = true;
+    let pageNumber = 0;
+    while (hasMore) {
+      let page: {
+        cursor?: string;
+        follows: string[];
+      } = await step.run(`get-follows-${pageNumber}`, async () => {
+        let agent = new AtpAgent({ service: "https://public.api.bsky.app" });
+        let follows = await agent.app.bsky.graph.getFollows({
+          actor: event.data.did,
+          limit: 100,
+          cursor: cursor || undefined,
+        });
+        if (!follows.success)
+          throw new Error(
+            "error during querying follows for: " + event.data.did,
+          );
+        return {
+          cursor: follows.data.cursor,
+          follows: follows.data.follows.map((f) => f.did),
+        };
+      });
+      pageNumber++;
+      follows.push(...page.follows);
+      cursor = page.cursor || null;
+      if (!cursor) hasMore = false;
+    }
+    let existingFollows: string[] = [];
+    const batchSize = 100;
+    let batchNumber = 0;
+
+    // Create all check batches in parallel
+    const checkBatches: Promise<any>[] = [
+      step.run("check-if-identity-exists", async () => {
+        let { data: exists } = await supabaseServerClient
+          .from("identities")
+          .select()
+          .eq("atp_did", event.data.did)
+          .single();
+        if (!exists) {
+          const client = await pool.connect();
+          let db = drizzle(client);
+          let identity = await createIdentity(db, { atp_did: event.data.did });
+          client.release();
+          return identity;
+        }
+      }),
+    ];
+    for (let i = 0; i < follows.length; i += batchSize) {
+      const batch = follows.slice(i, i + batchSize);
+      checkBatches.push(
+        step.run(`check-existing-follows-batch-${batchNumber}`, async () => {
+          const { data: existingIdentities } = await supabaseServerClient
+            .from("identities")
+            .select("atp_did")
+            .in("atp_did", batch);
+
+          return existingIdentities?.map((identity) => identity.atp_did!) || [];
+        }),
+      );
+      batchNumber++;
+    }
+
+    // Wait for all check batches to complete
+    const batchResults = await Promise.all(checkBatches);
+    existingFollows = batchResults.flat().filter(Boolean);
+
+    // Filter follows to only include those that exist in identities table
+    const insertBatchSize = 100;
+    let insertBatchNumber = 0;
+
+    // Create all insert batches in parallel
+    const insertBatches = [];
+    for (let i = 0; i < existingFollows.length; i += insertBatchSize) {
+      const batch = existingFollows.slice(i, i + insertBatchSize);
+      insertBatches.push(
+        step.run(`insert-follows-batch-${insertBatchNumber}`, async () => {
+          const insertData = batch.map((f) => ({
+            identity: event.data.did,
+            follows: f,
+          }));
+
+          return await supabaseServerClient
+            .from("bsky_follows")
+            .upsert(insertData);
+        }),
+      );
+      insertBatchNumber++;
+    }
+
+    // Wait for all insert batches to complete
+    await Promise.all(insertBatches);
+
+    // Delete follows that are no longer in the fetched list
+    // For large follow lists, we need to batch this operation
+    await step.run("delete-unfollowed", async () => {
+      // Get all current follows from the database
+      const { data: currentFollows } = await supabaseServerClient
+        .from("bsky_follows")
+        .select("follows")
+        .eq("identity", event.data.did);
+
+      if (!currentFollows || currentFollows.length === 0) {
+        return { deleted: 0 };
+      }
+
+      // Find follows that are in the database but not in the newly fetched list
+      const currentFollowDids = currentFollows.map((f) => f.follows);
+      const toDelete = currentFollowDids.filter(
+        (did) => !existingFollows.includes(did)
+      );
+
+      if (toDelete.length === 0) {
+        return { deleted: 0 };
+      }
+
+      // Delete in batches to avoid query size limits
+      const deleteBatchSize = 100;
+      const deletePromises = [];
+      for (let i = 0; i < toDelete.length; i += deleteBatchSize) {
+        const batch = toDelete.slice(i, i + deleteBatchSize);
+        deletePromises.push(
+          supabaseServerClient
+            .from("bsky_follows")
+            .delete()
+            .eq("identity", event.data.did)
+            .in("follows", batch)
+        );
+      }
+
+      await Promise.all(deletePromises);
+      return { deleted: toDelete.length };
+    });
+    return {
+      done: true,
+    };
+  },
+);

app/api/inngest/route.tsx

···
 import { index_post_mention } from "./functions/index_post_mention";
 import { come_online } from "./functions/come_online";
 import { batched_update_profiles } from "./functions/batched_update_profiles";
+import { index_follows } from "./functions/index_follows";
 
-// Create an API that serves zero functions
 export const { GET, POST, PUT } = serve({
   client: inngest,
-  functions: [index_post_mention, come_online, batched_update_profiles],
+  functions: [
+    index_post_mention,
+    come_online,
+    batched_update_profiles,
+    index_follows,
+  ],
 });

app/api/oauth/[route]/route.ts

···
     case "callback": {
       const params = new URLSearchParams(req.url.split("?")[1]);
 
-      //TODO remember to reset this to a better default!
-      let redirectPath = "/lish";
+      let redirectPath = "/";
       try {
         const { session, state } = await client.callback(params);
         let s: OauthRequestClientState = JSON.parse(state || "{}");
···
   else url = new URL(decodeURIComponent(redirectPath), "https://example.com");
   if (action?.action === "subscribe") {
     let result = await subscribeToPublication(action.publication);
-    console.log(result);
     if (result.hasFeed === false)
       url.searchParams.set("showSubscribeSuccess", "true");
   }

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

···
       let errorResponse = e as NextApiResponse;
       if (errorResponse.statusCode === 403) {
         try {
-          let verification = await vercel.projects.getProjectDomain({
-            idOrName: "prj_9jX4tmYCISnm176frFxk07fF74kG",
-            teamId: "team_42xaJiZMTw9Sr7i0DcLTae9d",
-            domain,
-          });
-          if (!verification.verification) return {};
+          let [verification, config] = await Promise.all([
+            vercel.projects.getProjectDomain({
+              idOrName: "prj_9jX4tmYCISnm176frFxk07fF74kG",
+              teamId: "team_42xaJiZMTw9Sr7i0DcLTae9d",
+              domain,
+            }),
+            vercel.domains.getDomainConfig({
+              domain,
+              teamId: "team_42xaJiZMTw9Sr7i0DcLTae9d",
+            }),
+          ]);
+          if (!verification.verification) {
+            return { config };
+          }
           return {
-            error: "Verification_needed",
             verification: verification.verification,
+            config,
           } as const;
         } catch (e) {
           return { error: true };

app/discover/PubListing.tsx

···
 "use client";
 import { AtUri } from "@atproto/syntax";
+import { PublicationSubscription } from "app/reader/getSubscriptions";
+import { PubIcon } from "components/ActionBar/Publications";
+import { Separator } from "components/Layout";
 import { usePubTheme } from "components/ThemeManager/PublicationThemeProvider";
 import { BaseThemeProvider } from "components/ThemeManager/ThemeProvider";
 import { PubLeafletPublication, PubLeafletThemeColor } from "lexicons/api";
···
 import { timeAgo } from "src/utils/timeAgo";
 import { Json } from "supabase/database.types";
 
-export const PubListing = (props: {
-  record: Json;
-  uri: string;
-  documents_in_publications: {
-    indexed_at: string;
-    documents: { data: Json } | null;
-  }[];
-}) => {
+export const PubListing = (
+  props: PublicationSubscription & {
+    resizeHeight?: boolean;
+  },
+) => {
   let record = props.record as PubLeafletPublication.Record;
   let theme = usePubTheme(record);
   let backgroundImage = record?.theme?.backgroundImage?.image?.ref
···
           hover:outline-accent-contrast hover:border-accent-contrast`}
       >
         <div
-          style={{
-            backgroundRepeat: "no-repeat",
-            backgroundPosition: "center",
-            backgroundSize: "cover",
-            backgroundImage: record?.icon
-              ? `url(${blobRefToSrc(record.icon?.ref, new AtUri(props.uri).host)})`
-              : undefined,
-          }}
-          className={`w-6 h-6 rounded-full bg-accent-1 text-accent-2 flex place-content-center leading-snug font-bold text-center shrink-0 ${record.theme?.showPageBackground ? "mt-[6px]" : "mt-0.5"}`}
-        >
-          {!record?.icon ? record.name.slice(0, 1).toLocaleUpperCase() : null}
-        </div>
-        <div
-          className={`flex w-full flex-col ${record.theme?.showPageBackground ? "bg-[rgba(var(--bg-page),var(--bg-page-alpha))] px-2 py-1 rounded-lg" : ""}`}
+          className={`flex w-full flex-col justify-center text-center max-h-48 pt-4 pb-3 px-3 rounded-lg ${props.resizeHeight ? "" : "sm:h-48 h-full"} ${record.theme?.showPageBackground ? "bg-[rgba(var(--bg-page),var(--bg-page-alpha))] " : ""}`}
         >
-          <h3>{record.name}</h3>
-          <p className="text-secondary">{record.description}</p>
-          <div className="flex gap-1 items-center text-sm text-tertiary pt-2 ">
+          <div className="mx-auto pb-1">
+            <PubIcon record={record} uri={props.uri} large />
+          </div>
+
+          <h4 className="truncate shrink-0 ">{record.name}</h4>
+          {record.description && (
+            <p className="text-secondary text-sm max-h-full overflow-hidden pb-1">
+              {record.description}
+            </p>
+          )}
+          <div className="flex flex-col items-center justify-center text-xs text-tertiary pt-2">
+            <div className="flex flex-row gap-2 items-center">
+              {props.authorProfile?.handle}
+            </div>
             <p>
-              Updated {timeAgo(props.documents_in_publications[0].indexed_at)}
+              Updated{" "}
+              {timeAgo(
+                props.documents_in_publications?.[0]?.documents?.indexed_at ||
+                  "",
+              )}
             </p>
           </div>
         </div>

app/discover/SortedPublicationList.tsx

···
             );
             return bDate.getTime() - aDate.getTime();
           })
-          .map((pub) => <PubListing key={pub.uri} {...pub} />)}
+          .map((pub) => <PubListing resizeHeight key={pub.uri} {...pub} />)}
       </div>
     </div>
   );

app/discover/page.tsx

···
     <div className="w-full h-full mx-auto bg-[#FDFCFA]">
       <DashboardLayout
         id="discover"
-        hasBackgroundImage={false}
+        cardBorderHidden={false}
         currentPage="discover"
         defaultTab="default"
         actions={null}

app/home/Actions/Actions.tsx

···
       {identity ? <AccountSettings /> : <LoginActionButton />}
       {/*<HelpPopover noShortcuts />*/}
       <ThemePopover entityID={rootEntity} home />
+      <HelpPopover />
     </>
   );
 };

app/home/HomeEmpty/HomeEmpty.tsx

···
 export const PublicationBanner = (props: { small?: boolean }) => {
   return (
     <div
-      className={`accent-container flex sm:py-2 gap-4 items-center ${props.small ? "items-start p-2 text-sm font-normal" : "items-center p-4"}`}
+      className={`accent-container flex sm:py-2  items-center ${props.small ? "items-start gap-2 p-2 text-sm font-normal" : "items-center p-4 gap-4"}`}
     >
       {props.small ? (
-        <PublishSmall className="shrink-0" />
+        <PublishSmall className="shrink-0 text-accent-contrast" />
       ) : (
         <div className="w-[64px] mx-auto">
           <PubListEmptyIllo />
         </div>
       )}
-      <div className="grow">
+      <div className={`${props.small ? "pt-[2px]" : ""} grow`}>
         <Link href={"/lish/createPub"} className="font-bold">
           Start a Publication
         </Link>{" "}
···
 export const DiscoverBanner = (props: { small?: boolean }) => {
   return (
     <div
-      className={`accent-container flex sm:py-2 gap-4 items-center ${props.small ? "items-start p-2 text-sm font-normal" : "items-center p-4"}`}
+      className={`accent-container flex sm:py-2  items-center ${props.small ? "items-start gap-2 p-2 text-sm font-normal" : "items-center p-4 gap-4"}`}
     >
       {props.small ? (
-        <DiscoverSmall className="shrink-0" />
+        <DiscoverSmall className="shrink-0 text-accent-contrast" />
       ) : (
         <div className="w-[64px] mx-auto">
           <DiscoverIllo />
         </div>
       )}
-      <div className="grow">
+      <div className={`${props.small ? "pt-[2px]" : ""} grow`}>
         <Link href={"/discover"} className="font-bold">
           Explore Publications
         </Link>{" "}

app/home/HomeLayout.tsx

···
   return (
     <DashboardLayout
       id="home"
-      hasBackgroundImage={hasBackgroundImage}
+      cardBorderHidden={cardBorderHidden}
       currentPage="home"
       defaultTab="home"
       actions={<Actions />}
···
       {leaflets.filter((l) => !!l.token.leaflets_in_publications).length ===
         0 && <PublicationBanner small />}
       <DiscoverBanner small />
-      <div className="spacer h-8 w-full bg-transparent shrink-0 " />
     </>
   );
 }

app/home/LeafletList/LeafletPreview.tsx

···
       <div className="border border-border-light rounded-md w-full h-full overflow-hidden relative">
         <div className="relative w-full h-full">
           <ThemeBackgroundProvider entityID={root}>
-            <div className="leafletPreview relative grow shrink-0 h-full w-full px-2 pt-2 sm:px-3 sm:pt-3 flex items-end pointer-events-none">
+            <div
+              inert
+              className="leafletPreview relative grow shrink-0 h-full w-full px-2 pt-2 sm:px-3 sm:pt-3 flex items-end pointer-events-none"
+            >
               <div
                 className={`leafletContentWrapper h-full sm:w-48 w-40 mx-auto overflow-clip ${!cardBorderHidden && "border border-border-light border-b-0 rounded-t-md"}`}
                 style={

app/lish/Subscribe.tsx

···
   pubName: string;
   pub_uri: string;
   subscribers: { identity: string }[];
+  base_url: string;
 }) => {
   let toaster = useToaster();
   let [hasFeed] = useState(false);
···
       <Popover
         trigger={<div className="text-accent-contrast text-sm">Manage</div>}
       >
-        <div className="max-w-sm flex flex-col gap-3 justify-center text-center">
+        <div className="max-w-sm flex flex-col gap-1">
+          <h4>Update Options</h4>
+
           {!hasFeed && (
-            <>
-              <div className="flex flex-col gap-2 font-bold text-secondary w-full">
-                Updates via Bluesky custom feed!
-                <a
-                  href="https://bsky.app/profile/leaflet.pub/feed/subscribedPublications"
-                  target="_blank"
-                  className=" place-self-center"
-                >
-                  <ButtonPrimary>View Feed</ButtonPrimary>
-                </a>
-              </div>
-              <hr className="border-border-light" />
-            </>
+            <a
+              href="https://bsky.app/profile/leaflet.pub/feed/subscribedPublications"
+              target="_blank"
+              className=" place-self-center"
+            >
+              <ButtonPrimary fullWidth compact className="!px-4">
+                View Bluesky Custom Feed
+              </ButtonPrimary>
+            </a>
           )}
+
+          <a href={`${props.base_url}/rss`} className="flex" target="_blank">
+            <span className="sr-only">Subscribe to RSS</span>
+            <ButtonPrimary fullWidth compact>
+              Get RSS
+            </ButtonPrimary>
+          </a>
+
+          <hr className="border-border-light my-1" />
+
           <form action={unsubscribe}>
             <button className="font-bold text-accent-contrast w-max place-self-center">
               {unsubscribePending ? <DotLoader /> : "Unsubscribe"}

app/lish/[did]/[publication]/[rkey]/Interactions/Comments/CommentBox.tsx

···
   autoFocus?: boolean;
 }) {
   let mountRef = useRef<HTMLPreElement | null>(null);
-  let { commentBox: { quote } } = useInteractionState(props.doc_uri);
+  let {
+    commentBox: { quote },
+  } = useInteractionState(props.doc_uri);
   let [loading, setLoading] = useState(false);
-  
+
   const handleSubmit = async () => {
     if (loading || !view.current) return;
-    
+
     setLoading(true);
     let currentState = view.current.state;
     let [plaintext, facets] = docToFacetedText(currentState.doc);
···
           "Mod-z": undo,
           "Mod-y": redo,
           "Shift-Mod-z": redo,
-          "Ctrl-Enter": () => { handleSubmit(); return true; },
-          "Meta-Enter": () => { handleSubmit(); return true; },
+          "Ctrl-Enter": () => {
+            handleSubmit();
+            return true;
+          },
+          "Meta-Enter": () => {
+            handleSubmit();
+            return true;
+          },
         }),
         keymap(baseKeymap),
         autolink({
···
             let xml = new DOMParser().parseFromString(html, "text/html");
             text = xml.textContent || "";
           }
-          console.log("URL: " + window.location.toString());
-          console.log("TEXT: " + text, text?.includes(QUOTE_PARAM));
           if (
             text?.includes(QUOTE_PARAM) &&
             text.includes(window.location.toString())
···
           }
         },
         dispatchTransaction(tr) {
-          console.log("dispatching?");
           let newState = this.state.apply(tr);
           setEditorState(newState);
           view.current?.updateState(newState);
···
       view.current = null;
     };
   }, []);
-  
+
   return (
     <div className=" flex flex-col">
       {quote && (
···
           <button
             className="text-border absolute -top-3 right-1 bg-bg-page p-1 rounded-full"
             onClick={() =>
-              setInteractionState(props.doc_uri, { commentBox: { quote: null } })
+              setInteractionState(props.doc_uri, {
+                commentBox: { quote: null },
+              })
             }
           >
             <CloseFillTiny />
···
             view={view}
           />
         </div>
-        <ButtonPrimary
-          compact
-          onClick={handleSubmit}
-        >
+        <ButtonPrimary compact onClick={handleSubmit}>
           {loading ? <DotLoader /> : <ShareSmall />}
         </ButtonPrimary>
       </div>

app/lish/[did]/[publication]/[rkey]/PostHeader/PostHeader.tsx

···
 
 export function PostHeader(props: {
   data: PostPageData;
-  name: string;
   profile: ProfileViewDetailed;
   preferences: { showComments?: boolean };
 }) {
···
               )
             }
           >
-            {props.name}
+            {pub?.name}
           </SpeedyLink>
           {identity &&
             identity.atp_did ===
               document.documents_in_publications[0]?.publications
-                .identity_did && (
+                .identity_did &&
+            document.leaflets_in_publications[0] && (
               <a
                 className=" rounded-full  flex place-items-center"
                 href={`https://leaflet.pub/${document.leaflets_in_publications[0].leaflet}`}

app/lish/[did]/[publication]/[rkey]/PublishBskyPostBlock.tsx

···
       let postId = post.uri.split("/")[4];
       let url = `https://bsky.app/profile/${post.author.handle}/post/${postId}`;
 
-      let datetimeFormatted = new Date(
-        timestamp ? timestamp : "",
-      ).toLocaleString("en-US", {
-        month: "short",
-        day: "numeric",
-        year: "numeric",
-        hour: "numeric",
-        minute: "numeric",
-        hour12: true,
-      });
       return (
         <div
           className={`
···
             </>
           )}
           <div className="w-full flex gap-2 items-center justify-between">
-            <div className="text-xs text-tertiary">{datetimeFormatted}</div>
+            <ClientDate date={timestamp} />
             <div className="flex gap-2 items-center">
               {post.replyCount && post.replyCount > 0 && (
                 <>
···
       );
   }
 };
+
+const ClientDate = (props: { date?: string }) => {
+  let pageLoaded = useInitialPageLoad();
+  if (!pageLoaded) return null;
+
+  let datetimeFormatted = new Date(props.date ? props.date : "").toLocaleString(
+    "en-US",
+    {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      hour12: true,
+    },
+  );
+
+  return <div className="text-xs text-tertiary">{datetimeFormatted}</div>;
+};

app/lish/[did]/[publication]/[rkey]/QuoteHandler.tsx

···
 import { CommentTiny } from "components/Icons/CommentTiny";
 import { setInteractionState } from "./Interactions/Interactions";
 import { PostPageContext } from "./PostPageContext";
+import { PubLeafletPublication } from "lexicons/api";
 
 export function QuoteHandler() {
   let [position, setPosition] = useState<{
···
   let { identity } = useIdentityData();
   const data = useContext(PostPageContext);
   const document_uri = data?.uri;
-  if (!document_uri) throw new Error('document_uri not available in PostPageContext');
+  if (!document_uri)
+    throw new Error("document_uri not available in PostPageContext");
   let [url, position] = useMemo(() => {
     let currentUrl = new URL(window.location.href);
     let pos = decodeQuotePosition(props.position);
···
       currentUrl.pathname = currentUrl.pathname.split("/l-quote/")[0];
     }
     currentUrl.pathname = currentUrl.pathname + `/l-quote/${props.position}`;
-    
+
     // Clear existing query parameters
     currentUrl.search = "";
 
     currentUrl.hash = `#${pos?.start.block.join(".")}_${pos?.start.offset}`;
     return [currentUrl.toString(), pos];
   }, [props.position]);
+  let pubRecord = data.documents_in_publications[0]?.publications?.record as
+    | PubLeafletPublication.Record
+    | undefined;
 
   return (
     <>
···
         <CopyTiny className="shrink-0" />
         Link
       </button>
-      <Separator classname="h-4" />
-
-      {identity?.atp_did && (
-        <button
-          className="flex gap-1 items-center hover:font-bold px-1"
-          onClick={() => {
-            if (!position) return;
-            setInteractionState(document_uri, {
-              drawer: "comments",
-              drawerOpen: true,
-              commentBox: { quote: position },
-            });
-          }}
-        >
-          <CommentTiny /> Comment
-        </button>
+      {pubRecord?.preferences?.showComments !== false && identity?.atp_did && (
+        <>
+          <Separator classname="h-4" />
+          <button
+            className="flex gap-1 items-center hover:font-bold px-1"
+            onClick={() => {
+              if (!position) return;
+              setInteractionState(document_uri, {
+                drawer: "comments",
+                drawerOpen: true,
+                commentBox: { quote: position },
+              });
+            }}
+          >
+            <CommentTiny /> Comment
+          </button>
+        </>
       )}
     </>
   );

app/lish/[did]/[publication]/[rkey]/page.tsx

···
 }): Promise<Metadata> {
   let params = await props.params;
   let did = decodeURIComponent(params.did);
-  let publication = decodeURIComponent(params.publication);
   if (!did) return { title: "Publication 404" };
 
   let [{ data: document }] = await Promise.all([
     supabaseServerClient
       .from("documents")
-      .select("*")
+      .select("*, documents_in_publications(publications(*))")
       .eq("uri", AtUri.make(did, ids.PubLeafletDocument, params.rkey))
       .single(),
   ]);
···
   let docRecord = document.data as PubLeafletDocument.Record;
 
   return {
-    title: docRecord.title + " - " + publication,
+    title:
+      docRecord.title +
+      " - " +
+      document.documents_in_publications[0]?.publications?.name,
     description: docRecord?.description || "",
   };
 }
···
               bskyPostData={bskyPostData.data.posts}
               did={did}
               blocks={blocks}
-              name={decodeURIComponent((await props.params).publication)}
               prerenderedCodeBlocks={prerenderedCodeBlocks}
             />
           </LeafletLayout>

app/lish/[did]/[publication]/dashboard/DraftList.tsx

···
         titles={{
           ...leaflets_in_publications.reduce(
             (acc, leaflet) => {
-              if (leaflet.title && leaflet.permission_tokens)
-                acc[leaflet.permission_tokens.root_entity] = leaflet.title;
+              if (leaflet.permission_tokens)
+                acc[leaflet.permission_tokens.root_entity] =
+                  leaflet.title || "Untitled";
               return acc;
             },
             {} as { [l: string]: string },

app/lish/[did]/[publication]/dashboard/PublicationDashboard.tsx

···
   return (
     <DashboardLayout
       id={publication.uri}
-      hasBackgroundImage={!!record?.theme?.backgroundImage}
+      cardBorderHidden={!!record.theme?.showPageBackground}
       defaultTab="Drafts"
       tabs={{
         Drafts: {

app/lish/[did]/[publication]/dashboard/page.tsx

···
       </PublicationSWRDataProvider>
     );
   } catch (e) {
-    console.log(e);
     return <pre>{JSON.stringify(e, undefined, 2)}</pre>;
   }
 }

app/lish/[did]/[publication]/icon.ts

···
 
     let identity = await idResolver.did.resolve(did);
     let service = identity?.service?.find((f) => f.id === "#atproto_pds");
-    console.log(identity);
     if (!service) return null;
     let cid = (record.icon.ref as unknown as { $link: string })["$link"];
     const response = await fetch(
···
     let resizedImage = await sharp(await blob.arrayBuffer())
       .resize({ width: 32, height: 32 })
       .toBuffer();
-    console.log("fetched favicon!");
     return new Response(new Uint8Array(resizedImage), {
       headers: {
         "Content-Type": "image/png",

app/lish/createPub/CreatePubForm.tsx

···
             </a>
           </p>
           <p className="text-sm text-tertiary font-normal">
-            This publication will appear on our public Discover page
+            You'll be able to change this later!
           </p>
         </div>
       </Checkbox>

app/lish/createPub/UpdatePubForm.tsx

···
 import { Verification } from "@vercel/sdk/esm/models/getprojectdomainop";
 import Link from "next/link";
 import { Checkbox } from "components/Checkbox";
+import type { GetDomainConfigResponseBody } from "@vercel/sdk/esm/models/getdomainconfigop";
 
 export const EditPubForm = () => {
   let { data } = usePublicationData();
···
   let [state, setState] = useState<
     | { type: "default" }
     | { type: "addDomain" }
-    | { type: "domainSettings"; domain: string; verification?: Verification[] }
+    | {
+        type: "domainSettings";
+        domain: string;
+        verification?: Verification[];
+        config?: GetDomainConfigResponseBody;
+      }
   >({ type: "default" });
   let domains = pubData?.publication_domains || [];
 
···
         ) : state.type === "domainSettings" ? (
           <DomainSettings
             verification={state.verification}
+            config={state.config}
             domain={state.domain}
             goBack={() => setState({ type: "default" })}
           />
···
                     setState({
                       type: "domainSettings",
                       domain: d.domain,
-                      verification: v,
+                      verification: v?.verification,
+                      config: v?.config,
                     });
                   }}
                 />
···
   domain: string;
   base_path: string;
   publication_uri: string;
-  setDomain: (v?: Verification[]) => void;
+  setDomain: (domain?: {
+    verification?: Verification[];
+    config?: GetDomainConfigResponseBody;
+  }) => void;
 }) {
   let { data } = useSWR(props.domain, async (domain) => {
     return await callRPC("get_domain_status", { domain });
   });
 
-  let pending = data?.config?.misconfigured || data?.error;
-  console.log(props.domain, data);
+  let pending = data?.config?.misconfigured || data?.verification;
 
   return (
     <div className="text-sm text-secondary relative w-full ">
···
           <button
             className="group/pending px-1 py-0.5 flex gap-1 items-center rounded-full  hover:bg-accent-1  hover:text-accent-2 hover:outline-accent-1 border-transparent outline-solid outline-transparent selected-outline"
             onClick={() => {
-              if (data?.error === "Verification_needed") {
-                props.setDomain(data.verification);
-              } else {
-                props.setDomain();
-              }
+              props.setDomain(data);
             }}
           >
             <p className="group-hover/pending:block hidden w-max pl-1 font-bold">
···
 
 const DomainSettings = (props: {
   domain: string;
+  config?: GetDomainConfigResponseBody;
   goBack: () => void;
   verification?: Verification[];
 }) => {
+  let { data, mutate } = useSWR(props.domain, async (domain) => {
+    return await callRPC("get_domain_status", { domain });
+  });
   let isSubdomain = props.domain.split(".").length > 2;
-  if (props.verification)
-    return (
-      <div className="flex flex-col gap-[6px] text-sm">
-        <div>{props.domain} is in use on a Vercel account.</div>
-        <div className="flex gap-3 p-1 border border-border-light rounded-md py-1">
-          <div className="flex flex-col ">
-            <div className="text-tertiary">Type</div>
-            <div>{props.verification[0].type}</div>
-          </div>
-          <div className="flex flex-col">
-            <div className="text-tertiary">Name</div>
-            <div style={{ wordBreak: "break-word" }}>
-              {props.verification[0].domain}
-            </div>
-          </div>
-          <div className="flex flex-col">
-            <div className="text-tertiary">Value</div>
-            <div style={{ wordBreak: "break-word" }}>
-              {props.verification?.[0].value}
-            </div>
-          </div>
-        </div>
-        <div>
-          <button
-            className="text-accent-contrast w-fit"
-            onClick={() => props.goBack()}
-          >
-            Back
-          </button>
-        </div>
-        <button className="text-accent-contrast w-fit">verify</button>
-      </div>
-    );
-
+  if (!data) return;
+  let { config, verification } = data;
+  if (!config?.misconfigured && !verification)
+    return <div>This domain is verified!</div>;
   return (
-    <div className="flex flex-col gap-[6px] text-sm">
+    <div className="flex flex-col gap-[6px] text-sm text-primary">
       <div>
         To verify this domain, add the following record to your DNS provider for{" "}
         <strong>{props.domain}</strong>.
       </div>
-
-      {isSubdomain ? (
-        <div className="flex gap-3 p-1 border border-border-light rounded-md py-1">
-          <div className="flex flex-col ">
-            <div className="text-tertiary">Type</div>
-            <div>CNAME</div>
-          </div>
-          <div className="flex flex-col">
-            <div className="text-tertiary">Name</div>
-            <div style={{ wordBreak: "break-word" }}>
-              {props.domain.split(".").slice(0, -2).join(".")}
-            </div>
-          </div>
-          <div className="flex flex-col">
-            <div className="text-tertiary">Value</div>
-            <div style={{ wordBreak: "break-word" }}>cname.vercel-dns.com</div>
-          </div>
-        </div>
-      ) : (
-        <div className="flex gap-3 px-2 py-1 border border-border-light rounded-md ">
-          <div className="flex flex-col ">
-            <div className="text-tertiary">Type</div>
-            <div>A</div>
-          </div>
-          <div className="flex flex-col">
-            <div className="text-tertiary">Name</div>
-            <div>@</div>
-          </div>
-          <div className="flex flex-col">
-            <div className="text-tertiary">Value</div>
-            <div>76.76.21.21</div>
-          </div>
-        </div>
-      )}
-      <button
-        className="text-accent-contrast w-fit"
-        onClick={() => props.goBack()}
-      >
-        Back
-      </button>
+      <table className="border border-border-light rounded-md">
+        <thead>
+          <tr>
+            <th className="p-1 py-1 text-tertiary">Type</th>
+            <th className="p-1 py-1 text-tertiary">Name</th>
+            <th className="p-1 py-1 text-tertiary">Value</th>
+          </tr>
+        </thead>
+        <tbody>
+          {verification && (
+            <tr>
+              <td className="p-1 py-1">
+                <div>{verification[0].type}</div>
+              </td>
+              <td className="p-1 py-1">
+                <div style={{ wordBreak: "break-word" }}>
+                  {verification[0].domain}
+                </div>
+              </td>
+              <td className="p-1 py-1">
+                <div style={{ wordBreak: "break-word" }}>
+                  {verification?.[0].value}
+                </div>
+              </td>
+            </tr>
+          )}
+          {config &&
+            (isSubdomain ? (
+              <tr>
+                <td className="p-1 py-1">
+                  <div>CNAME</div>
+                </td>
+                <td className="p-1 py-1">
+                  <div style={{ wordBreak: "break-word" }}>
+                    {props.domain.split(".").slice(0, -2).join(".")}
+                  </div>
+                </td>
+                <td className="p-1 py-1">
+                  <div style={{ wordBreak: "break-word" }}>
+                    {
+                      config?.recommendedCNAME.sort(
+                        (a, b) => a.rank - b.rank,
+                      )[0].value
+                    }
+                  </div>
+                </td>
+              </tr>
+            ) : (
+              <tr>
+                <td className="p-1 py-1">
+                  <div>A</div>
+                </td>
+                <td className="p-1 py-1">
+                  <div style={{ wordBreak: "break-word" }}>@</div>
+                </td>
+                <td className="p-1 py-1">
+                  <div style={{ wordBreak: "break-word" }}>
+                    {
+                      config?.recommendedIPv4.sort((a, b) => a.rank - b.rank)[0]
+                        .value[0]
+                    }
+                  </div>
+                </td>
+              </tr>
+            ))}
+          {config?.configuredBy === "CNAME" && config.recommendedCNAME[0] && (
+            <tr></tr>
+          )}
+        </tbody>
+      </table>
+      <div className="flex flex-row justify-between">
+        <button
+          className="text-accent-contrast w-fit"
+          onClick={() => props.goBack()}
+        >
+          Back
+        </button>
+        <VerifyButton verify={() => mutate()} />
+      </div>
     </div>
   );
 };
+
+const VerifyButton = (props: { verify: () => Promise<any> }) => {
+  let [loading, setLoading] = useState(false);
+  return (
+    <button
+      className="text-accent-contrast w-fit"
+      onClick={async (e) => {
+        e.preventDefault();
+        setLoading(true);
+        await props.verify();
+        setLoading(false);
+      }}
+    >
+      {loading ? <DotLoader /> : "verify"}
+    </button>
+  );
+};

app/lish/subscribeToPublication.ts

···
   let bsky = new BskyAgent(credentialSession);
   let [prefs, profile, resolveDid] = await Promise.all([
     bsky.app.bsky.actor.getPreferences(),
-    bsky.app.bsky.actor.profile.get({
-      repo: credentialSession.did!,
-      rkey: "self",
-    }),
+    bsky.app.bsky.actor.profile
+      .get({
+        repo: credentialSession.did!,
+        rkey: "self",
+      })
+      .catch(),
     idResolver.did.resolve(credentialSession.did!),
   ]);
   if (!identity.bsky_profiles && profile.value) {
···
 }
 
 export async function unsubscribeToPublication(publication: string) {
-  console.log("calling unsubscribe!");
   const oauthClient = await createOauthClient();
   let identity = await getIdentityData();
   if (!identity || !identity.atp_did) return;

app/reader/ReaderContent.tsx

···
+"use client";
+import { AtUri } from "@atproto/api";
+import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
+import { PubIcon } from "components/ActionBar/Publications";
+import { ButtonPrimary } from "components/Buttons";
+import { CommentTiny } from "components/Icons/CommentTiny";
+import { DiscoverSmall } from "components/Icons/DiscoverSmall";
+import { QuoteTiny } from "components/Icons/QuoteTiny";
+import { Separator } from "components/Layout";
+import { SpeedyLink } from "components/SpeedyLink";
+import { usePubTheme } from "components/ThemeManager/PublicationThemeProvider";
+import { BaseThemeProvider } from "components/ThemeManager/ThemeProvider";
+import { useSmoker } from "components/Toast";
+import { PubLeafletDocument, PubLeafletPublication } from "lexicons/api";
+import { blobRefToSrc } from "src/utils/blobRefToSrc";
+import { Json } from "supabase/database.types";
+import type { Cursor, Post } from "./getReaderFeed";
+import useSWRInfinite from "swr/infinite";
+import { getReaderFeed } from "./getReaderFeed";
+import { useEffect, useRef } from "react";
+import { useRouter } from "next/navigation";
+import Link from "next/link";
+
+export const ReaderContent = (props: {
+  root_entity: string;
+  posts: Post[];
+  nextCursor: Cursor | null;
+}) => {
+  const getKey = (
+    pageIndex: number,
+    previousPageData: { posts: Post[]; nextCursor: Cursor | null } | null,
+  ) => {
+    // Reached the end
+    if (previousPageData && !previousPageData.nextCursor) return null;
+
+    // First page, we don't have previousPageData
+    if (pageIndex === 0) return ["reader-feed", null] as const;
+
+    // Add the cursor to the key
+    return ["reader-feed", previousPageData?.nextCursor] as const;
+  };
+
+  const { data, error, size, setSize, isValidating } = useSWRInfinite(
+    getKey,
+    ([_, cursor]) => getReaderFeed(cursor),
+    {
+      fallbackData: [{ posts: props.posts, nextCursor: props.nextCursor }],
+      revalidateFirstPage: false,
+    },
+  );
+
+  const loadMoreRef = useRef<HTMLDivElement>(null);
+
+  // Set up intersection observer to load more when trigger element is visible
+  useEffect(() => {
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting && !isValidating) {
+          const hasMore = data && data[data.length - 1]?.nextCursor;
+          if (hasMore) {
+            setSize(size + 1);
+          }
+        }
+      },
+      { threshold: 0.1 },
+    );
+
+    if (loadMoreRef.current) {
+      observer.observe(loadMoreRef.current);
+    }
+
+    return () => observer.disconnect();
+  }, [data, size, setSize, isValidating]);
+
+  const allPosts = data ? data.flatMap((page) => page.posts) : [];
+
+  if (allPosts.length === 0 && !isValidating) return <ReaderEmpty />;
+
+  return (
+    <div className="flex flex-col gap-3 relative">
+      {allPosts.map((p) => (
+        <Post {...p} key={p.documents.uri} />
+      ))}
+      {/* Trigger element for loading more posts */}
+      <div
+        ref={loadMoreRef}
+        className="absolute bottom-96 left-0 w-full h-px pointer-events-none"
+        aria-hidden="true"
+      />
+      {isValidating && (
+        <div className="text-center text-tertiary py-4">
+          Loading more posts...
+        </div>
+      )}
+    </div>
+  );
+};
+
+const Post = (props: Post) => {
+  let pubRecord = props.publication.pubRecord as PubLeafletPublication.Record;
+
+  let postRecord = props.documents.data as PubLeafletDocument.Record;
+  let postUri = new AtUri(props.documents.uri);
+
+  let theme = usePubTheme(pubRecord);
+  let backgroundImage = pubRecord?.theme?.backgroundImage?.image?.ref
+    ? blobRefToSrc(
+        pubRecord?.theme?.backgroundImage?.image?.ref,
+        new AtUri(props.publication.uri).host,
+      )
+    : null;
+
+  let backgroundImageRepeat = pubRecord?.theme?.backgroundImage?.repeat;
+  let backgroundImageSize = pubRecord?.theme?.backgroundImage?.width || 500;
+
+  let showPageBackground = pubRecord.theme?.showPageBackground;
+
+  let quotes = props.documents.document_mentions_in_bsky?.[0]?.count || 0;
+  let comments =
+    pubRecord.preferences?.showComments === false
+      ? 0
+      : props.documents.comments_on_documents?.[0]?.count || 0;
+
+  return (
+    <BaseThemeProvider {...theme} local>
+      <div
+        style={{
+          backgroundImage: `url(${backgroundImage})`,
+          backgroundRepeat: backgroundImageRepeat ? "repeat" : "no-repeat",
+          backgroundSize: `${backgroundImageRepeat ? `${backgroundImageSize}px` : "cover"}`,
+        }}
+        className={`no-underline! flex flex-row gap-2 w-full relative
+          bg-bg-leaflet
+          border border-border-light rounded-lg
+          sm:p-2 p-2 selected-outline
+          hover:outline-accent-contrast hover:border-accent-contrast
+          `}
+      >
+        <a
+          className="h-full w-full absolute top-0 left-0"
+          href={`${props.publication.href}/${postUri.rkey}`}
+        />
+        <div
+          className={`${showPageBackground ? "bg-bg-page " : "bg-transparent"}  rounded-md w-full  px-[10px] pt-2 pb-2`}
+          style={{
+            backgroundColor: showPageBackground
+              ? "rgba(var(--bg-page), var(--bg-page-alpha))"
+              : "transparent",
+          }}
+        >
+          <h3 className="text-primary truncate">{postRecord.title}</h3>
+
+          <p className="text-secondary">{postRecord.description}</p>
+          <div className="flex gap-2 justify-between items-end">
+            <div className="flex flex-col-reverse md:flex-row md gap-3 md:gap-2 text-sm text-tertiary items-start justify-start pt-1 md:pt-3">
+              <PubInfo
+                href={props.publication.href}
+                pubRecord={pubRecord}
+                uri={props.publication.uri}
+              />
+              <Separator classname="h-4 !min-h-0 md:block hidden" />
+              <PostInfo
+                author={props.author || ""}
+                publishedAt={postRecord.publishedAt}
+              />
+            </div>
+
+            <PostInterations
+              postUrl={`${props.publication.href}/${postUri.rkey}`}
+              quotesCount={quotes}
+              commentsCount={comments}
+              showComments={pubRecord.preferences?.showComments}
+            />
+          </div>
+        </div>
+      </div>
+    </BaseThemeProvider>
+  );
+};
+
+const PubInfo = (props: {
+  href: string;
+  pubRecord: PubLeafletPublication.Record;
+  uri: string;
+}) => {
+  return (
+    <a
+      href={props.href}
+      className="text-accent-contrast font-bold no-underline text-sm flex gap-1 items-center md:w-fit w-full relative shrink-0"
+    >
+      <PubIcon small record={props.pubRecord} uri={props.uri} />
+      {props.pubRecord.name}
+    </a>
+  );
+};
+
+const PostInfo = (props: {
+  author: string;
+  publishedAt: string | undefined;
+}) => {
+  return (
+    <div className="flex flex-wrap gap-2 grow items-center shrink-0">
+      {props.author}
+      {props.publishedAt && (
+        <>
+          <Separator classname="h-4 !min-h-0" />
+          {new Date(props.publishedAt).toLocaleDateString("en-US", {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+          })}{" "}
+        </>
+      )}
+    </div>
+  );
+};
+
+const PostInterations = (props: {
+  quotesCount: number;
+  commentsCount: number;
+  postUrl: string;
+  showComments: boolean | undefined;
+}) => {
+  let smoker = useSmoker();
+  let interactionsAvailable =
+    props.quotesCount > 0 ||
+    (props.showComments !== false && props.commentsCount > 0);
+
+  return (
+    <div className={`flex gap-2 text-tertiary text-sm  items-center`}>
+      {props.quotesCount === 0 ? null : (
+        <div className={`flex gap-1 items-center `}>
+          <span className="sr-only">Post quotes</span>
+          <QuoteTiny aria-hidden /> {props.quotesCount}
+        </div>
+      )}
+      {props.showComments === false || props.commentsCount === 0 ? null : (
+        <div className={`flex gap-1 items-center`}>
+          <span className="sr-only">Post comments</span>
+          <CommentTiny aria-hidden /> {props.commentsCount}
+        </div>
+      )}
+      {interactionsAvailable && <Separator classname="h-4 !min-h-0" />}
+      <button
+        id={`copy-post-link-${props.postUrl}`}
+        className="flex gap-1 items-center hover:font-bold relative"
+        onClick={(e) => {
+          e.stopPropagation();
+          e.preventDefault();
+          let mouseX = e.clientX;
+          let mouseY = e.clientY;
+
+          if (!props.postUrl) return;
+          navigator.clipboard.writeText(`leaflet.pub${props.postUrl}`);
+
+          smoker({
+            text: <strong>Copied Link!</strong>,
+            position: {
+              y: mouseY,
+              x: mouseX,
+            },
+          });
+        }}
+      >
+        Share
+      </button>
+    </div>
+  );
+};
+export const ReaderEmpty = () => {
+  return (
+    <div className="flex flex-col gap-2 container bg-[rgba(var(--bg-page),.7)] sm:p-4 p-3 justify-between text-center text-tertiary">
+      Nothing to read yet… <br />
+      Subscribe to publications and find their posts here!
+      <Link href={"/discover"}>
+        <ButtonPrimary className="mx-auto place-self-center">
+          <DiscoverSmall /> Discover Publications
+        </ButtonPrimary>
+      </Link>
+    </div>
+  );
+};

app/reader/SubscriptionsContent.tsx

···
+"use client";
+import { PubListing } from "app/discover/PubListing";
+import { ButtonPrimary } from "components/Buttons";
+import { DiscoverSmall } from "components/Icons/DiscoverSmall";
+import { Json } from "supabase/database.types";
+import { PublicationSubscription, getSubscriptions } from "./getSubscriptions";
+import useSWRInfinite from "swr/infinite";
+import { useEffect, useRef } from "react";
+import { Cursor } from "./getReaderFeed";
+import Link from "next/link";
+
+export const SubscriptionsContent = (props: {
+  publications: PublicationSubscription[];
+  nextCursor: Cursor | null;
+}) => {
+  const getKey = (
+    pageIndex: number,
+    previousPageData: {
+      subscriptions: PublicationSubscription[];
+      nextCursor: Cursor | null;
+    } | null,
+  ) => {
+    // Reached the end
+    if (previousPageData && !previousPageData.nextCursor) return null;
+
+    // First page, we don't have previousPageData
+    if (pageIndex === 0) return ["subscriptions", null] as const;
+
+    // Add the cursor to the key
+    return ["subscriptions", previousPageData?.nextCursor] as const;
+  };
+
+  const { data, error, size, setSize, isValidating } = useSWRInfinite(
+    getKey,
+    ([_, cursor]) => getSubscriptions(cursor),
+    {
+      fallbackData: [
+        { subscriptions: props.publications, nextCursor: props.nextCursor },
+      ],
+      revalidateFirstPage: false,
+    },
+  );
+
+  const loadMoreRef = useRef<HTMLDivElement>(null);
+
+  // Set up intersection observer to load more when trigger element is visible
+  useEffect(() => {
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting && !isValidating) {
+          const hasMore = data && data[data.length - 1]?.nextCursor;
+          if (hasMore) {
+            setSize(size + 1);
+          }
+        }
+      },
+      { threshold: 0.1 },
+    );
+
+    if (loadMoreRef.current) {
+      observer.observe(loadMoreRef.current);
+    }
+
+    return () => observer.disconnect();
+  }, [data, size, setSize, isValidating]);
+
+  const allPublications = data
+    ? data.flatMap((page) => page.subscriptions)
+    : [];
+
+  if (allPublications.length === 0 && !isValidating)
+    return <SubscriptionsEmpty />;
+
+  return (
+    <div className="relative">
+      <div className="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-2 lg:grid-cols-3 gap-3">
+        {allPublications?.map((p, index) => <PubListing key={p.uri} {...p} />)}
+      </div>
+      {/* Trigger element for loading more subscriptions */}
+      <div
+        ref={loadMoreRef}
+        className="absolute bottom-96 left-0 w-full h-px pointer-events-none"
+        aria-hidden="true"
+      />
+      {isValidating && (
+        <div className="text-center text-tertiary py-4">
+          Loading more subscriptions...
+        </div>
+      )}
+    </div>
+  );
+};
+
+export const SubscriptionsEmpty = () => {
+  return (
+    <div className="flex flex-col gap-2 container bg-[rgba(var(--bg-page),.7)] sm:p-4 p-3 justify-between text-center text-tertiary">
+      You haven't subscribed to any publications yet!
+      <Link href={"/discover"}>
+        <ButtonPrimary className="mx-auto place-self-center">
+          <DiscoverSmall /> Discover Publications
+        </ButtonPrimary>
+      </Link>
+    </div>
+  );
+};

app/reader/getReaderFeed.ts

···
+"use server";
+
+import { getIdentityData } from "actions/getIdentityData";
+import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
+import { supabaseServerClient } from "supabase/serverClient";
+import { IdResolver } from "@atproto/identity";
+import type { DidCache, CacheResult, DidDocument } from "@atproto/identity";
+import Client from "ioredis";
+import { AtUri } from "@atproto/api";
+import { Json } from "supabase/database.types";
+import { idResolver } from "./idResolver";
+
+export type Cursor = {
+  timestamp: string;
+  uri: string;
+};
+
+export async function getReaderFeed(
+  cursor?: Cursor | null,
+): Promise<{ posts: Post[]; nextCursor: Cursor | null }> {
+  let auth_res = await getIdentityData();
+  if (!auth_res?.atp_did) return { posts: [], nextCursor: null };
+  let query = supabaseServerClient
+    .from("documents")
+    .select(
+      `*,
+      comments_on_documents(count),
+      document_mentions_in_bsky(count),
+      documents_in_publications!inner(publications!inner(*, publication_subscriptions!inner(*)))`,
+    )
+    .eq(
+      "documents_in_publications.publications.publication_subscriptions.identity",
+      auth_res.atp_did,
+    )
+    .order("indexed_at", { ascending: false })
+    .order("uri", { ascending: false })
+    .limit(25);
+  if (cursor) {
+    query = query.or(
+      `indexed_at.lt.${cursor.timestamp},and(indexed_at.eq.${cursor.timestamp},uri.lt.${cursor.uri})`,
+    );
+  }
+  let { data: feed, error } = await query;
+
+  let posts = await Promise.all(
+    feed?.map(async (post) => {
+      let pub = post.documents_in_publications[0].publications!;
+      let uri = new AtUri(post.uri);
+      let handle = await idResolver.did.resolve(uri.host);
+      let p: Post = {
+        publication: {
+          href: getPublicationURL(pub),
+          pubRecord: pub?.record || null,
+          uri: pub?.uri || "",
+        },
+        author: handle?.alsoKnownAs?.[0]
+          ? `@${handle.alsoKnownAs[0].slice(5)}`
+          : null,
+        documents: {
+          comments_on_documents: post.comments_on_documents,
+          document_mentions_in_bsky: post.document_mentions_in_bsky,
+          data: post.data,
+          uri: post.uri,
+          indexed_at: post.indexed_at,
+        },
+      };
+      return p;
+    }) || [],
+  );
+  const nextCursor =
+    posts.length > 0
+      ? {
+          timestamp: posts[posts.length - 1].documents.indexed_at,
+          uri: posts[posts.length - 1].documents.uri,
+        }
+      : null;
+
+  return {
+    posts,
+    nextCursor,
+  };
+}
+
+export type Post = {
+  author: string | null;
+  publication: {
+    href: string;
+    pubRecord: Json;
+    uri: string;
+  };
+  documents: {
+    data: Json;
+    uri: string;
+    indexed_at: string;
+    comments_on_documents:
+      | {
+          count: number;
+        }[]
+      | undefined;
+    document_mentions_in_bsky:
+      | {
+          count: number;
+        }[]
+      | undefined;
+  };
+};

app/reader/getSubscriptions.ts

···
+"use server";
+
+import { AtpAgent } from "@atproto/api";
+import { ProfileViewDetailed } from "@atproto/api/dist/client/types/app/bsky/actor/defs";
+import { getIdentityData } from "actions/getIdentityData";
+import { Json } from "supabase/database.types";
+import { supabaseServerClient } from "supabase/serverClient";
+import { idResolver } from "./idResolver";
+import { Cursor } from "./getReaderFeed";
+
+export async function getSubscriptions(cursor?: Cursor | null): Promise<{
+  nextCursor: null | Cursor;
+  subscriptions: PublicationSubscription[];
+}> {
+  let auth_res = await getIdentityData();
+  if (!auth_res?.atp_did) return { subscriptions: [], nextCursor: null };
+  let query = supabaseServerClient
+    .from("publication_subscriptions")
+    .select(`*, publications(*, documents_in_publications(*, documents(*)))`)
+    .order(`created_at`, { ascending: false })
+    .order(`uri`, { ascending: false })
+    .order("indexed_at", {
+      ascending: false,
+      referencedTable: "publications.documents_in_publications",
+    })
+    .limit(1, { referencedTable: "publications.documents_in_publications" })
+    .limit(25)
+    .eq("identity", auth_res.atp_did);
+
+  if (cursor) {
+    query = query.or(
+      `created_at.lt.${cursor.timestamp},and(created_at.eq.${cursor.timestamp},uri.lt.${cursor.uri})`,
+    );
+  }
+  let { data: pubs, error } = await query;
+
+  const hydratedSubscriptions: PublicationSubscription[] = await Promise.all(
+    pubs?.map(async (pub) => {
+      let id = await idResolver.did.resolve(pub.publications?.identity_did!);
+      return {
+        ...pub.publications!,
+        authorProfile: id?.alsoKnownAs?.[0]
+          ? { handle: `@${id.alsoKnownAs[0].slice(5)}` }
+          : undefined,
+      };
+    }) || [],
+  );
+
+  const nextCursor =
+    pubs && pubs.length > 0
+      ? {
+          timestamp: pubs[pubs.length - 1].created_at,
+          uri: pubs[pubs.length - 1].uri,
+        }
+      : null;
+
+  return {
+    subscriptions: hydratedSubscriptions,
+    nextCursor,
+  };
+}
+
+export type PublicationSubscription = {
+  authorProfile?: { handle: string };
+  record: Json;
+  uri: string;
+  documents_in_publications: {
+    documents: { data?: Json; indexed_at: string } | null;
+  }[];
+};

app/reader/idResolver.ts

···
+import { IdResolver } from "@atproto/identity";
+import type { DidCache, CacheResult, DidDocument } from "@atproto/identity";
+import Client from "ioredis";
+// Create Redis client for DID caching
+let redisClient: Client | null = null;
+if (process.env.REDIS_URL) {
+  redisClient = new Client(process.env.REDIS_URL);
+}
+
+// Redis-based DID cache implementation
+class RedisDidCache implements DidCache {
+  private staleTTL: number;
+  private maxTTL: number;
+
+  constructor(
+    private client: Client,
+    staleTTL = 60 * 60, // 1 hour
+    maxTTL = 60 * 60 * 24, // 24 hours
+  ) {
+    this.staleTTL = staleTTL;
+    this.maxTTL = maxTTL;
+  }
+
+  async cacheDid(did: string, doc: DidDocument): Promise<void> {
+    const cacheVal = {
+      doc,
+      updatedAt: Date.now(),
+    };
+    await this.client.setex(
+      `did:${did}`,
+      this.maxTTL,
+      JSON.stringify(cacheVal),
+    );
+  }
+
+  async checkCache(did: string): Promise<CacheResult | null> {
+    const cached = await this.client.get(`did:${did}`);
+    if (!cached) return null;
+
+    const { doc, updatedAt } = JSON.parse(cached);
+    const now = Date.now();
+    const age = now - updatedAt;
+
+    return {
+      did,
+      doc,
+      updatedAt,
+      stale: age > this.staleTTL * 1000,
+      expired: age > this.maxTTL * 1000,
+    };
+  }
+
+  async refreshCache(
+    did: string,
+    getDoc: () => Promise<DidDocument | null>,
+  ): Promise<void> {
+    const doc = await getDoc();
+    if (doc) {
+      await this.cacheDid(did, doc);
+    }
+  }
+
+  async clearEntry(did: string): Promise<void> {
+    await this.client.del(`did:${did}`);
+  }
+
+  async clear(): Promise<void> {
+    const keys = await this.client.keys("did:*");
+    if (keys.length > 0) {
+      await this.client.del(...keys);
+    }
+  }
+}
+
+// Create IdResolver with Redis-based DID cache
+export const idResolver = new IdResolver({
+  didCache: redisClient ? new RedisDidCache(redisClient) : undefined,
+});

app/reader/page.tsx

···
+import { cookies } from "next/headers";
+import { Fact, ReplicacheProvider } from "src/replicache";
+import type { Attribute } from "src/replicache/attributes";
+import {
+  ThemeBackgroundProvider,
+  ThemeProvider,
+} from "components/ThemeManager/ThemeProvider";
+import { EntitySetProvider } from "components/EntitySetProvider";
+import { getIdentityData } from "actions/getIdentityData";
+import { supabaseServerClient } from "supabase/serverClient";
+
+import { NotFoundLayout } from "components/PageLayouts/NotFoundLayout";
+import { DashboardLayout } from "components/PageLayouts/DashboardLayout";
+import { ReaderContent, ReaderEmpty } from "./ReaderContent";
+import {
+  SubscriptionsContent,
+  SubscriptionsEmpty,
+} from "./SubscriptionsContent";
+import { getReaderFeed } from "./getReaderFeed";
+import { getSubscriptions } from "./getSubscriptions";
+
+export default async function Reader(props: {}) {
+  let cookieStore = await cookies();
+  let auth_res = await getIdentityData();
+  let identity: string | undefined;
+  let permission_token = auth_res?.home_leaflet;
+  if (!permission_token)
+    return (
+      <DashboardLayout
+        id="reader"
+        cardBorderHidden={false}
+        currentPage="reader"
+        defaultTab="Read"
+        actions={null}
+        tabs={{
+          Read: {
+            controls: null,
+            content: <ReaderEmpty />,
+          },
+          Subscriptions: {
+            controls: null,
+            content: <SubscriptionsEmpty />,
+          },
+        }}
+      />
+    );
+  let [homeLeafletFacts] = await Promise.all([
+    supabaseServerClient.rpc("get_facts", {
+      root: permission_token.root_entity,
+    }),
+  ]);
+  let initialFacts =
+    (homeLeafletFacts.data as unknown as Fact<Attribute>[]) || [];
+  let root_entity = permission_token.root_entity;
+
+  if (!auth_res?.atp_did) return;
+  let posts = await getReaderFeed();
+  let publications = await getSubscriptions();
+  return (
+    <ReplicacheProvider
+      rootEntity={root_entity}
+      token={permission_token}
+      name={root_entity}
+      initialFacts={initialFacts}
+    >
+      <EntitySetProvider
+        set={permission_token.permission_token_rights[0].entity_set}
+      >
+        <ThemeProvider entityID={root_entity}>
+          <ThemeBackgroundProvider entityID={root_entity}>
+            <DashboardLayout
+              id="reader"
+              cardBorderHidden={false}
+              currentPage="reader"
+              defaultTab="Read"
+              actions={null}
+              tabs={{
+                Read: {
+                  controls: null,
+                  content: (
+                    <ReaderContent
+                      root_entity={root_entity}
+                      nextCursor={posts.nextCursor}
+                      posts={posts.posts}
+                    />
+                  ),
+                },
+                Subscriptions: {
+                  controls: null,
+                  content: (
+                    <SubscriptionsContent
+                      publications={publications.subscriptions}
+                      nextCursor={publications.nextCursor}
+                    />
+                  ),
+                },
+              }}
+            />
+          </ThemeBackgroundProvider>
+        </ThemeProvider>
+      </EntitySetProvider>
+    </ReplicacheProvider>
+  );
+}

appview/bumpCursor.js

···
 } else {
   let newCursor = (cursor + 300 * 60 * 60 * 12).toString();
   writeFileSync(cursorFile, (cursor + 300 * 60 * 60 * 12).toString());
-  console.log(`
-  old cursor: ${cursor}
-  new cursor: ${newCursor}
-  `);
 }

components/ActionBar/Navigation.tsx

···
 import { PublicationButtons } from "./Publications";
 import { Popover } from "components/Popover";
 import { MenuSmall } from "components/Icons/MenuSmall";
+import {
+  ReaderReadSmall,
+  ReaderUnreadSmall,
+} from "components/Icons/ReaderSmall";
 
 export type navPages = "home" | "reader" | "pub" | "discover";
 
···
   currentPage: navPages;
   publication?: string;
 }) => {
-  let unreadNotifications = true;
-
   return (
     <div className="flex flex-col gap-4">
       <Sidebar alwaysOpen>
···
   return (
     <>
       <HomeButton current={props.currentPage === "home"} />
-      <ReaderButton current={props.currentPage === "discover"} />
+      <ReaderButton
+        current={props.currentPage === "reader"}
+        subs={identity?.publication_subscriptions?.length !== 0}
+      />
+      <DiscoverButton current={props.currentPage === "discover"} />
+
       <hr className="border-border-light my-1" />
       <PublicationButtons currentPubUri={thisPublication?.uri} />
     </>
···
   );
 };
 
-const ReaderButton = (props: { current?: boolean }) => {
-  // let readerUnreads = true;
-  // let subs = false;
+const ReaderButton = (props: { current?: boolean; subs: boolean }) => {
+  let readerUnreads = false;
 
-  // if (subs)
-  //   return (
-  //     <ActionButton
-  //       nav
-  //       icon={readerUnreads ? <ReaderUnreadSmall /> : <ReaderReadSmall />}
-  //       label="Reader"
-  //       className={`
-  //         ${readerUnreads ? "text-accent-contrast! border-accent-contrast" : props.current ? "bg-border-light! border-border" : ""}
-  //       `}
-  //     />
-  //   );
+  if (!props.subs) return;
+  return (
+    <Link href={"/reader"} className="hover:no-underline!">
+      <ActionButton
+        nav
+        icon={readerUnreads ? <ReaderUnreadSmall /> : <ReaderReadSmall />}
+        label="Reader"
+        className={`
+          ${readerUnreads && "text-accent-contrast!"}
+          ${props.current && "border-accent-contrast!"}
+        `}
+      />
+    </Link>
+  );
+};
+
+const DiscoverButton = (props: { current?: boolean }) => {
   return (
     <Link href={"/discover"} className="hover:no-underline!">
       <ActionButton
         nav
         icon={<DiscoverSmall />}
         label="Discover"
-        subtext={"Explore publications!"}
+        subtext=""
         className={props.current ? "bg-bg-page! border-border-light!" : ""}
       />
     </Link>

components/ActionBar/Publications.tsx

···
       {identity.publications?.map((d) => {
         // console.log("thisURI : " + d.uri);
         // console.log("currentURI : " + props.currentPubUri);
-        console.log(d.uri === props.currentPubUri);
 
         return (
           <PublicationOption
···
         );
       })}
       <Link
-        href={"./lish/createPub"}
+        href={"/lish/createPub"}
         className="pubListCreateNew  text-accent-contrast text-sm place-self-end hover:text-accent-contrast"
       >
         New
···
   return (
     <SpeedyLink href={`lish/createPub`} className=" hover:no-underline!">
       <ActionButton
-        label="Publish on ATP"
+        label="Publish"
         icon={<PublishSmall />}
         nav
-        subtext="Start a blog in the Atmosphere"
+        subtext="Blog on ATProto!"
       />
     </SpeedyLink>
   );
···
 export const PubIcon = (props: {
   record: PubLeafletPublication.Record;
   uri: string;
+  small?: boolean;
+  large?: boolean;
+  className?: string;
 }) => {
   if (!props.record) return;
 
+  let iconSizeClassName = `${props.small ? "w-4 h-4" : props.large ? "w-12 h-12" : "w-6 h-6"} rounded-full`;
+
   return props.record.icon ? (
     <div
       style={{
···
         backgroundSize: "cover",
         backgroundImage: `url(/api/atproto_images?did=${new AtUri(props.uri).host}&cid=${(props.record.icon?.ref as unknown as { $link: string })["$link"]})`,
       }}
-      className="w-6 h-6 rounded-full"
+      className={`${iconSizeClassName} ${props.className}`}
     />
   ) : (
-    <div className="w-6 h-6 rounded-full bg-accent-1 relative">
-      <div className="font-bold text-sm absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2 text-accent-2">
+    <div className={`${iconSizeClassName} bg-accent-1 relative`}>
+      <div
+        className={`${props.small ? "text-xs" : props.large ? "text-2xl" : "text-sm"} font-bold  absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2 text-accent-2`}
+      >
         {props.record?.name.slice(0, 1)}
       </div>
     </div>

components/Blocks/Block.tsx

···
 import { CodeBlock } from "./CodeBlock";
 import { HorizontalRule } from "./HorizontalRule";
 import { deepEquals } from "src/utils/deepEquals";
+import { isTextBlock } from "src/utils/isTextBlock";
 
 export type Block = {
   factID: string;
···
 
   let mouseHandlers = useBlockMouseHandlers(props);
 
-  // focus block on longpress, shouldnt the type be based on the block type (?)
   let { isLongPress, handlers } = useLongPress(() => {
+    if (isTextBlock[props.type]) return;
     if (isLongPress.current) {
       focusBlock(
         { type: props.type, value: props.entityID, parent: props.parent },

components/Blocks/PageLinkBlock.tsx

···
   return (
     <div
       ref={previewRef}
+      inert
       className={`pageLinkBlockPreview w-[120px] overflow-clip  mx-3 mt-3 -mb-2  border rounded-md shrink-0 border-border-light flex flex-col gap-0.5 rotate-[4deg] origin-center ${cardBorderHidden ? "" : "bg-bg-page"}`}
     >
       <div

components/Blocks/TextBlock/RenderYJSFragment.tsx

···
               node.toArray().map((node, index) => {
                 if (node.constructor === XmlText) {
                   let deltas = node.toDelta() as Delta[];
-                  if (deltas.length === 0) return <br />;
+                  if (deltas.length === 0) return <br key={index} />;
                   return (
                     <Fragment key={index}>
                       {deltas.map((d, index) => {

components/Blocks/TextBlock/index.tsx

···
             let oldEditorState = this.state;
             let newState = this.state.apply(tr);
             let addToHistory = tr.getMeta("addToHistory");
+            let isBulkOp = tr.getMeta("bulkOp");
             let docHasChanges = tr.steps.length !== 0 || tr.docChanged;
             if (addToHistory !== false && docHasChanges) {
               if (actionTimeout.current) {
                 window.clearTimeout(actionTimeout.current);
               } else {
-                rep.undoManager.startGroup();
+                if (!isBulkOp) rep.undoManager.startGroup();
               }
 
-              actionTimeout.current = window.setTimeout(() => {
-                rep.undoManager.endGroup();
-                actionTimeout.current = null;
-              }, 200);
+              if (!isBulkOp)
+                actionTimeout.current = window.setTimeout(() => {
+                  rep.undoManager.endGroup();
+                  actionTimeout.current = null;
+                }, 200);
               rep.undoManager.add({
                 redo: () => {
                   useEditorStates.setState((oldState) => {
                     let view = oldState.editorStates[props.entityID]?.view;
-                    if (!view?.hasFocus()) view?.focus();
+                    if (!view?.hasFocus() && !isBulkOp) view?.focus();
                     return {
                       editorStates: {
                         ...oldState.editorStates,
···
                 undo: () => {
                   useEditorStates.setState((oldState) => {
                     let view = oldState.editorStates[props.entityID]?.view;
-                    if (!view?.hasFocus()) view?.focus();
+                    if (!view?.hasFocus() && !isBulkOp) view?.focus();
                     return {
                       editorStates: {
                         ...oldState.editorStates,

components/Blocks/TextBlock/useHandlePaste.ts

···
     let oldEntityID = child.getAttribute("data-entityid") as string;
     let factsData = child.getAttribute("data-facts");
     if (factsData) {
-      let facts = JSON.parse(atob(factsData)) as Fact<any>[];
+      let facts = JSON.parse(factsData) as Fact<any>[];
 
       let oldEntityIDToNewID = {} as { [k: string]: string };
       let oldEntities = facts.reduce((acc, f) => {

components/Icons/ExternalLinkTiny.tsx

···
+import { Props } from "./Props";
+
+export const ExternalLinkTiny = (props: Props) => {
+  return (
+    <svg
+      width="16"
+      height="16"
+      viewBox="0 0 16 16"
+      fill="none"
+      xmlns="http://www.w3.org/2000/svg"
+      {...props}
+    >
+      <path
+        d="M4.94336 2.26074C5.22793 2.3192 5.44238 2.57118 5.44238 2.87305C5.44227 3.17482 5.22788 3.42693 4.94336 3.48535L4.81738 3.49805H4.37305C3.61366 3.49805 2.99805 4.11366 2.99805 4.87305V11.627C2.99818 12.3862 3.61374 13.002 4.37305 13.002H11.127C11.8863 13.002 12.5018 12.3862 12.502 11.627V11.1055C12.5021 10.7605 12.7819 10.4805 13.127 10.4805C13.472 10.4805 13.7518 10.7605 13.752 11.1055V11.627C13.7518 13.0766 12.5766 14.252 11.127 14.252H4.37305C2.92338 14.252 1.74818 13.0766 1.74805 11.627V4.87305C1.74805 3.4233 2.9233 2.24805 4.37305 2.24805H4.81738L4.94336 2.26074ZM13.127 1.74805C13.7482 1.74809 14.252 2.25176 14.252 2.87305V8.04199C14.2518 8.66317 13.7482 9.16694 13.127 9.16699C12.5058 9.16693 12.0021 8.66316 12.002 8.04199V5.58887L7.25488 10.3359L7.16895 10.4141C6.7271 10.774 6.07483 10.7476 5.66309 10.3359C5.22426 9.89664 5.22413 9.18433 5.66309 8.74512L10.4102 3.99805H7.95703C7.33606 3.99774 6.83216 3.49406 6.83203 2.87305C6.83203 2.25192 7.33597 1.74836 7.95703 1.74805H13.127Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+};

components/PageHeader.tsx

···
 
 export const Header = (props: {
   children: React.ReactNode;
-  hasBackgroundImage: boolean;
+  cardBorderHidden: boolean;
 }) => {
   let [scrollPos, setScrollPos] = useState(0);
 
···
     }
   }, []);
 
-  let headerBGColor = props.hasBackgroundImage
-    ? "var(--bg-page)"
-    : "var(--bg-leaflet)";
+  let headerBGColor = props.cardBorderHidden
+    ? "var(--bg-leaflet)"
+    : "var(--bg-page)";
 
   return (
     <div
···
           style={
             scrollPos < 20
               ? {
-                  backgroundColor: `rgba(${headerBGColor}, ${scrollPos / 60 + 0.75})`,
-                  paddingLeft: props.hasBackgroundImage
-                    ? "8px"
-                    : `calc(${scrollPos / 20}*8px)`,
-                  paddingRight: props.hasBackgroundImage
+                  backgroundColor: props.cardBorderHidden
+                    ? `rgba(${headerBGColor}, ${scrollPos / 60 + 0.75})`
+                    : `rgba(${headerBGColor}, ${scrollPos / 20})`,
+                  paddingLeft: props.cardBorderHidden
+                    ? "4px"
+                    : `calc(${scrollPos / 20}*4px)`,
+                  paddingRight: props.cardBorderHidden
                     ? "8px"
                     : `calc(${scrollPos / 20}*8px)`,
                 }
               : {
                   backgroundColor: `rgb(${headerBGColor})`,
-                  paddingLeft: "8px",
+                  paddingLeft: "4px",
                   paddingRight: "8px",
                 }
           }

components/PageLayouts/DashboardLayout.tsx

···
 "use client";
-import { useState, createContext, useContext } from "react";
+import { useState, createContext, useContext, useEffect } from "react";
+import { useSearchParams } from "next/navigation";
 import { Header } from "../PageHeader";
 import { Footer } from "components/ActionBar/Footer";
 import { Sidebar } from "components/ActionBar/Sidebar";
···
 import { SearchTiny } from "components/Icons/SearchTiny";
 import { InterfaceState, useIdentityData } from "components/IdentityProvider";
 import { updateIdentityInterfaceState } from "actions/updateIdentityInterfaceState";
+import Link from "next/link";
+import { ExternalLinkTiny } from "components/Icons/ExternalLinkTiny";
+import { usePreserveScroll } from "src/hooks/usePreserveScroll";
 
 export type DashboardState = {
   display?: "grid" | "list";
···
 
 export function DashboardLayout<
   T extends {
-    [name: string]: { content: React.ReactNode; controls: React.ReactNode };
+    [name: string]: {
+      content: React.ReactNode;
+      controls: React.ReactNode;
+    };
   },
 >(props: {
   id: string;
-  hasBackgroundImage: boolean;
+  cardBorderHidden: boolean;
   tabs: T;
   defaultTab: keyof T;
   currentPage: navPages;
   publication?: string;
   actions: React.ReactNode;
 }) {
-  let [tab, setTab] = useState(props.defaultTab);
+  const searchParams = useSearchParams();
+  const tabParam = searchParams.get("tab");
+
+  // Initialize tab from search param if valid, otherwise use default
+  const initialTab = tabParam && props.tabs[tabParam] ? tabParam : props.defaultTab;
+  let [tab, setTab] = useState<keyof T>(initialTab);
+
+  // Custom setter that updates both state and URL
+  const setTabWithUrl = (newTab: keyof T) => {
+    setTab(newTab);
+    const params = new URLSearchParams(searchParams.toString());
+    params.set("tab", newTab as string);
+    const newUrl = `${window.location.pathname}?${params.toString()}`;
+    window.history.replaceState(null, "", newUrl);
+  };
+
   let { content, controls } = props.tabs[tab];
+  let { ref } = usePreserveScroll<HTMLDivElement>(
+    `dashboard-${props.id}-${tab as string}`,
+  );
 
   let [headerState, setHeaderState] = useState<"default" | "controls">(
     "default",
···
         </MediaContents>
         <div
           className={`w-full h-full flex flex-col gap-2 relative overflow-y-scroll pt-3 pb-12 px-3 sm:pt-8 sm:pb-12 sm:pl-6 sm:pr-4 `}
+          ref={ref}
           id="home-content"
         >
           {Object.keys(props.tabs).length <= 1 && !controls ? null : (
             <>
-              <Header hasBackgroundImage={props.hasBackgroundImage}>
+              <Header cardBorderHidden={props.cardBorderHidden}>
                 {headerState === "default" ? (
                   <>
                     {Object.keys(props.tabs).length > 1 && (
                       <div className="pubDashTabs flex flex-row gap-1">
-                        {Object.keys(props.tabs).map((t) => (
-                          <Tab
-                            key={t}
-                            name={t}
-                            selected={t === tab}
-                            onSelect={() => setTab(t)}
-                          />
-                        ))}
+                        {Object.keys(props.tabs).map((t) => {
+                          return (
+                            <Tab
+                              key={t}
+                              name={t}
+                              selected={t === tab}
+                              onSelect={() => setTabWithUrl(t)}
+                            />
+                          );
+                        })}
                       </div>
                     )}
                     {props.publication && (
···
   );
 };
 
-function Tab(props: { name: string; selected: boolean; onSelect: () => void }) {
+function Tab(props: {
+  name: string;
+  selected: boolean;
+  onSelect: () => void;
+  href?: string;
+}) {
   return (
     <div
-      className={`pubTabs px-1 py-0 rounded-md hover:cursor-pointer ${props.selected ? "text-accent-2 bg-accent-1 font-bold -mb-px" : "text-tertiary"}`}
+      className={`pubTabs px-1 py-0 flex gap-1 items-center rounded-md hover:cursor-pointer ${props.selected ? "text-accent-2 bg-accent-1 font-bold -mb-px" : "text-tertiary"}`}
       onClick={() => props.onSelect()}
     >
       {props.name}
+      {props.href && <ExternalLinkTiny />}
     </div>
   );
 }

components/Pages/PublicationMetadata.tsx

···
 import Link from "next/link";
 import { useLeafletPublicationData } from "components/PageSWRDataProvider";
-import { AsyncValueInput, Input } from "components/Input";
-import { useEffect, useState } from "react";
-import { useDebouncedEffect } from "src/hooks/useDebouncedEffect";
-import { updateLeafletDraftMetadata } from "actions/publications/updateLeafletDraftMetadata";
+import { useRef } from "react";
 import { useReplicache } from "src/replicache";
-import {
-  AsyncValueAutosizeTextarea,
-  AutosizeTextarea,
-} from "components/utils/AutosizeTextarea";
+import { AsyncValueAutosizeTextarea } from "components/utils/AutosizeTextarea";
 import { Separator } from "components/Layout";
 import { AtUri } from "@atproto/syntax";
 import { PubLeafletDocument } from "lexicons/api";
···
   let description = useSubscribe(rep, (tx) =>
     tx.get<string>("publication_description"),
   );
-  let { permissions } = useEntitySetContext();
-
   let record = pub?.documents?.data as PubLeafletDocument.Record | null;
   let publishedAt = record?.publishedAt;
 
···
           Editor
         </div>
       </div>
-      <AsyncValueAutosizeTextarea
-        disabled={!permissions.write}
+      <TextField
         className="text-xl font-bold outline-hidden bg-transparent"
         value={title}
-        onChange={async (e) => {
+        onChange={async (newTitle) => {
           await rep?.mutate.updatePublicationDraft({
-            title: e.currentTarget.value,
+            title: newTitle,
             description,
           });
         }}
         placeholder="Untitled"
       />
-      <AsyncValueAutosizeTextarea
-        disabled={!permissions.write}
+      <TextField
         placeholder="add an optional description..."
         className="italic text-secondary outline-hidden bg-transparent"
         value={description}
-        onChange={async (e) => {
+        onChange={async (newDescription) => {
           await rep?.mutate.updatePublicationDraft({
-            description: e.currentTarget.value,
             title,
+            description: newDescription,
           });
         }}
       />
···
         <p className="text-sm text-tertiary pt-2">Draft</p>
       )}
     </div>
+  );
+};
+
+export const TextField = ({
+  value,
+  onChange,
+  className,
+  placeholder,
+}: {
+  value: string;
+  onChange: (v: string) => Promise<void>;
+  className: string;
+  placeholder: string;
+}) => {
+  let { undoManager } = useReplicache();
+  let actionTimeout = useRef<number | null>(null);
+  let { permissions } = useEntitySetContext();
+  let previousSelection = useRef<null | { start: number; end: number }>(null);
+  let ref = useRef<HTMLTextAreaElement | null>(null);
+  return (
+    <AsyncValueAutosizeTextarea
+      ref={ref}
+      disabled={!permissions.write}
+      onSelect={(e) => {
+        let start = e.currentTarget.selectionStart,
+          end = e.currentTarget.selectionEnd;
+        previousSelection.current = { start, end };
+      }}
+      className={className}
+      value={value}
+      onBlur={async () => {
+        if (actionTimeout.current) {
+          undoManager.endGroup();
+          window.clearTimeout(actionTimeout.current);
+          actionTimeout.current = null;
+        }
+      }}
+      onChange={async (e) => {
+        let newValue = e.currentTarget.value;
+        let oldValue = value;
+        let start = e.currentTarget.selectionStart,
+          end = e.currentTarget.selectionEnd;
+        await onChange(e.currentTarget.value);
+
+        if (actionTimeout.current) {
+          window.clearTimeout(actionTimeout.current);
+        } else {
+          undoManager.startGroup();
+        }
+
+        actionTimeout.current = window.setTimeout(() => {
+          undoManager.endGroup();
+          actionTimeout.current = null;
+        }, 200);
+        let previousStart = previousSelection.current?.start || null,
+          previousEnd = previousSelection.current?.end || null;
+        undoManager.add({
+          redo: async () => {
+            await onChange(newValue);
+            ref.current?.setSelectionRange(start, end);
+            ref.current?.focus();
+          },
+          undo: async () => {
+            await onChange(oldValue);
+            ref.current?.setSelectionRange(previousStart, previousEnd);
+            ref.current?.focus();
+          },
+        });
+      }}
+      placeholder={placeholder}
+    />
   );
 };
 

components/SelectionManager.tsx

···
 import { getBlocksWithType } from "src/hooks/queries/useBlocks";
 import { v7 } from "uuid";
 import { indent, outdent, outdentFull } from "src/utils/list-operations";
-import { addShortcut } from "src/shortcuts";
+import { addShortcut, Shortcut } from "src/shortcuts";
 import { htmlToMarkdown } from "src/htmlMarkdownParsers";
 import { elementId } from "src/utils/elementId";
 import { scrollIntoViewIfNeeded } from "src/utils/scrollIntoViewIfNeeded";
···
 import { useIsMobile } from "src/hooks/isMobile";
 import { deleteBlock } from "./Blocks/DeleteBlock";
 import { Replicache } from "replicache";
+import { schema } from "./Blocks/TextBlock/schema";
+import { TextSelection } from "prosemirror-state";
+import { MarkType } from "prosemirror-model";
 export const useSelectingMouse = create(() => ({
   start: null as null | string,
 }));
···
   let isMobile = useIsMobile();
   useEffect(() => {
     if (!entity_set.permissions.write || !rep) return;
-    if (isMobile) return;
     const getSortedSelectionBound = getSortedSelection.bind(null, rep);
-    let removeListener = addShortcut(
-      [
-        {
-          metaKey: true,
-          key: "ArrowUp",
-          handler: async () => {
-            let [firstBlock] =
-              (await rep?.query((tx) =>
-                getBlocksWithType(
-                  tx,
-                  useUIState.getState().selectedBlocks[0].parent,
-                ),
-              )) || [];
-            if (firstBlock) focusBlock(firstBlock, { type: "start" });
-          },
+    let shortcuts: Shortcut[] = [
+      {
+        metaKey: true,
+        key: "ArrowUp",
+        handler: async () => {
+          let [firstBlock] =
+            (await rep?.query((tx) =>
+              getBlocksWithType(
+                tx,
+                useUIState.getState().selectedBlocks[0].parent,
+              ),
+            )) || [];
+          if (firstBlock) focusBlock(firstBlock, { type: "start" });
+        },
+      },
+      {
+        metaKey: true,
+        key: "ArrowDown",
+        handler: async () => {
+          let blocks =
+            (await rep?.query((tx) =>
+              getBlocksWithType(
+                tx,
+                useUIState.getState().selectedBlocks[0].parent,
+              ),
+            )) || [];
+          let folded = useUIState.getState().foldedBlocks;
+          blocks = blocks.filter(
+            (f) =>
+              !f.listData ||
+              !f.listData.path.find(
+                (path) =>
+                  folded.includes(path.entity) && f.value !== path.entity,
+              ),
+          );
+          let lastBlock = blocks[blocks.length - 1];
+          if (lastBlock) focusBlock(lastBlock, { type: "end" });
+        },
+      },
+      {
+        metaKey: true,
+        altKey: true,
+        key: ["l", "¬"],
+        handler: async () => {
+          let [sortedBlocks, siblings] = await getSortedSelectionBound();
+          for (let block of sortedBlocks) {
+            if (!block.listData) {
+              await rep?.mutate.assertFact({
+                entity: block.value,
+                attribute: "block/is-list",
+                data: { type: "boolean", value: true },
+              });
+            } else {
+              outdentFull(block, rep);
+            }
+          }
         },
+      },
+      {
+        metaKey: true,
+        shift: true,
+        key: ["ArrowDown", "J"],
+        handler: async () => {
+          let [sortedBlocks, siblings] = await getSortedSelectionBound();
+          let block = sortedBlocks[0];
+          let nextBlock = siblings
+            .slice(siblings.findIndex((s) => s.value === block.value) + 1)
+            .find(
+              (f) =>
+                f.listData &&
+                block.listData &&
+                !f.listData.path.find((f) => f.entity === block.value),
+            );
+          if (
+            nextBlock?.listData &&
+            block.listData &&
+            nextBlock.listData.depth === block.listData.depth - 1
+          ) {
+            if (useUIState.getState().foldedBlocks.includes(nextBlock.value))
+              useUIState.getState().toggleFold(nextBlock.value);
+            await rep?.mutate.moveBlock({
+              block: block.value,
+              oldParent: block.listData?.parent,
+              newParent: nextBlock.value,
+              position: { type: "first" },
+            });
+          } else {
+            await rep?.mutate.moveBlockDown({
+              entityID: block.value,
+              parent: block.listData?.parent || block.parent,
+            });
+          }
+        },
+      },
+      {
+        metaKey: true,
+        shift: true,
+        key: ["ArrowUp", "K"],
+        handler: async () => {
+          let [sortedBlocks, siblings] = await getSortedSelectionBound();
+          let block = sortedBlocks[0];
+          let previousBlock =
+            siblings?.[siblings.findIndex((s) => s.value === block.value) - 1];
+          if (previousBlock.value === block.listData?.parent) {
+            previousBlock =
+              siblings?.[
+                siblings.findIndex((s) => s.value === block.value) - 2
+              ];
+          }
+
+          if (
+            previousBlock?.listData &&
+            block.listData &&
+            block.listData.depth > 1 &&
+            !previousBlock.listData.path.find(
+              (f) => f.entity === block.listData?.parent,
+            )
+          ) {
+            let depth = block.listData.depth;
+            let newParent = previousBlock.listData.path.find(
+              (f) => f.depth === depth - 1,
+            );
+            if (!newParent) return;
+            if (useUIState.getState().foldedBlocks.includes(newParent.entity))
+              useUIState.getState().toggleFold(newParent.entity);
+            rep?.mutate.moveBlock({
+              block: block.value,
+              oldParent: block.listData?.parent,
+              newParent: newParent.entity,
+              position: { type: "end" },
+            });
+          } else {
+            rep?.mutate.moveBlockUp({
+              entityID: block.value,
+              parent: block.listData?.parent || block.parent,
+            });
+          }
+        },
+      },
+
+      {
+        metaKey: true,
+        shift: true,
+        key: "Enter",
+        handler: async () => {
+          let [sortedBlocks, siblings] = await getSortedSelectionBound();
+          if (!sortedBlocks[0].listData) return;
+          useUIState.getState().toggleFold(sortedBlocks[0].value);
+        },
+      },
+    ];
+    if (moreThanOneSelected)
+      shortcuts = shortcuts.concat([
         {
           metaKey: true,
-          key: "ArrowDown",
+          key: "u",
           handler: async () => {
-            let blocks =
-              (await rep?.query((tx) =>
-                getBlocksWithType(
-                  tx,
-                  useUIState.getState().selectedBlocks[0].parent,
-                ),
-              )) || [];
-            let folded = useUIState.getState().foldedBlocks;
-            blocks = blocks.filter(
-              (f) =>
-                !f.listData ||
-                !f.listData.path.find(
-                  (path) =>
-                    folded.includes(path.entity) && f.value !== path.entity,
-                ),
+            let [sortedBlocks] = await getSortedSelectionBound();
+            toggleMarkInBlocks(
+              sortedBlocks.filter((b) => b.type === "text").map((b) => b.value),
+              schema.marks.underline,
             );
-            let lastBlock = blocks[blocks.length - 1];
-            if (lastBlock) focusBlock(lastBlock, { type: "end" });
           },
         },
         {
           metaKey: true,
-          altKey: true,
-          key: ["l", "¬"],
+          key: "i",
           handler: async () => {
-            let [sortedBlocks, siblings] = await getSortedSelectionBound();
-            for (let block of sortedBlocks) {
-              if (!block.listData) {
-                await rep?.mutate.assertFact({
-                  entity: block.value,
-                  attribute: "block/is-list",
-                  data: { type: "boolean", value: true },
-                });
-              } else {
-                outdentFull(block, rep);
-              }
-            }
+            let [sortedBlocks] = await getSortedSelectionBound();
+            toggleMarkInBlocks(
+              sortedBlocks.filter((b) => b.type === "text").map((b) => b.value),
+              schema.marks.em,
+            );
           },
         },
         {
           metaKey: true,
-          shift: true,
-          key: ["ArrowDown", "J"],
+          key: "b",
           handler: async () => {
-            let [sortedBlocks, siblings] = await getSortedSelectionBound();
-            let block = sortedBlocks[0];
-            let nextBlock = siblings
-              .slice(siblings.findIndex((s) => s.value === block.value) + 1)
-              .find(
-                (f) =>
-                  f.listData &&
-                  block.listData &&
-                  !f.listData.path.find((f) => f.entity === block.value),
-              );
-            if (
-              nextBlock?.listData &&
-              block.listData &&
-              nextBlock.listData.depth === block.listData.depth - 1
-            ) {
-              if (useUIState.getState().foldedBlocks.includes(nextBlock.value))
-                useUIState.getState().toggleFold(nextBlock.value);
-              rep?.mutate.moveBlock({
-                block: block.value,
-                oldParent: block.listData?.parent,
-                newParent: nextBlock.value,
-                position: { type: "first" },
-              });
-            } else {
-              rep?.mutate.moveBlockDown({
-                entityID: block.value,
-                parent: block.listData?.parent || block.parent,
-              });
-            }
+            let [sortedBlocks] = await getSortedSelectionBound();
+            toggleMarkInBlocks(
+              sortedBlocks.filter((b) => b.type === "text").map((b) => b.value),
+              schema.marks.strong,
+            );
           },
         },
         {
-          metaKey: true,
-          shift: true,
-          key: ["ArrowUp", "K"],
+          metaAndCtrl: true,
+          key: "h",
           handler: async () => {
-            let [sortedBlocks, siblings] = await getSortedSelectionBound();
-            let block = sortedBlocks[0];
-            let previousBlock =
-              siblings?.[
-                siblings.findIndex((s) => s.value === block.value) - 1
-              ];
-            if (previousBlock.value === block.listData?.parent) {
-              previousBlock =
-                siblings?.[
-                  siblings.findIndex((s) => s.value === block.value) - 2
-                ];
-            }
-
-            if (
-              previousBlock?.listData &&
-              block.listData &&
-              block.listData.depth > 1 &&
-              !previousBlock.listData.path.find(
-                (f) => f.entity === block.listData?.parent,
-              )
-            ) {
-              let depth = block.listData.depth;
-              let newParent = previousBlock.listData.path.find(
-                (f) => f.depth === depth - 1,
-              );
-              if (!newParent) return;
-              if (useUIState.getState().foldedBlocks.includes(newParent.entity))
-                useUIState.getState().toggleFold(newParent.entity);
-              rep?.mutate.moveBlock({
-                block: block.value,
-                oldParent: block.listData?.parent,
-                newParent: newParent.entity,
-                position: { type: "end" },
-              });
-            } else {
-              rep?.mutate.moveBlockUp({
-                entityID: block.value,
-                parent: block.listData?.parent || block.parent,
-              });
-            }
+            let [sortedBlocks] = await getSortedSelectionBound();
+            toggleMarkInBlocks(
+              sortedBlocks.filter((b) => b.type === "text").map((b) => b.value),
+              schema.marks.highlight,
+              {
+                color: useUIState.getState().lastUsedHighlight,
+              },
+            );
           },
         },
         {
-          metaKey: true,
-          shift: true,
-          key: "Enter",
+          metaAndCtrl: true,
+          key: "x",
           handler: async () => {
-            let [sortedBlocks, siblings] = await getSortedSelectionBound();
-            if (!sortedBlocks[0].listData) return;
-            useUIState.getState().toggleFold(sortedBlocks[0].value);
+            let [sortedBlocks] = await getSortedSelectionBound();
+            toggleMarkInBlocks(
+              sortedBlocks.filter((b) => b.type === "text").map((b) => b.value),
+              schema.marks.strikethrough,
+            );
           },
         },
-      ].map((shortcut) => ({
+      ]);
+    let removeListener = addShortcut(
+      shortcuts.map((shortcut) => ({
         ...shortcut,
         handler: () => undoManager.withUndoGroup(() => shortcut.handler()),
       })),
···
         }
         if ((e.key === "c" || e.key === "x") && (e.metaKey || e.ctrlKey)) {
           if (!rep) return;
+          if (e.shiftKey || (e.metaKey && e.ctrlKey)) return;
           let [, , selectionWithFoldedChildren] =
             await getSortedSelectionBound();
           if (!selectionWithFoldedChildren) return;
···
       removeListener();
       window.removeEventListener("keydown", listener);
     };
-  }, [moreThanOneSelected, rep, entity_set.permissions.write, isMobile]);
+  }, [moreThanOneSelected, rep, entity_set.permissions.write]);
 
   let [mouseDown, setMouseDown] = useState(false);
   let initialContentEditableParent = useRef<null | Node>(null);
···
     sortedBlocksWithChildren,
   ];
 };
+
+function toggleMarkInBlocks(blocks: string[], mark: MarkType, attrs?: any) {
+  let everyBlockHasMark = blocks.reduce((acc, block) => {
+    let editor = useEditorStates.getState().editorStates[block];
+    if (!editor) return acc;
+    let { view } = editor;
+    let from = 0;
+    let to = view.state.doc.content.size;
+    let hasMarkInRange = view.state.doc.rangeHasMark(from, to, mark);
+    return acc && hasMarkInRange;
+  }, true);
+  for (let block of blocks) {
+    let editor = useEditorStates.getState().editorStates[block];
+    if (!editor) return;
+    let { view } = editor;
+    let tr = view.state.tr;
+
+    let from = 0;
+    let to = view.state.doc.content.size;
+
+    tr.setMeta("bulkOp", true);
+    if (everyBlockHasMark) {
+      tr.removeMark(from, to, mark);
+    } else {
+      tr.addMark(from, to, mark.create(attrs));
+    }
+
+    view.dispatch(tr);
+  }
+}

components/ThemeManager/PubPickers/PubBackgroundPickers.tsx

···
                     if (file) {
                       const reader = new FileReader();
                       reader.onload = (e) => {
-                        console.log("loaded!", props.bgImage);
                         props.setBgImage({
                           src: e.target?.result as string,
                           file,

components/ThemeManager/PubThemeSetter.tsx

···
         onSubmit={async (e) => {
           e.preventDefault();
           if (!pub) return;
-          console.log(image);
           setLoading(true);
           let result = await updatePublicationTheme({
             uri: pub.uri,

components/ThemeManager/ThemeProvider.tsx

···
     if (!el) return;
     setCSSVariableToColor(el, "--bg-leaflet", bgLeaflet);
     setCSSVariableToColor(el, "--bg-page", bgPage);
+    document.body.style.backgroundColor = `rgb(${colorToString(bgLeaflet, "rgb")})`;
     document
       .querySelector('meta[name="theme-color"]')
       ?.setAttribute("content", `rgb(${colorToString(bgLeaflet, "rgb")})`);

components/utils/AutosizeTextarea.tsx

···
   let { noWrap, ...rest } = props;
   useImperativeHandle(ref, () => textarea.current as HTMLTextAreaElement);
 
-  console.log({ noWrap });
   return (
     <div
       className={`${styles["grow-wrap"]} ${props.className} ${noWrap ? styles["no-wrap"] : ""}`}

drizzle/relations.ts

···
 import { relations } from "drizzle-orm/relations";
-import { identities, bsky_profiles, publications, documents, comments_on_documents, entities, facts, entity_sets, permission_tokens, email_subscriptions_to_entity, email_auth_tokens, custom_domains, phone_rsvps_to_entity, custom_domain_routes, poll_votes_on_entity, subscribers_to_publications, document_mentions_in_bsky, bsky_posts, permission_token_on_homepage, documents_in_publications, publication_domains, publication_subscriptions, leaflets_in_publications, permission_token_rights } from "./schema";
+import { identities, publications, documents, comments_on_documents, bsky_profiles, entity_sets, entities, facts, email_auth_tokens, poll_votes_on_entity, permission_tokens, phone_rsvps_to_entity, custom_domains, custom_domain_routes, email_subscriptions_to_entity, bsky_follows, subscribers_to_publications, permission_token_on_homepage, documents_in_publications, document_mentions_in_bsky, bsky_posts, publication_domains, leaflets_in_publications, publication_subscriptions, permission_token_rights } from "./schema";
 
-export const bsky_profilesRelations = relations(bsky_profiles, ({one, many}) => ({
+export const publicationsRelations = relations(publications, ({one, many}) => ({
 	identity: one(identities, {
-		fields: [bsky_profiles.did],
+		fields: [publications.identity_did],
 		references: [identities.atp_did]
 	}),
-	comments_on_documents: many(comments_on_documents),
+	subscribers_to_publications: many(subscribers_to_publications),
+	documents_in_publications: many(documents_in_publications),
+	publication_domains: many(publication_domains),
+	leaflets_in_publications: many(leaflets_in_publications),
+	publication_subscriptions: many(publication_subscriptions),
 }));
 
 export const identitiesRelations = relations(identities, ({one, many}) => ({
-	bsky_profiles: many(bsky_profiles),
 	publications: many(publications),
+	email_auth_tokens: many(email_auth_tokens),
+	bsky_profiles: many(bsky_profiles),
 	permission_token: one(permission_tokens, {
 		fields: [identities.home_page],
 		references: [permission_tokens.id]
 	}),
-	email_auth_tokens: many(email_auth_tokens),
 	custom_domains_identity: many(custom_domains, {
 		relationName: "custom_domains_identity_identities_email"
 	}),
 	custom_domains_identity_id: many(custom_domains, {
 		relationName: "custom_domains_identity_id_identities_id"
 	}),
+	bsky_follows_follows: many(bsky_follows, {
+		relationName: "bsky_follows_follows_identities_atp_did"
+	}),
+	bsky_follows_identity: many(bsky_follows, {
+		relationName: "bsky_follows_identity_identities_atp_did"
+	}),
 	subscribers_to_publications: many(subscribers_to_publications),
 	permission_token_on_homepages: many(permission_token_on_homepage),
 	publication_domains: many(publication_domains),
 	publication_subscriptions: many(publication_subscriptions),
 }));
 
-export const publicationsRelations = relations(publications, ({one, many}) => ({
-	identity: one(identities, {
-		fields: [publications.identity_did],
-		references: [identities.atp_did]
-	}),
-	subscribers_to_publications: many(subscribers_to_publications),
-	documents_in_publications: many(documents_in_publications),
-	publication_domains: many(publication_domains),
-	publication_subscriptions: many(publication_subscriptions),
-	leaflets_in_publications: many(leaflets_in_publications),
-}));
-
 export const comments_on_documentsRelations = relations(comments_on_documents, ({one}) => ({
 	document: one(documents, {
 		fields: [comments_on_documents.document],
···
 
 export const documentsRelations = relations(documents, ({many}) => ({
 	comments_on_documents: many(comments_on_documents),
-	document_mentions_in_bskies: many(document_mentions_in_bsky),
 	documents_in_publications: many(documents_in_publications),
+	document_mentions_in_bskies: many(document_mentions_in_bsky),
 	leaflets_in_publications: many(leaflets_in_publications),
 }));
 
-export const factsRelations = relations(facts, ({one}) => ({
-	entity: one(entities, {
-		fields: [facts.entity],
-		references: [entities.id]
+export const bsky_profilesRelations = relations(bsky_profiles, ({one, many}) => ({
+	comments_on_documents: many(comments_on_documents),
+	identity: one(identities, {
+		fields: [bsky_profiles.did],
+		references: [identities.atp_did]
 	}),
 }));
 
 export const entitiesRelations = relations(entities, ({one, many}) => ({
-	facts: many(facts),
 	entity_set: one(entity_sets, {
 		fields: [entities.set],
 		references: [entity_sets.id]
 	}),
-	permission_tokens: many(permission_tokens),
-	email_subscriptions_to_entities: many(email_subscriptions_to_entity),
-	phone_rsvps_to_entities: many(phone_rsvps_to_entity),
+	facts: many(facts),
 	poll_votes_on_entities_option_entity: many(poll_votes_on_entity, {
 		relationName: "poll_votes_on_entity_option_entity_entities_id"
 	}),
 	poll_votes_on_entities_poll_entity: many(poll_votes_on_entity, {
 		relationName: "poll_votes_on_entity_poll_entity_entities_id"
 	}),
+	permission_tokens: many(permission_tokens),
+	phone_rsvps_to_entities: many(phone_rsvps_to_entity),
+	email_subscriptions_to_entities: many(email_subscriptions_to_entity),
 }));
 
 export const entity_setsRelations = relations(entity_sets, ({many}) => ({
···
 	permission_token_rights: many(permission_token_rights),
 }));
 
+export const factsRelations = relations(facts, ({one}) => ({
+	entity: one(entities, {
+		fields: [facts.entity],
+		references: [entities.id]
+	}),
+}));
+
+export const email_auth_tokensRelations = relations(email_auth_tokens, ({one}) => ({
+	identity: one(identities, {
+		fields: [email_auth_tokens.identity],
+		references: [identities.id]
+	}),
+}));
+
+export const poll_votes_on_entityRelations = relations(poll_votes_on_entity, ({one}) => ({
+	entity_option_entity: one(entities, {
+		fields: [poll_votes_on_entity.option_entity],
+		references: [entities.id],
+		relationName: "poll_votes_on_entity_option_entity_entities_id"
+	}),
+	entity_poll_entity: one(entities, {
+		fields: [poll_votes_on_entity.poll_entity],
+		references: [entities.id],
+		relationName: "poll_votes_on_entity_poll_entity_entities_id"
+	}),
+}));
+
 export const permission_tokensRelations = relations(permission_tokens, ({one, many}) => ({
 	entity: one(entities, {
 		fields: [permission_tokens.root_entity],
 		references: [entities.id]
 	}),
 	identities: many(identities),
-	email_subscriptions_to_entities: many(email_subscriptions_to_entity),
 	custom_domain_routes_edit_permission_token: many(custom_domain_routes, {
 		relationName: "custom_domain_routes_edit_permission_token_permission_tokens_id"
 	}),
 	custom_domain_routes_view_permission_token: many(custom_domain_routes, {
 		relationName: "custom_domain_routes_view_permission_token_permission_tokens_id"
 	}),
+	email_subscriptions_to_entities: many(email_subscriptions_to_entity),
 	permission_token_on_homepages: many(permission_token_on_homepage),
 	leaflets_in_publications: many(leaflets_in_publications),
 	permission_token_rights: many(permission_token_rights),
 }));
 
-export const email_subscriptions_to_entityRelations = relations(email_subscriptions_to_entity, ({one}) => ({
+export const phone_rsvps_to_entityRelations = relations(phone_rsvps_to_entity, ({one}) => ({
 	entity: one(entities, {
-		fields: [email_subscriptions_to_entity.entity],
+		fields: [phone_rsvps_to_entity.entity],
 		references: [entities.id]
-	}),
-	permission_token: one(permission_tokens, {
-		fields: [email_subscriptions_to_entity.token],
-		references: [permission_tokens.id]
 	}),
 }));
 
-export const email_auth_tokensRelations = relations(email_auth_tokens, ({one}) => ({
-	identity: one(identities, {
-		fields: [email_auth_tokens.identity],
-		references: [identities.id]
+export const custom_domain_routesRelations = relations(custom_domain_routes, ({one}) => ({
+	custom_domain: one(custom_domains, {
+		fields: [custom_domain_routes.domain],
+		references: [custom_domains.domain]
+	}),
+	permission_token_edit_permission_token: one(permission_tokens, {
+		fields: [custom_domain_routes.edit_permission_token],
+		references: [permission_tokens.id],
+		relationName: "custom_domain_routes_edit_permission_token_permission_tokens_id"
+	}),
+	permission_token_view_permission_token: one(permission_tokens, {
+		fields: [custom_domain_routes.view_permission_token],
+		references: [permission_tokens.id],
+		relationName: "custom_domain_routes_view_permission_token_permission_tokens_id"
 	}),
 }));
 
 export const custom_domainsRelations = relations(custom_domains, ({one, many}) => ({
+	custom_domain_routes: many(custom_domain_routes),
 	identity_identity: one(identities, {
 		fields: [custom_domains.identity],
 		references: [identities.email],
···
 		references: [identities.id],
 		relationName: "custom_domains_identity_id_identities_id"
 	}),
-	custom_domain_routes: many(custom_domain_routes),
 	publication_domains: many(publication_domains),
 }));
 
-export const phone_rsvps_to_entityRelations = relations(phone_rsvps_to_entity, ({one}) => ({
+export const email_subscriptions_to_entityRelations = relations(email_subscriptions_to_entity, ({one}) => ({
 	entity: one(entities, {
-		fields: [phone_rsvps_to_entity.entity],
+		fields: [email_subscriptions_to_entity.entity],
 		references: [entities.id]
 	}),
-}));
-
-export const custom_domain_routesRelations = relations(custom_domain_routes, ({one}) => ({
-	custom_domain: one(custom_domains, {
-		fields: [custom_domain_routes.domain],
-		references: [custom_domains.domain]
-	}),
-	permission_token_edit_permission_token: one(permission_tokens, {
-		fields: [custom_domain_routes.edit_permission_token],
-		references: [permission_tokens.id],
-		relationName: "custom_domain_routes_edit_permission_token_permission_tokens_id"
-	}),
-	permission_token_view_permission_token: one(permission_tokens, {
-		fields: [custom_domain_routes.view_permission_token],
-		references: [permission_tokens.id],
-		relationName: "custom_domain_routes_view_permission_token_permission_tokens_id"
+	permission_token: one(permission_tokens, {
+		fields: [email_subscriptions_to_entity.token],
+		references: [permission_tokens.id]
 	}),
 }));
 
-export const poll_votes_on_entityRelations = relations(poll_votes_on_entity, ({one}) => ({
-	entity_option_entity: one(entities, {
-		fields: [poll_votes_on_entity.option_entity],
-		references: [entities.id],
-		relationName: "poll_votes_on_entity_option_entity_entities_id"
+export const bsky_followsRelations = relations(bsky_follows, ({one}) => ({
+	identity_follows: one(identities, {
+		fields: [bsky_follows.follows],
+		references: [identities.atp_did],
+		relationName: "bsky_follows_follows_identities_atp_did"
 	}),
-	entity_poll_entity: one(entities, {
-		fields: [poll_votes_on_entity.poll_entity],
-		references: [entities.id],
-		relationName: "poll_votes_on_entity_poll_entity_entities_id"
+	identity_identity: one(identities, {
+		fields: [bsky_follows.identity],
+		references: [identities.atp_did],
+		relationName: "bsky_follows_identity_identities_atp_did"
 	}),
 }));
 
···
 	}),
 }));
 
-export const document_mentions_in_bskyRelations = relations(document_mentions_in_bsky, ({one}) => ({
-	document: one(documents, {
-		fields: [document_mentions_in_bsky.document],
-		references: [documents.uri]
-	}),
-	bsky_post: one(bsky_posts, {
-		fields: [document_mentions_in_bsky.uri],
-		references: [bsky_posts.uri]
-	}),
-}));
-
-export const bsky_postsRelations = relations(bsky_posts, ({many}) => ({
-	document_mentions_in_bskies: many(document_mentions_in_bsky),
-}));
-
 export const permission_token_on_homepageRelations = relations(permission_token_on_homepage, ({one}) => ({
 	identity: one(identities, {
 		fields: [permission_token_on_homepage.identity],
···
 	}),
 }));
 
+export const document_mentions_in_bskyRelations = relations(document_mentions_in_bsky, ({one}) => ({
+	document: one(documents, {
+		fields: [document_mentions_in_bsky.document],
+		references: [documents.uri]
+	}),
+	bsky_post: one(bsky_posts, {
+		fields: [document_mentions_in_bsky.uri],
+		references: [bsky_posts.uri]
+	}),
+}));
+
+export const bsky_postsRelations = relations(bsky_posts, ({many}) => ({
+	document_mentions_in_bskies: many(document_mentions_in_bsky),
+}));
+
 export const publication_domainsRelations = relations(publication_domains, ({one}) => ({
 	custom_domain: one(custom_domains, {
 		fields: [publication_domains.domain],
···
 	}),
 }));
 
-export const publication_subscriptionsRelations = relations(publication_subscriptions, ({one}) => ({
-	identity: one(identities, {
-		fields: [publication_subscriptions.identity],
-		references: [identities.atp_did]
-	}),
-	publication: one(publications, {
-		fields: [publication_subscriptions.publication],
-		references: [publications.uri]
-	}),
-}));
-
 export const leaflets_in_publicationsRelations = relations(leaflets_in_publications, ({one}) => ({
 	document: one(documents, {
 		fields: [leaflets_in_publications.doc],
···
 	}),
 	publication: one(publications, {
 		fields: [leaflets_in_publications.publication],
+		references: [publications.uri]
+	}),
+}));
+
+export const publication_subscriptionsRelations = relations(publication_subscriptions, ({one}) => ({
+	identity: one(identities, {
+		fields: [publication_subscriptions.identity],
+		references: [identities.atp_did]
+	}),
+	publication: one(publications, {
+		fields: [publication_subscriptions.publication],
 		references: [publications.uri]
 	}),
 }));

drizzle/schema.ts

···
-import { pgTable, pgEnum, text, jsonb, foreignKey, timestamp, uuid, bigint, boolean, unique, uniqueIndex, smallint, primaryKey } from "drizzle-orm/pg-core"
+import { pgTable, pgEnum, text, jsonb, index, foreignKey, timestamp, uuid, bigint, boolean, unique, uniqueIndex, smallint, primaryKey } from "drizzle-orm/pg-core"
   import { sql } from "drizzle-orm"
 
 export const aal_level = pgEnum("aal_level", ['aal1', 'aal2', 'aal3'])
 export const code_challenge_method = pgEnum("code_challenge_method", ['s256', 'plain'])
 export const factor_status = pgEnum("factor_status", ['unverified', 'verified'])
-export const factor_type = pgEnum("factor_type", ['totp', 'webauthn'])
+export const factor_type = pgEnum("factor_type", ['totp', 'webauthn', 'phone'])
+export const oauth_authorization_status = pgEnum("oauth_authorization_status", ['pending', 'approved', 'denied', 'expired'])
+export const oauth_client_type = pgEnum("oauth_client_type", ['public', 'confidential'])
+export const oauth_registration_type = pgEnum("oauth_registration_type", ['dynamic', 'manual'])
+export const oauth_response_type = pgEnum("oauth_response_type", ['code'])
 export const one_time_token_type = pgEnum("one_time_token_type", ['confirmation_token', 'reauthentication_token', 'recovery_token', 'email_change_token_new', 'email_change_token_current', 'phone_change_token'])
-export const request_status = pgEnum("request_status", ['PENDING', 'SUCCESS', 'ERROR'])
 export const key_status = pgEnum("key_status", ['default', 'valid', 'invalid', 'expired'])
 export const key_type = pgEnum("key_type", ['aead-ietf', 'aead-det', 'hmacsha512', 'hmacsha256', 'auth', 'shorthash', 'generichash', 'kdf', 'secretbox', 'secretstream', 'stream_xchacha20'])
 export const rsvp_status = pgEnum("rsvp_status", ['GOING', 'NOT_GOING', 'MAYBE'])
 export const action = pgEnum("action", ['INSERT', 'UPDATE', 'DELETE', 'TRUNCATE', 'ERROR'])
 export const equality_op = pgEnum("equality_op", ['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in'])
+export const buckettype = pgEnum("buckettype", ['STANDARD', 'ANALYTICS'])
 
 
 export const oauth_state_store = pgTable("oauth_state_store", {
···
 	state: jsonb("state").notNull(),
 });
 
-export const oauth_session_store = pgTable("oauth_session_store", {
-	key: text("key").primaryKey().notNull(),
-	session: jsonb("session").notNull(),
-});
-
-export const bsky_profiles = pgTable("bsky_profiles", {
-	did: text("did").primaryKey().notNull().references(() => identities.atp_did, { onDelete: "cascade" } ),
-	record: jsonb("record").notNull(),
-	indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	handle: text("handle"),
-});
-
 export const publications = pgTable("publications", {
 	uri: text("uri").primaryKey().notNull(),
 	indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
 	name: text("name").notNull(),
 	identity_did: text("identity_did").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ),
 	record: jsonb("record"),
-});
-
-export const bsky_posts = pgTable("bsky_posts", {
-	uri: text("uri").primaryKey().notNull(),
-	indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	post_view: jsonb("post_view").notNull(),
-	cid: text("cid").notNull(),
+},
+(table) => {
+	return {
+		identity_did_idx: index("publications_identity_did_idx").on(table.identity_did),
+	}
 });
 
 export const comments_on_documents = pgTable("comments_on_documents", {
···
 	profile: text("profile").references(() => bsky_profiles.did, { onDelete: "set null", onUpdate: "cascade" } ),
 });
 
+export const entities = pgTable("entities", {
+	id: uuid("id").primaryKey().notNull(),
+	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	set: uuid("set").notNull().references(() => entity_sets.id, { onDelete: "cascade", onUpdate: "cascade" } ),
+},
+(table) => {
+	return {
+		set_idx: index("entities_set_idx").on(table.set),
+	}
+});
+
 export const facts = pgTable("facts", {
 	id: uuid("id").primaryKey().notNull(),
 	entity: uuid("entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "restrict" } ),
···
 	updated_at: timestamp("updated_at", { mode: 'string' }),
 	// You can use { mode: "bigint" } if numbers are exceeding js number limitations
 	version: bigint("version", { mode: "number" }).default(0).notNull(),
-});
-
-export const documents = pgTable("documents", {
-	uri: text("uri").primaryKey().notNull(),
-	data: jsonb("data").notNull(),
-	indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+},
+(table) => {
+	return {
+		entity_idx: index("facts_entity_idx").on(table.entity),
+	}
 });
 
 export const replicache_clients = pgTable("replicache_clients", {
···
 	client_group: text("client_group").notNull(),
 	// You can use { mode: "bigint" } if numbers are exceeding js number limitations
 	last_mutation: bigint("last_mutation", { mode: "number" }).notNull(),
+},
+(table) => {
+	return {
+		client_group_idx: index("replicache_clients_client_group_idx").on(table.client_group),
+	}
 });
 
-export const entities = pgTable("entities", {
-	id: uuid("id").primaryKey().notNull(),
+export const email_auth_tokens = pgTable("email_auth_tokens", {
+	id: uuid("id").defaultRandom().primaryKey().notNull(),
 	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	set: uuid("set").notNull().references(() => entity_sets.id, { onDelete: "cascade", onUpdate: "cascade" } ),
+	confirmed: boolean("confirmed").default(false).notNull(),
+	email: text("email"),
+	confirmation_code: text("confirmation_code").notNull(),
+	identity: uuid("identity").references(() => identities.id, { onDelete: "cascade", onUpdate: "cascade" } ),
+});
+
+export const bsky_posts = pgTable("bsky_posts", {
+	uri: text("uri").primaryKey().notNull(),
+	indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	post_view: jsonb("post_view").notNull(),
+	cid: text("cid").notNull(),
+});
+
+export const bsky_profiles = pgTable("bsky_profiles", {
+	did: text("did").primaryKey().notNull().references(() => identities.atp_did, { onDelete: "cascade" } ),
+	record: jsonb("record").notNull(),
+	indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	handle: text("handle"),
 });
 
 export const entity_sets = pgTable("entity_sets", {
 	id: uuid("id").defaultRandom().primaryKey().notNull(),
 	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+});
+
+export const poll_votes_on_entity = pgTable("poll_votes_on_entity", {
+	id: uuid("id").defaultRandom().primaryKey().notNull(),
+	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	poll_entity: uuid("poll_entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "cascade" } ),
+	option_entity: uuid("option_entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "cascade" } ),
+	voter_token: uuid("voter_token").notNull(),
 });
 
 export const permission_tokens = pgTable("permission_tokens", {
···
 	}
 });
 
-export const email_subscriptions_to_entity = pgTable("email_subscriptions_to_entity", {
-	id: uuid("id").defaultRandom().primaryKey().notNull(),
-	entity: uuid("entity").notNull().references(() => entities.id, { onDelete: "cascade" } ),
-	email: text("email").notNull(),
-	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	token: uuid("token").notNull().references(() => permission_tokens.id, { onDelete: "cascade" } ),
-	confirmed: boolean("confirmed").default(false).notNull(),
-	confirmation_code: text("confirmation_code").notNull(),
-});
-
-export const email_auth_tokens = pgTable("email_auth_tokens", {
-	id: uuid("id").defaultRandom().primaryKey().notNull(),
-	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	confirmed: boolean("confirmed").default(false).notNull(),
-	email: text("email"),
-	confirmation_code: text("confirmation_code").notNull(),
-	identity: uuid("identity").references(() => identities.id, { onDelete: "cascade", onUpdate: "cascade" } ),
-});
-
 export const phone_number_auth_tokens = pgTable("phone_number_auth_tokens", {
 	id: uuid("id").defaultRandom().primaryKey().notNull(),
 	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
···
 	confirmation_code: text("confirmation_code").notNull(),
 	phone_number: text("phone_number").notNull(),
 	country_code: text("country_code").notNull(),
-});
-
-export const custom_domains = pgTable("custom_domains", {
-	domain: text("domain").primaryKey().notNull(),
-	identity: text("identity").default('').references(() => identities.email, { onDelete: "cascade", onUpdate: "cascade" } ),
-	confirmed: boolean("confirmed").notNull(),
-	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	identity_id: uuid("identity_id").references(() => identities.id, { onDelete: "cascade" } ),
 });
 
 export const phone_rsvps_to_entity = pgTable("phone_rsvps_to_entity", {
···
 },
 (table) => {
 	return {
+		edit_permission_token_idx: index("custom_domain_routes_edit_permission_token_idx").on(table.edit_permission_token),
 		custom_domain_routes_domain_route_key: unique("custom_domain_routes_domain_route_key").on(table.domain, table.route),
 	}
 });
 
-export const poll_votes_on_entity = pgTable("poll_votes_on_entity", {
+export const custom_domains = pgTable("custom_domains", {
+	domain: text("domain").primaryKey().notNull(),
+	identity: text("identity").default('').references(() => identities.email, { onDelete: "cascade", onUpdate: "cascade" } ),
+	confirmed: boolean("confirmed").notNull(),
+	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	identity_id: uuid("identity_id").references(() => identities.id, { onDelete: "cascade" } ),
+});
+
+export const email_subscriptions_to_entity = pgTable("email_subscriptions_to_entity", {
 	id: uuid("id").defaultRandom().primaryKey().notNull(),
+	entity: uuid("entity").notNull().references(() => entities.id, { onDelete: "cascade" } ),
+	email: text("email").notNull(),
 	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	poll_entity: uuid("poll_entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "cascade" } ),
-	option_entity: uuid("option_entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "cascade" } ),
-	voter_token: uuid("voter_token").notNull(),
+	token: uuid("token").notNull().references(() => permission_tokens.id, { onDelete: "cascade" } ),
+	confirmed: boolean("confirmed").default(false).notNull(),
+	confirmation_code: text("confirmation_code").notNull(),
 });
 
-export const subscribers_to_publications = pgTable("subscribers_to_publications", {
-	identity: text("identity").notNull().references(() => identities.email, { onUpdate: "cascade" } ),
-	publication: text("publication").notNull().references(() => publications.uri),
-	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+export const documents = pgTable("documents", {
+	uri: text("uri").primaryKey().notNull(),
+	data: jsonb("data").notNull(),
+	indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+});
+
+export const oauth_session_store = pgTable("oauth_session_store", {
+	key: text("key").primaryKey().notNull(),
+	session: jsonb("session").notNull(),
+});
+
+export const bsky_follows = pgTable("bsky_follows", {
+	identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ),
+	follows: text("follows").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ),
 },
 (table) => {
 	return {
-		subscribers_to_publications_pkey: primaryKey({ columns: [table.identity, table.publication], name: "subscribers_to_publications_pkey"}),
+		bsky_follows_pkey: primaryKey({ columns: [table.identity, table.follows], name: "bsky_follows_pkey"}),
 	}
 });
 
-export const document_mentions_in_bsky = pgTable("document_mentions_in_bsky", {
-	uri: text("uri").notNull().references(() => bsky_posts.uri, { onDelete: "cascade" } ),
-	link: text("link").notNull(),
-	document: text("document").notNull().references(() => documents.uri, { onDelete: "cascade" } ),
+export const subscribers_to_publications = pgTable("subscribers_to_publications", {
+	identity: text("identity").notNull().references(() => identities.email, { onUpdate: "cascade" } ),
+	publication: text("publication").notNull().references(() => publications.uri),
+	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
 },
 (table) => {
 	return {
-		document_mentions_in_bsky_pkey: primaryKey({ columns: [table.uri, table.document], name: "document_mentions_in_bsky_pkey"}),
+		subscribers_to_publications_pkey: primaryKey({ columns: [table.identity, table.publication], name: "subscribers_to_publications_pkey"}),
 	}
 });
 
···
 },
 (table) => {
 	return {
+		publication_idx: index("documents_in_publications_publication_idx").on(table.publication),
 		documents_in_publications_pkey: primaryKey({ columns: [table.publication, table.document], name: "documents_in_publications_pkey"}),
 	}
 });
 
-export const publication_domains = pgTable("publication_domains", {
-	publication: text("publication").notNull().references(() => publications.uri, { onDelete: "cascade" } ),
-	domain: text("domain").notNull().references(() => custom_domains.domain, { onDelete: "cascade" } ),
-	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade", onUpdate: "cascade" } ),
+export const document_mentions_in_bsky = pgTable("document_mentions_in_bsky", {
+	uri: text("uri").notNull().references(() => bsky_posts.uri, { onDelete: "cascade" } ),
+	link: text("link").notNull(),
+	document: text("document").notNull().references(() => documents.uri, { onDelete: "cascade" } ),
+	indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
 },
 (table) => {
 	return {
-		publication_domains_pkey: primaryKey({ columns: [table.publication, table.domain], name: "publication_domains_pkey"}),
+		document_mentions_in_bsky_pkey: primaryKey({ columns: [table.uri, table.document], name: "document_mentions_in_bsky_pkey"}),
 	}
 });
 
-export const publication_subscriptions = pgTable("publication_subscriptions", {
+export const publication_domains = pgTable("publication_domains", {
 	publication: text("publication").notNull().references(() => publications.uri, { onDelete: "cascade" } ),
-	identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ),
+	domain: text("domain").notNull().references(() => custom_domains.domain, { onDelete: "cascade" } ),
 	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-	record: jsonb("record").notNull(),
-	uri: text("uri").notNull(),
+	identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade", onUpdate: "cascade" } ),
 },
 (table) => {
 	return {
-		publication_subscriptions_pkey: primaryKey({ columns: [table.publication, table.identity], name: "publication_subscriptions_pkey"}),
-		publication_subscriptions_uri_key: unique("publication_subscriptions_uri_key").on(table.uri),
+		publication_idx: index("publication_domains_publication_idx").on(table.publication),
+		publication_domains_pkey: primaryKey({ columns: [table.publication, table.domain], name: "publication_domains_pkey"}),
 	}
 });
 
···
 },
 (table) => {
 	return {
+		leaflet_idx: index("leaflets_in_publications_leaflet_idx").on(table.leaflet),
+		publication_idx: index("leaflets_in_publications_publication_idx").on(table.publication),
 		leaflets_in_publications_pkey: primaryKey({ columns: [table.publication, table.leaflet], name: "leaflets_in_publications_pkey"}),
 	}
 });
 
+export const publication_subscriptions = pgTable("publication_subscriptions", {
+	publication: text("publication").notNull().references(() => publications.uri, { onDelete: "cascade" } ),
+	identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ),
+	created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	record: jsonb("record").notNull(),
+	uri: text("uri").notNull(),
+},
+(table) => {
+	return {
+		publication_idx: index("publication_subscriptions_publication_idx").on(table.publication),
+		publication_subscriptions_pkey: primaryKey({ columns: [table.publication, table.identity], name: "publication_subscriptions_pkey"}),
+		publication_subscriptions_uri_key: unique("publication_subscriptions_uri_key").on(table.uri),
+	}
+});
+
 export const permission_token_rights = pgTable("permission_token_rights", {
 	token: uuid("token").notNull().references(() => permission_tokens.id, { onDelete: "cascade", onUpdate: "cascade" } ),
 	entity_set: uuid("entity_set").notNull().references(() => entity_sets.id, { onDelete: "cascade", onUpdate: "cascade" } ),
···
 },
 (table) => {
 	return {
+		token_idx: index("permission_token_rights_token_idx").on(table.token),
+		entity_set_idx: index("permission_token_rights_entity_set_idx").on(table.entity_set),
 		permission_token_rights_pkey: primaryKey({ columns: [table.token, table.entity_set], name: "permission_token_rights_pkey"}),
 	}
 });

feeds/index.ts

···
 import { parseReqNsid, verifyJwt } from "@atproto/xrpc-server";
 import { supabaseServerClient } from "supabase/serverClient";
 import { PubLeafletDocument } from "lexicons/api";
+import { inngest } from "app/api/inngest/client";
+import { AtUri } from "@atproto/api";
 
 const app = new Hono();
 
···
 
 app.get("/xrpc/app.bsky.feed.getFeedSkeleton", async (c) => {
   let auth = await validateAuth(c.req, serviceDid);
-  if (!auth) return c.json({ feed: [] });
+  let feed = c.req.query("feed");
+  if (!auth || !feed) return c.json({ feed: [] });
   let cursor = c.req.query("cursor");
+  let parsedCursor;
+  if (cursor) {
+    let date = cursor.split("::")[0];
+    let uri = cursor.split("::")[1];
+    parsedCursor = { date, uri };
+  }
   let limit = parseInt(c.req.query("limit") || "10");
+  let feedAtURI = new AtUri(feed);
+  let posts;
+  let query;
+  if (feedAtURI.rkey == "bsky-leaflet-quotes") {
+    let query = supabaseServerClient
+      .from("document_mentions_in_bsky")
+      .select("*")
+      .order("indexed_at", { ascending: false })
+      .order("uri", { ascending: false })
+      .limit(25);
+    if (parsedCursor)
+      query = query.or(
+        `indexed_at.lt.${parsedCursor.date},and(indexed_at.eq.${parsedCursor.date},uri.lt.${parsedCursor.uri})`,
+      );
 
-  let { data: publications } = await supabaseServerClient
-    .from("publication_subscriptions")
-    .select(`publications(documents_in_publications(documents(*)))`)
-    .eq("identity", auth);
+    let { data, error } = await query;
+    let posts = data || [];
 
-  const allPosts = (publications || [])
-    .flatMap((pub) => {
-      let posts = pub.publications?.documents_in_publications || [];
-      return posts;
-    })
-    .sort((a, b) => {
-      let aRecord = a.documents?.data! as PubLeafletDocument.Record;
-      let bRecord = b.documents?.data! as PubLeafletDocument.Record;
-      const aDate = aRecord.publishedAt
-        ? new Date(aRecord.publishedAt)
-        : new Date(0);
-      const bDate = bRecord.publishedAt
-        ? new Date(bRecord.publishedAt)
-        : new Date(0);
-      return bDate.getTime() - aDate.getTime(); // Sort by most recent first
+    let lastPost = posts[posts.length - 1];
+    let newCursor = lastPost ? `${lastPost.indexed_at}::${lastPost.uri}` : null;
+    return c.json({
+      cursor: newCursor || cursor,
+      feed: posts.flatMap((p) => {
+        return { post: p.uri };
+      }),
     });
-  let posts;
-  if (!cursor) {
-    posts = allPosts.slice(0, 25);
+  }
+  if (feedAtURI.rkey === "bsky-follows-leaflets") {
+    if (!cursor) {
+      console.log("Sending event");
+      await inngest.send({ name: "feeds/index-follows", data: { did: auth } });
+    }
+    query = supabaseServerClient
+      .from("documents")
+      .select(
+        `*,
+         documents_in_publications!inner(
+           publications!inner(*,
+             identities!publications_identity_did_fkey!inner(
+               bsky_follows!bsky_follows_follows_fkey!inner(*)
+              )
+            )
+          )`,
+      )
+      .eq(
+        "documents_in_publications.publications.identities.bsky_follows.identity",
+        auth,
+      );
+  } else if (feedAtURI.rkey === "all-leaflets") {
+    query = supabaseServerClient
+      .from("documents")
+      .select(
+        `*,
+          documents_in_publications!inner(publications!inner(*))`,
+      )
+      .or(
+        "record->preferences->showInDiscover.is.null,record->preferences->>showInDiscover.eq.true",
+        { referencedTable: "documents_in_publications.publications" },
+      );
   } else {
-    let date = cursor.split("::")[0];
-    let uri = cursor.split("::")[1];
-    posts = allPosts
-      .filter((p) => {
-        if (!p.documents?.data) return false;
-        let record = p.documents.data as PubLeafletDocument.Record;
-        if (!record.publishedAt) return false;
-        return record.publishedAt <= date && uri !== p.documents?.uri;
-      })
-      .slice(0, 25);
+    //the default subscription feed
+    query = supabaseServerClient
+      .from("documents")
+      .select(
+        `*,
+          documents_in_publications!inner(publications!inner(*, publication_subscriptions!inner(*)))`,
+      )
+      .eq(
+        "documents_in_publications.publications.publication_subscriptions.identity",
+        auth,
+      );
   }
+  query = query
+    .not("data -> postRef", "is", null)
+    .order("indexed_at", { ascending: false })
+    .order("uri", { ascending: false })
+    .limit(25);
+  if (parsedCursor)
+    query = query.or(
+      `indexed_at.lt.${parsedCursor.date},and(indexed_at.eq.${parsedCursor.date},uri.lt.${parsedCursor.uri})`,
+    );
+
+  let { data, error } = await query;
+  console.log(error);
+  posts = data;
+
+  posts = posts || [];
 
   let lastPost = posts[posts.length - 1];
-  let lastRecord = lastPost?.documents?.data! as PubLeafletDocument.Record;
-  let newCursor = lastRecord
-    ? `${lastRecord.publishedAt}::${lastPost.documents?.uri}`
-    : null;
+  let newCursor = lastPost ? `${lastPost.indexed_at}::${lastPost.uri}` : null;
   return c.json({
     cursor: newCursor || cursor,
     feed: posts.flatMap((p) => {
-      if (!p.documents?.data) return [];
-      let record = p.documents.data as PubLeafletDocument.Record;
+      if (!p.data) return [];
+      let record = p.data as PubLeafletDocument.Record;
       if (!record.postRef) return [];
       return { post: record.postRef.uri };
     }),

lexicons/src/blocks.ts

···
   },
 };
 
+export const PubLeafletBlocksOrderedList: LexiconDoc = {
+  lexicon: 1,
+  id: "pub.leaflet.blocks.orderedList",
+  defs: {
+    main: {
+      type: "object",
+      required: ["children"],
+      properties: {
+        startIndex: { type: "integer" },
+        children: { type: "array", items: { type: "ref", ref: "#listItem" } },
+      },
+    },
+    listItem: {
+      type: "object",
+      required: ["content"],
+      properties: {
+        content: {
+          type: "union",
+          refs: [
+            PubLeafletBlocksText,
+            PubLeafletBlocksHeader,
+            PubLeafletBlocksImage,
+          ].map((l) => l.id),
+        },
+        children: { type: "array", items: { type: "ref", ref: "#listItem" } },
+      },
+    },
+  },
+};
+
 export const PubLeafletBlocksUnorderedList: LexiconDoc = {
   lexicon: 1,
   id: "pub.leaflet.blocks.unorderedList",

middleware.ts

···
     let aturi = new AtUri(pub?.uri);
     return NextResponse.rewrite(
       new URL(
-        `/lish/${aturi.host}/${encodeURIComponent(pub.name)}${req.nextUrl.pathname}`,
+        `/lish/${aturi.host}/${aturi.rkey}${req.nextUrl.pathname}`,
         req.url,
       ),
     );

package-lock.json

···
         "@types/mdx": "^2.0.13",
         "@vercel/analytics": "^1.5.0",
         "@vercel/functions": "^2.2.12",
-        "@vercel/sdk": "^1.3.1",
+        "@vercel/sdk": "^1.11.4",
         "babel-plugin-react-compiler": "^19.1.0-rc.1",
         "base64-js": "^1.5.1",
         "colorjs.io": "^0.5.2",
···
       }
     },
     "node_modules/@vercel/sdk": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@vercel/sdk/-/sdk-1.3.1.tgz",
-      "integrity": "sha512-lTzG17DIDEJlWaGRNVyLZ17p8NRMOE2U98Kg96r1q79LGC8nPthoWhxupHXxGk3eAjjsvp8OA3bncKEyCHcofg==",
+      "version": "1.11.4",
+      "resolved": "https://registry.npmjs.org/@vercel/sdk/-/sdk-1.11.4.tgz",
+      "integrity": "sha512-TlLGQq6ToqnGhICQjvAyjSJkrHsLtqIM+nZuGV/SiamwSzXjiTpeTAe5wMDAao7LPJ9Efir/z76TvXFbLlW/9Q==",
+      "dependencies": {
+        "zod": "^3.20.0"
+      },
+      "bin": {
+        "mcp": "bin/mcp-server.js"
+      },
       "peerDependencies": {
-        "zod": ">= 3"
+        "@modelcontextprotocol/sdk": ">=1.5.0 <1.10.0"
+      },
+      "peerDependenciesMeta": {
+        "@modelcontextprotocol/sdk": {
+          "optional": true
+        }
       }
     },
     "node_modules/abort-controller": {

package.json

···
     "@types/mdx": "^2.0.13",
     "@vercel/analytics": "^1.5.0",
     "@vercel/functions": "^2.2.12",
-    "@vercel/sdk": "^1.3.1",
+    "@vercel/sdk": "^1.11.4",
     "babel-plugin-react-compiler": "^19.1.0-rc.1",
     "base64-js": "^1.5.1",
     "colorjs.io": "^0.5.2",

src/hooks/usePreserveScroll.ts

···
+import { useRef, useEffect } from "react";
+
+let scrollPositions: { [key: string]: number } = {};
+export function usePreserveScroll<T extends HTMLElement>(key: string | null) {
+  let ref = useRef<T | null>(null);
+  useEffect(() => {
+    if (!ref.current || !key) return;
+
+    window.requestAnimationFrame(() => {
+      ref.current?.scrollTo({ top: scrollPositions[key] || 0 });
+    });
+
+    const listener = () => {
+      if (!ref.current?.scrollTop) return;
+      scrollPositions[key] = ref.current.scrollTop;
+    };
+
+    ref.current.addEventListener("scroll", listener);
+    return () => ref.current?.removeEventListener("scroll", listener);
+  }, [key, ref.current]);
+  return { ref };
+}

src/shortcuts.ts

···
 import { ReplicacheMutators } from "./replicache";
 import { isMac } from "./utils/isDevice";
 
-type Shortcut = {
+export type Shortcut = {
   metaKey?: boolean;
+  metaAndCtrl?: boolean;
   altKey?: boolean;
   shift?: boolean;
   key: string | string[];
···
     for (let shortcut of [shortcuts].flat()) {
       if (e.shiftKey !== !!shortcut.shift) continue;
       if (e.altKey !== !!shortcut.altKey) continue;
-      if (!!shortcut.metaKey !== (isMac() ? e.metaKey : e.ctrlKey)) continue;
+      if (shortcut.metaAndCtrl) {
+        if (!(e.metaKey && e.ctrlKey)) continue;
+      } else if (!!shortcut.metaKey !== (isMac() ? e.metaKey : e.ctrlKey))
+        continue;
       if (![shortcut.key].flat().includes(e.key)) continue;
       e.preventDefault();
       return shortcut.handler();

src/utils/addLinkBlock.ts

···
   }
 
   if (data.data.links?.player?.[0]) {
-    console.log(data.data.links.player);
     let embed = data.data.links?.player?.[0];
     await rep.mutate.assertFact([
       {

src/utils/focusBlock.ts

···
         top: nextBlockViewClientRect.top + 12,
         left: Math.max(position.left, nextBlockViewClientRect.left),
       });
-      console.log(pos);
       break;
     }
     case "bottom": {

src/utils/getBlocksAsHTML.tsx

···
     return (
       <div
         data-type="card"
-        data-facts={btoa(JSON.stringify(facts))}
+        data-facts={JSON.stringify(facts)}
         data-entityid={card.data.value}
       />
     );
···
   let [alignment] = await scanIndex(tx).eav(b.value, "block/text-alignment");
   let toHtml = BlockTypeToHTML[b.type];
   let element = await toHtml(b, tx, alignment?.data.value);
-  console.log(element);
   return renderToStaticMarkup(element);
 }

supabase/database.types.ts

···
   }
   public: {
     Tables: {
+      bsky_follows: {
+        Row: {
+          follows: string
+          identity: string
+        }
+        Insert: {
+          follows: string
+          identity?: string
+        }
+        Update: {
+          follows?: string
+          identity?: string
+        }
+        Relationships: [
+          {
+            foreignKeyName: "bsky_follows_follows_fkey"
+            columns: ["follows"]
+            isOneToOne: false
+            referencedRelation: "identities"
+            referencedColumns: ["atp_did"]
+          },
+          {
+            foreignKeyName: "bsky_follows_identity_fkey"
+            columns: ["identity"]
+            isOneToOne: false
+            referencedRelation: "identities"
+            referencedColumns: ["atp_did"]
+          },
+        ]
+      }
       bsky_posts: {
         Row: {
           cid: string
···
       document_mentions_in_bsky: {
         Row: {
           document: string
+          indexed_at: string
           link: string
           uri: string
         }
         Insert: {
           document: string
+          indexed_at?: string
           link: string
           uri: string
         }
         Update: {
           document?: string
+          indexed_at?: string
           link?: string
           uri?: string
         }

supabase/migrations/20251014215602_add_bsky_follows_table.sql

···
+create table "public"."bsky_follows" (
+    "identity" text not null,
+    "follows" text not null
+);
+
+alter table "public"."bsky_follows" enable row level security;
+
+CREATE UNIQUE INDEX bsky_follows_pkey ON public.bsky_follows USING btree (identity, follows);
+
+CREATE INDEX facts_reference_idx ON public.facts USING btree (((data ->> 'value'::text))) WHERE (((data ->> 'type'::text) = 'reference'::text) OR ((data ->> 'type'::text) = 'ordered-reference'::text));
+
+alter table "public"."bsky_follows" add constraint "bsky_follows_pkey" PRIMARY KEY using index "bsky_follows_pkey";
+
+alter table "public"."bsky_follows" add constraint "bsky_follows_follows_fkey" FOREIGN KEY (follows) REFERENCES identities(atp_did) ON DELETE CASCADE not valid;
+
+alter table "public"."bsky_follows" validate constraint "bsky_follows_follows_fkey";
+
+alter table "public"."bsky_follows" add constraint "bsky_follows_identity_fkey" FOREIGN KEY (identity) REFERENCES identities(atp_did) ON DELETE CASCADE not valid;
+
+alter table "public"."bsky_follows" validate constraint "bsky_follows_identity_fkey";
+
+grant delete on table "public"."bsky_follows" to "anon";
+
+grant insert on table "public"."bsky_follows" to "anon";
+
+grant references on table "public"."bsky_follows" to "anon";
+
+grant select on table "public"."bsky_follows" to "anon";
+
+grant trigger on table "public"."bsky_follows" to "anon";
+
+grant truncate on table "public"."bsky_follows" to "anon";
+
+grant update on table "public"."bsky_follows" to "anon";
+
+grant delete on table "public"."bsky_follows" to "authenticated";
+
+grant insert on table "public"."bsky_follows" to "authenticated";
+
+grant references on table "public"."bsky_follows" to "authenticated";
+
+grant select on table "public"."bsky_follows" to "authenticated";
+
+grant trigger on table "public"."bsky_follows" to "authenticated";
+
+grant truncate on table "public"."bsky_follows" to "authenticated";
+
+grant update on table "public"."bsky_follows" to "authenticated";
+
+grant delete on table "public"."bsky_follows" to "service_role";
+
+grant insert on table "public"."bsky_follows" to "service_role";
+
+grant references on table "public"."bsky_follows" to "service_role";
+
+grant select on table "public"."bsky_follows" to "service_role";
+
+grant trigger on table "public"."bsky_follows" to "service_role";
+
+grant truncate on table "public"."bsky_follows" to "service_role";
+
+grant update on table "public"."bsky_follows" to "service_role";

supabase/migrations/20251017160632_add_indexed_at_to_document_mentions_in_bsky.sql

···
+alter table "public"."document_mentions_in_bsky" add column "indexed_at" timestamp with time zone not null default now();