Merge branch 'main' of https://github.com/hyperlink-academy/minilink into feature/email

actions/publishToPublication.ts

···
     credentialSession.did!,
   );
 
-  let existingRecord: Partial<PubLeafletDocument.Record> = {};
+  let existingRecord: Partial<SiteStandardDocument.Record> = {};
   const normalizedDoc = normalizeDocumentRecord(draft?.documents?.data);
   if (normalizedDoc) {
     // When reading existing data, use normalized format to extract fields
···
       tags: normalizedDoc.tags,
       coverImage: normalizedDoc.coverImage,
       theme: normalizedDoc.theme,
+      bskyPostRef: normalizedDoc.bskyPostRef,
     };
   }
 
···
   // Determine the rkey early since we need it for the path field
   const rkey = existingDocUri ? new AtUri(existingDocUri).rkey : TID.nextStr();
 
+  // Resolve fields: use new values if provided, otherwise preserve existing
+  const resolvedDescription =
+    description !== undefined ? description : existingRecord.description;
+  const resolvedTags = tags !== undefined ? tags : existingRecord.tags;
+  const resolvedCoverImage = coverImageBlob ?? existingRecord.coverImage;
+  const resolvedPublishedAt =
+    publishedAt || existingRecord.publishedAt || new Date().toISOString();
+
   // Create record based on the document type
   let record: PubLeafletDocument.Record | SiteStandardDocument.Record;
 
···
       title: title || "",
       site: siteUri,
       path: "/" + rkey,
-      publishedAt:
-        publishedAt || existingRecord.publishedAt || new Date().toISOString(),
-      ...(description && { description }),
-      ...(tags !== undefined && { tags }),
-      ...(coverImageBlob && { coverImage: coverImageBlob }),
+      publishedAt: resolvedPublishedAt,
+      ...(resolvedDescription !== undefined && {
+        description: resolvedDescription,
+      }),
+      ...(resolvedTags !== undefined && { tags: resolvedTags }),
+      ...(resolvedCoverImage && { coverImage: resolvedCoverImage }),
+      ...(existingRecord.bskyPostRef && {
+        bskyPostRef: existingRecord.bskyPostRef,
+      }),
       // Include theme for standalone documents (not for publication documents)
       ...(!publication_uri && theme && { theme }),
       ...(preferences && {
···
         },
       }),
       title: title || "",
-      description: description || "",
-      ...(tags !== undefined && { tags }),
-      ...(coverImageBlob && { coverImage: coverImageBlob }),
+      description: resolvedDescription || "",
+      ...(resolvedTags !== undefined && { tags: resolvedTags }),
+      ...(resolvedCoverImage && { coverImage: resolvedCoverImage }),
+      ...(existingRecord.bskyPostRef && {
+        postRef: existingRecord.bskyPostRef,
+      }),
       pages: pagesArray,
-      publishedAt:
-        publishedAt || existingRecord.publishedAt || new Date().toISOString(),
+      publishedAt: resolvedPublishedAt,
     } satisfies PubLeafletDocument.Record;
   }
 
···
         publication: publication_uri,
         title: title,
         description: description,
+        tags: resolvedTags ?? [],
+        cover_image: cover_image ?? null,
       }),
     ]);
   } else {
···
       document: result.uri,
       title: title || "",
       description: description || "",
+      tags: resolvedTags ?? [],
+      cover_image: cover_image ?? null,
     });
 
     // Heuristic: Remove title entities if this is the first time publishing standalone

app/(home-pages)/p/[didOrHandle]/ProfileHeader.tsx

···
     </div>
   );
 
-
   return (
     <div
       className={`profileHeader flex flex-col relative `}
···
             did={props.profile.did}
           />
 
-          <pre className="profileDescription pt-1 px-3 sm:px-4 whitespace-pre-wrap">
+          <pre
+            className="profileDescription pt-1 px-3 sm:px-4 whitespace-pre-wrap"
+            style={{ fontFamily: "inherit" }}
+          >
             {profileRecord.description
               ? parseDescription(profileRecord.description)
               : null}

app/[leaflet_id]/actions/PublishButton.tsx

···
 
 const UpdateButton = () => {
   let [isLoading, setIsLoading] = useState(false);
-  let { data: pub, mutate } = useLeafletPublicationData();
+  let { data: pub, mutate, normalizedDocument } = useLeafletPublicationData();
   let { permission_token, rootEntity, rep } = useReplicache();
   let { identity } = useIdentityData();
   let toaster = useToaster();
···
       : pub?.description || "";
 
   // Get tags from Replicache state (same as draft editor)
+  // Fall back to normalized document tags if Replicache hasn't pulled yet
   let tags = useSubscribe(rep, (tx) => tx.get<string[]>("publication_tags"));
-  const currentTags = Array.isArray(tags) ? tags : [];
+  const currentTags = Array.isArray(tags)
+    ? tags
+    : normalizedDocument?.tags ?? [];
 
   // Get cover image from Replicache state
   let coverImage = useSubscribe(rep, (tx) =>

app/globals.css

···
   @apply box-decoration-clone;
 }
 
-.selected .selection-highlight {
+.selection-highlight {
   background-color: Highlight;
   @apply py-[1.5px];
 }

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

···
       }
     }
 
+    let content = chunks.join("");
+    // Strip <link> preload tags injected by React SSR — they trigger
+    // security warnings in RSS validators and aren't useful in feeds.
+    content = content.replace(/<link\b[^>]*>/gi, "");
+    // Convert relative URLs to absolute so RSS readers can resolve them.
+    const baseUrl = pubRecord.url.replace(/\/$/, "");
+    content = content.replace(
+      /(src|href)="\/(?!\/)/g,
+      `$1="${baseUrl}/`,
+    );
+
     const docUrl = getDocumentURL(record, doc.documents.uri, pubRecord);
     feed.addItem({
       title: record.title,
···
       date: record.publishedAt ? new Date(record.publishedAt) : new Date(),
       id: docUrl,
       link: docUrl,
-      content: chunks.join(""),
+      content,
     });
   }
 

appview/index.ts

···
   if (evt.collection === "parts.page.mention.service") {
     if (evt.event === "create" || evt.event === "update") {
       let record = evt.record as any;
-      if (!record?.name || !record?.endpoint) return;
       let { error } = await supabase.from("mention_services").upsert({
         uri: evt.uri.toString(),
         identity_did: evt.did,

components/Blocks/Block.tsx

···
 import { focusBlock } from "src/utils/focusBlock";
 import { useHandleDrop } from "./useHandleDrop";
 import { useEntitySetContext } from "components/EntitySetProvider";
-
+import { indent, outdent } from "src/utils/list-operations";
+import { useDrag } from "@use-gesture/react";
 import { TextBlock } from "./TextBlock/index";
 import { ImageBlock } from "./ImageBlock";
 import { PageLinkBlock } from "./PageLinkBlock";
···
 import { Separator } from "components/Layout";
 import { moveBlockUp, moveBlockDown } from "src/utils/moveBlock";
 import { deleteBlock } from "src/utils/deleteBlock";
+
+const SWIPE_THRESHOLD = 50;
 
 export type Block = {
   factID: string;
···
     nextPosition: props.nextPosition,
   });
   let entity_set = useEntitySetContext();
+  let isMobile = useIsMobile();
+  let { rep } = useReplicache();
 
   let { isLongPress, longPressHandlers } = useLongPress(() => {
     if (isTextBlock[props.type]) return;
···
   // THIS IS WHERE YOU SET WHETHER OR NOT AREYOUSURE IS TRIGGERED ON THE DELETE KEY
   useBlockKeyboardHandlers(props, areYouSure, setAreYouSure);
 
+  const bindSwipe = useDrag(
+    ({ last, movement: [mx], event }) => {
+      if (!last) return;
+      if (!rep || !props.listData || !entity_set.permissions.write) return;
+      if (Math.abs(mx) < SWIPE_THRESHOLD) return;
+      event?.preventDefault();
+      let { foldedBlocks, toggleFold } = useUIState.getState();
+      if (mx > 0) {
+        if (props.previousBlock) {
+          indent(props, props.previousBlock, rep, {
+            foldedBlocks,
+            toggleFold,
+          });
+        }
+      } else {
+        outdent(props, props.previousBlock, rep, {
+          foldedBlocks,
+          toggleFold,
+        });
+      }
+    },
+    {
+      axis: "x",
+      filterTaps: true,
+      pointer: { touch: true },
+      enabled: isMobile && !!props.listData,
+    },
+  );
+
   return (
     <div
-      {...(!props.preview ? { ...mouseHandlers, ...longPressHandlers } : {})}
+      {...(!props.preview
+        ? { ...mouseHandlers, ...longPressHandlers, ...bindSwipe() }
+        : {})}
       id={
         !props.preview ? elementId.block(props.entityID).container : undefined
       }
···
         flex flex-row gap-2
         px-3 sm:px-4
         z-1 w-full
+        ${props.listData ? "touch-pan-y" : ""}
       ${alignmentStyle}
       ${
         !props.nextBlock
···
     className?: string;
   },
 ) => {
-  let isMobile = useIsMobile();
   let checklist = useEntity(props.value, "block/check-list");
   let listStyle = useEntity(props.value, "block/list-style");
   let headingLevel = useEntity(props.value, "block/heading-level")?.data.value;
···
 
   let [editingNumber, setEditingNumber] = useState(false);
   let [numberInputValue, setNumberInputValue] = useState("");
-
   useEffect(() => {
     if (!editingNumber) {
       setNumberInputValue("");
···
 
     setEditingNumber(false);
   };
+
   return (
     <div
       className={`shrink-0  flex justify-end items-center h-3 z-1

components/Blocks/TextBlock/plugins.ts

···
 import { Decoration, DecorationSet } from "prosemirror-view";
 import { Plugin } from "prosemirror-state";
+
 export const highlightSelectionPlugin = new Plugin({
   state: {
     init(_, { doc }) {
       return DecorationSet.empty;
     },
     apply(tr, oldDecorations, oldState, newState) {
+      // Skip selection-only changes to avoid DOM mutations that break
+      // native selection handle dragging. On blur, we force an update
+      // so the highlight is visible when focus moves to the toolbar.
+      if (!tr.docChanged && !tr.getMeta("updateSelectionHighlight")) {
+        return oldDecorations;
+      }
+
       let decorations = [];
 
       // Check if there's a selection
···
     },
   },
   props: {
+    handleDOMEvents: {
+      blur(view) {
+        view.dispatch(
+          view.state.tr.setMeta("updateSelectionHighlight", true),
+        );
+        return false;
+      },
+    },
     decorations(state) {
       return this.getState(state);
     },

middleware.ts

···
 import { AtUri } from "@atproto/syntax";
 import { createClient } from "@supabase/supabase-js";
+import { getCache } from "@vercel/functions";
 import { NextRequest, NextResponse } from "next/server";
 import { Database } from "supabase/database.types";
 
···
 let supabase = createClient<Database>(
   process.env.NEXT_PUBLIC_SUPABASE_API_URL as string,
   process.env.SUPABASE_SERVICE_ROLE_KEY as string,
-  {
-    global: {
-      fetch: async (...args) => {
-        const response = await fetch(args[0], {
-          ...args[1],
-          next: {
-            revalidate: 60,
-          },
-        });
-        return response;
-      },
-    },
-  },
 );
 
+const cache = getCache();
+
+async function getDomainRoutes(hostname: string) {
+  let { data } = await supabase
+    .from("custom_domains")
+    .select(
+      "*, custom_domain_routes(*), publication_domains(*, publications(*))",
+    )
+    .eq("domain", hostname)
+    .single();
+  return data;
+}
+type DomainRoutes = Awaited<ReturnType<typeof getDomainRoutes>>;
+
 const auth_callback_route = "/auth_callback";
 const receive_auth_callback_route = "/receive_auth_callback";
 export default async function middleware(req: NextRequest) {
···
 
   if (hostname === "leaflet.pub") return;
   if (req.nextUrl.pathname === "/not-found") return;
-  let { data: routes } = await supabase
-    .from("custom_domains")
-    .select(
-      "*, custom_domain_routes(*), publication_domains(*, publications(*))",
-    )
-    .eq("domain", hostname)
-    .single();
+  let routes: DomainRoutes = null;
+  try {
+    routes = (await cache.get(`domain:${hostname}`)) as DomainRoutes;
+  } catch {}
+  if (!routes) {
+    routes = await getDomainRoutes(hostname);
+    if (routes) {
+      try {
+        await cache.set(`domain:${hostname}`, routes, {
+          ttl: 60,
+          tags: [`domain:${hostname}`],
+        });
+      } catch {}
+    }
+  }
 
   let pub = routes?.publication_domains[0]?.publications;
   if (pub) {

package-lock.json

···
         "@tinybirdco/sdk": "^0.0.55",
         "@tiptap/core": "^2.11.5",
         "@types/mdx": "^2.0.13",
+        "@use-gesture/react": "^10.3.1",
         "@vercel/analytics": "^1.5.0",
         "@vercel/functions": "^2.2.12",
         "@vercel/sdk": "^1.11.4",
···
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz",
       "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ=="
+    },
+    "node_modules/@use-gesture/core": {
+      "version": "10.3.1",
+      "resolved": "https://registry.npmjs.org/@use-gesture/core/-/core-10.3.1.tgz",
+      "integrity": "sha512-WcINiDt8WjqBdUXye25anHiNxPc0VOrlT8F6LLkU6cycrOGUDyY/yyFmsg3k8i5OLvv25llc0QC45GhR/C8llw==",
+      "license": "MIT"
+    },
+    "node_modules/@use-gesture/react": {
+      "version": "10.3.1",
+      "resolved": "https://registry.npmjs.org/@use-gesture/react/-/react-10.3.1.tgz",
+      "integrity": "sha512-Yy19y6O2GJq8f7CHf7L0nxL8bf4PZCPaVOCgJrusOeFHY1LvHgYXnmnXg6N5iwAnbgbZCDjo60SiM6IPJi9C5g==",
+      "license": "MIT",
+      "dependencies": {
+        "@use-gesture/core": "10.3.1"
+      },
+      "peerDependencies": {
+        "react": ">= 16.8.0"
+      }
     },
     "node_modules/@vercel/analytics": {
       "version": "1.5.0",

package.json

···
     "@tinybirdco/sdk": "^0.0.55",
     "@tiptap/core": "^2.11.5",
     "@types/mdx": "^2.0.13",
+    "@use-gesture/react": "^10.3.1",
     "@vercel/analytics": "^1.5.0",
     "@vercel/functions": "^2.2.12",
     "@vercel/sdk": "^1.11.4",

supabase/migrations/20260325000000_add_get_leaflet_page_data.sql

···
+CREATE OR REPLACE FUNCTION public.get_leaflet_page_data(p_token_id uuid)
+RETURNS TABLE (
+  permission_token json,
+  permission_token_rights json,
+  leaflets_in_publications json,
+  leaflets_to_documents json,
+  custom_domain_routes json,
+  facts json
+)
+LANGUAGE sql STABLE
+AS $$
+WITH token AS (
+  SELECT pt.*
+  FROM permission_tokens pt
+  WHERE pt.id = p_token_id
+),
+token_rights AS (
+  SELECT json_agg(row_to_json(ptr)) AS rights, array_agg(ptr.entity_set) AS entity_sets
+  FROM permission_token_rights ptr
+  WHERE ptr.token = p_token_id
+),
+related_tokens AS (
+  SELECT array_agg(pt2.id) AS ids
+  FROM permission_token_rights ptr2
+  JOIN permission_tokens pt2 ON pt2.id = ptr2.token
+  WHERE ptr2.entity_set IN (SELECT unnest(entity_sets) FROM token_rights)
+    AND pt2.id != p_token_id
+),
+lip_direct AS (
+  SELECT json_agg(row_to_json(sub)) AS data
+  FROM (
+    SELECT lip.*,
+      row_to_json(pub) AS publications,
+      row_to_json(d) AS documents
+    FROM leaflets_in_publications lip
+    LEFT JOIN publications pub ON pub.uri = lip.publication
+    LEFT JOIN documents d ON d.uri = lip.doc
+    WHERE lip.leaflet = p_token_id
+  ) sub
+),
+lip_fallback AS (
+  SELECT json_agg(row_to_json(sub)) AS data
+  FROM (
+    SELECT lip.*,
+      row_to_json(pub) AS publications,
+      row_to_json(d) AS documents
+    FROM leaflets_in_publications lip
+    LEFT JOIN publications pub ON pub.uri = lip.publication
+    LEFT JOIN documents d ON d.uri = lip.doc
+    WHERE lip.leaflet IN (SELECT unnest(ids) FROM related_tokens)
+  ) sub
+),
+ltd_direct AS (
+  SELECT json_agg(row_to_json(sub)) AS data
+  FROM (
+    SELECT ltd.*,
+      row_to_json(doc) AS documents
+    FROM leaflets_to_documents ltd
+    LEFT JOIN documents doc ON doc.uri = ltd.document
+    WHERE ltd.leaflet = p_token_id
+  ) sub
+),
+ltd_fallback AS (
+  SELECT json_agg(row_to_json(sub)) AS data
+  FROM (
+    SELECT ltd.*,
+      row_to_json(doc) AS documents
+    FROM leaflets_to_documents ltd
+    LEFT JOIN documents doc ON doc.uri = ltd.document
+    WHERE ltd.leaflet IN (SELECT unnest(ids) FROM related_tokens)
+  ) sub
+),
+cdr AS (
+  SELECT json_agg(row_to_json(c)) AS data
+  FROM custom_domain_routes c
+  WHERE c.edit_permission_token = p_token_id
+),
+facts AS (
+  SELECT json_agg(row_to_json(f)) AS data
+  FROM get_facts((SELECT root_entity FROM token)) f
+)
+SELECT
+  row_to_json(token) AS permission_token,
+  (SELECT rights FROM token_rights) AS permission_token_rights,
+  COALESCE((SELECT data FROM lip_direct), (SELECT data FROM lip_fallback)) AS leaflets_in_publications,
+  COALESCE((SELECT data FROM ltd_direct), (SELECT data FROM ltd_fallback)) AS leaflets_to_documents,
+  (SELECT data FROM cdr) AS custom_domain_routes,
+  (SELECT data FROM facts) AS facts
+FROM token;
+$$;
+
+-- Indexes for get_leaflet_page_data query patterns
+CREATE INDEX IF NOT EXISTS leaflets_in_publications_leaflet_idx
+  ON public.leaflets_in_publications(leaflet);
+
+CREATE INDEX IF NOT EXISTS permission_token_rights_entity_set_idx
+  ON public.permission_token_rights(entity_set);
+
+CREATE INDEX IF NOT EXISTS custom_domain_routes_edit_permission_token_idx
+  ON public.custom_domain_routes(edit_permission_token);