add user preference to show/hide recommends

.claude/settings.local.json

···
       "mcp__primitive__pending_delegations",
       "mcp__primitive__claim_delegation",
       "mcp__primitive__tasks_update",
-      "mcp__primitive__contexts_update"
+      "mcp__primitive__contexts_update",
+      "mcp__primitive__contexts_list"
     ]
   }
 }

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

···
   preferences: {
     showComments?: boolean;
     showMentions?: boolean;
+    showRecommends?: boolean;
     showPrevNext?: boolean;
   };
   quotesCount: number | undefined;
···
         recommendsCount={props.recommendsCount}
         showComments={props.preferences.showComments !== false}
         showMentions={props.preferences.showMentions !== false}
+        showRecommends={props.preferences.showRecommends !== false}
         pageId={props.pageId}
       />
       {!props.isSubpage && (

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

···
   className?: string;
   showComments: boolean;
   showMentions: boolean;
+  showRecommends: boolean;
   pageId?: string;
 }) => {
   const {
···
   const tags = normalizedDocument.tags;
   const tagCount = tags?.length || 0;
 
-  let interactionsAvailable = props.showComments || props.showMentions;
+  let interactionsAvailable =
+    props.showComments || props.showMentions || props.showRecommends;
 
   return (
     <div
···
           <QuoteTiny aria-hidden /> {props.quotesCount}
         </button>
       )}
-      <RecommendButton
-        documentUri={document_uri}
-        recommendsCount={props.recommendsCount}
-      />
+      {props.showRecommends === false ? null : (
+        <RecommendButton
+          documentUri={document_uri}
+          recommendsCount={props.recommendsCount}
+        />
+      )}
       <Separator classname="h-4!" />
       {tagCount > 0 && <TagPopover tags={tags} tagCount={tagCount} />}
     </div>
···
   className?: string;
   showComments: boolean;
   showMentions: boolean;
+  showRecommends: boolean;
   pageId?: string;
 }) => {
   const {
···
   const tags = normalizedDocument.tags;
   const tagCount = tags?.length || 0;
 
-  let noInteractions = !props.showComments && !props.showMentions;
+  let noInteractions =
+    !props.showComments && !props.showMentions && !props.showRecommends;
 
   let subscribed =
     identity?.atp_did &&
···
         ) : (
           <>
             <div className="flex gap-2 sm:flex-row flex-col">
-              <RecommendButton
-                documentUri={document_uri}
-                recommendsCount={props.recommendsCount}
-                expanded
-              />
+              {props.showRecommends === false ? null : (
+                <RecommendButton
+                  documentUri={document_uri}
+                  recommendsCount={props.recommendsCount}
+                  expanded
+                />
+              )}
               {props.quotesCount === 0 || !props.showMentions ? null : (
                 <ButtonSecondary
                   onClick={() => {

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

···
           pageId={pageId}
           showComments={preferences.showComments !== false}
           showMentions={preferences.showMentions !== false}
+          showRecommends={preferences.showRecommends !== false}
           commentsCount={
             getCommentCount(document.comments_on_documents, pageId) || 0
           }

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

···
 export function PostHeader(props: {
   data: PostPageData;
   profile: ProfileViewDetailed;
-  preferences: { showComments?: boolean; showMentions?: boolean };
+  preferences: {
+    showComments?: boolean;
+    showMentions?: boolean;
+    showRecommends?: boolean;
+  };
 }) {
   let { identity } = useIdentityData();
   let document = props.data;
···
           <Interactions
             showComments={props.preferences.showComments !== false}
             showMentions={props.preferences.showMentions !== false}
+            showRecommends={props.preferences.showRecommends !== false}
             quotesCount={getQuoteCount(document?.quotesAndMentions || []) || 0}
             commentsCount={
               getCommentCount(document?.comments_on_documents || []) || 0

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

···
   preferences: {
     showComments?: boolean;
     showMentions?: boolean;
+    showRecommends?: boolean;
     showPrevNext?: boolean;
   };
   pubRecord?: NormalizedPublication | null;
···
   preferences: {
     showComments?: boolean;
     showMentions?: boolean;
+    showRecommends?: boolean;
     showPrevNext?: boolean;
   };
   pollData: PollData[];

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

···
               tags={doc.record.tags || []}
               showComments={pubRecord?.preferences?.showComments !== false}
               showMentions={pubRecord?.preferences?.showMentions !== false}
+              showRecommends={pubRecord?.preferences?.showRecommends !== false}
               postUrl={`${getPublicationURL(publication)}/${uri.rkey}`}
             />
           </div>

app/lish/[did]/[publication]/dashboard/settings/PostOptions.tsx

···
       ? true
       : record.preferences.showMentions,
   );
+  let [showRecommends, setShowRecommends] = useState(
+    record?.preferences?.showRecommends === undefined
+      ? true
+      : record.preferences.showRecommends,
+  );
   let [showPrevNext, setShowPrevNext] = useState(
     record?.preferences?.showPrevNext === undefined
       ? true
···
             showComments: showComments,
             showMentions: showMentions,
             showPrevNext: showPrevNext,
+            showRecommends: showRecommends,
           },
         });
         toast({ type: "success", content: <strong>Posts Updated!</strong> });
···
           <div className="flex flex-col justify-start">
             <div className="font-bold">Show Mentions</div>
             <div className="text-tertiary text-sm leading-tight">
-              Display a list of posts on Bluesky that mention your post
+              Display a list Bluesky mentions about your post
+            </div>
+          </div>
+        </Toggle>
+
+        <Toggle
+          toggle={showRecommends}
+          onToggle={() => {
+            setShowRecommends(!showRecommends);
+          }}
+        >
+          <div className="flex flex-col justify-start">
+            <div className="font-bold">Show Recommends</div>
+            <div className="text-tertiary text-sm leading-tight">
+              Allow readers to recommend/like your post
             </div>
           </div>
         </Toggle>

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

···
                             showMentions={
                               record?.preferences?.showMentions !== false
                             }
+                            showRecommends={
+                              record?.preferences?.showRecommends !== false
+                            }
                           />
                         </div>
                       </div>

app/lish/createPub/CreatePubForm.tsx

···
             showComments: true,
             showMentions: true,
             showPrevNext: true,
+            showRecommends: true,
           },
         });
 

app/lish/createPub/UpdatePubForm.tsx

···
             showComments: showComments,
             showMentions: showMentions,
             showPrevNext: showPrevNext,
+            showRecommends: record?.preferences?.showRecommends ?? true,
           },
         });
         toast({ type: "success", content: "Updated!" });
···
             </p>
           </div>
         </Toggle>
-
-        
       </div>
     </form>
   );

app/lish/createPub/createPublication.ts

···
   PubLeafletPublication,
   SiteStandardPublication,
 } from "lexicons/api";
-import {
-  restoreOAuthSession,
-  OAuthSessionError,
-} from "src/atproto-oauth";
+import { restoreOAuthSession, OAuthSessionError } from "src/atproto-oauth";
 import { getIdentityData } from "actions/getIdentityData";
 import { supabaseServerClient } from "supabase/serverClient";
 import { Json } from "supabase/database.types";
···
 
   // Build record based on publication type
   let record: SiteStandardPublication.Record | PubLeafletPublication.Record;
-  let iconBlob: Awaited<ReturnType<typeof agent.com.atproto.repo.uploadBlob>>["data"]["blob"] | undefined;
+  let iconBlob:
+    | Awaited<
+        ReturnType<typeof agent.com.atproto.repo.uploadBlob>
+      >["data"]["blob"]
+    | undefined;
 
   // Upload the icon if provided
   if (iconFile && iconFile.size > 0) {
···
       ...(iconBlob && { icon: iconBlob }),
       basicTheme: {
         $type: "site.standard.theme.basic",
-        background: { $type: "site.standard.theme.color#rgb", ...PubThemeDefaultsRGB.background },
-        foreground: { $type: "site.standard.theme.color#rgb", ...PubThemeDefaultsRGB.foreground },
-        accent: { $type: "site.standard.theme.color#rgb", ...PubThemeDefaultsRGB.accent },
-        accentForeground: { $type: "site.standard.theme.color#rgb", ...PubThemeDefaultsRGB.accentForeground },
+        background: {
+          $type: "site.standard.theme.color#rgb",
+          ...PubThemeDefaultsRGB.background,
+        },
+        foreground: {
+          $type: "site.standard.theme.color#rgb",
+          ...PubThemeDefaultsRGB.foreground,
+        },
+        accent: {
+          $type: "site.standard.theme.color#rgb",
+          ...PubThemeDefaultsRGB.accent,
+        },
+        accentForeground: {
+          $type: "site.standard.theme.color#rgb",
+          ...PubThemeDefaultsRGB.accentForeground,
+        },
       },
       preferences: {
         showInDiscover: preferences.showInDiscover,
         showComments: preferences.showComments,
         showMentions: preferences.showMentions,
         showPrevNext: preferences.showPrevNext,
+        showRecommends: preferences.showRecommends,
       },
     } satisfies SiteStandardPublication.Record;
   } else {

app/lish/createPub/updatePublication.ts

···
   }
 
   const aturi = new AtUri(existingPub.uri);
-  const publicationType = getPublicationType(aturi.collection) as PublicationType;
+  const publicationType = getPublicationType(
+    aturi.collection,
+  ) as PublicationType;
 
   // Normalize existing record
   const normalizedPub = normalizePublicationRecord(existingPub.record);
···
 }
 
 /** Merges override with existing value, respecting explicit undefined */
-function resolveField<T>(override: T | undefined, existing: T | undefined, hasOverride: boolean): T | undefined {
+function resolveField<T>(
+  override: T | undefined,
+  existing: T | undefined,
+  hasOverride: boolean,
+): T | undefined {
   return hasOverride ? override : existing;
 }
 
···
   return {
     $type: "pub.leaflet.publication",
     name: overrides.name ?? normalizedPub?.name ?? "",
-    description: resolveField(overrides.description, normalizedPub?.description, "description" in overrides),
-    icon: resolveField(overrides.icon, normalizedPub?.icon, "icon" in overrides),
-    theme: resolveField(overrides.theme, normalizedPub?.theme, "theme" in overrides),
+    description: resolveField(
+      overrides.description,
+      normalizedPub?.description,
+      "description" in overrides,
+    ),
+    icon: resolveField(
+      overrides.icon,
+      normalizedPub?.icon,
+      "icon" in overrides,
+    ),
+    theme: resolveField(
+      overrides.theme,
+      normalizedPub?.theme,
+      "theme" in overrides,
+    ),
     base_path: overrides.basePath ?? existingBasePath,
-    preferences: preferences ? {
-      $type: "pub.leaflet.publication#preferences",
-      showInDiscover: preferences.showInDiscover,
-      showComments: preferences.showComments,
-      showMentions: preferences.showMentions,
-      showPrevNext: preferences.showPrevNext,
-    } : undefined,
+    preferences: preferences
+      ? {
+          $type: "pub.leaflet.publication#preferences",
+          showInDiscover: preferences.showInDiscover,
+          showComments: preferences.showComments,
+          showMentions: preferences.showMentions,
+          showPrevNext: preferences.showPrevNext,
+          showRecommends: preferences.showRecommends,
+        }
+      : undefined,
   };
 }
 
···
   return {
     $type: "site.standard.publication",
     name: overrides.name ?? normalizedPub?.name ?? "",
-    description: resolveField(overrides.description, normalizedPub?.description, "description" in overrides),
-    icon: resolveField(overrides.icon, normalizedPub?.icon, "icon" in overrides),
-    theme: resolveField(overrides.theme, normalizedPub?.theme, "theme" in overrides),
-    basicTheme: resolveField(overrides.basicTheme, normalizedPub?.basicTheme, "basicTheme" in overrides),
+    description: resolveField(
+      overrides.description,
+      normalizedPub?.description,
+      "description" in overrides,
+    ),
+    icon: resolveField(
+      overrides.icon,
+      normalizedPub?.icon,
+      "icon" in overrides,
+    ),
+    theme: resolveField(
+      overrides.theme,
+      normalizedPub?.theme,
+      "theme" in overrides,
+    ),
+    basicTheme: resolveField(
+      overrides.basicTheme,
+      normalizedPub?.basicTheme,
+      "basicTheme" in overrides,
+    ),
     url: basePath ? `https://${basePath}` : normalizedPub?.url || "",
-    preferences: preferences ? {
-      showInDiscover: preferences.showInDiscover,
-      showComments: preferences.showComments,
-      showMentions: preferences.showMentions,
-      showPrevNext: preferences.showPrevNext,
-    } : undefined,
+    preferences: preferences
+      ? {
+          showInDiscover: preferences.showInDiscover,
+          showComments: preferences.showComments,
+          showMentions: preferences.showMentions,
+          showPrevNext: preferences.showPrevNext,
+          showRecommends: preferences.showRecommends,
+        }
+      : undefined,
   };
 }
 
···
   iconFile?: File | null;
   preferences?: Omit<PubLeafletPublication.Preferences, "$type">;
 }): Promise<UpdatePublicationResult> {
-  return withPublicationUpdate(uri, async ({ normalizedPub, existingBasePath, publicationType, agent }) => {
-    // Upload icon if provided
-    let iconBlob = normalizedPub?.icon;
-    if (iconFile && iconFile.size > 0) {
-      const buffer = await iconFile.arrayBuffer();
-      const uploadResult = await agent.com.atproto.repo.uploadBlob(
-        new Uint8Array(buffer),
-        { encoding: iconFile.type },
-      );
-      if (uploadResult.data.blob) {
-        iconBlob = uploadResult.data.blob;
+  return withPublicationUpdate(
+    uri,
+    async ({ normalizedPub, existingBasePath, publicationType, agent }) => {
+      // Upload icon if provided
+      let iconBlob = normalizedPub?.icon;
+      if (iconFile && iconFile.size > 0) {
+        const buffer = await iconFile.arrayBuffer();
+        const uploadResult = await agent.com.atproto.repo.uploadBlob(
+          new Uint8Array(buffer),
+          { encoding: iconFile.type },
+        );
+        if (uploadResult.data.blob) {
+          iconBlob = uploadResult.data.blob;
+        }
       }
-    }
 
-    return buildRecord(normalizedPub, existingBasePath, publicationType, {
-      name,
-      description,
-      icon: iconBlob,
-      preferences,
-    });
-  });
+      return buildRecord(normalizedPub, existingBasePath, publicationType, {
+        name,
+        description,
+        icon: iconBlob,
+        preferences,
+      });
+    },
+  );
 }
 
 export async function updatePublicationBasePath({
···
   uri: string;
   base_path: string;
 }): Promise<UpdatePublicationResult> {
-  return withPublicationUpdate(uri, async ({ normalizedPub, existingBasePath, publicationType }) => {
-    return buildRecord(normalizedPub, existingBasePath, publicationType, {
-      basePath: base_path,
-    });
-  });
+  return withPublicationUpdate(
+    uri,
+    async ({ normalizedPub, existingBasePath, publicationType }) => {
+      return buildRecord(normalizedPub, existingBasePath, publicationType, {
+        basePath: base_path,
+      });
+    },
+  );
 }
 
 type Color =
···
     accentText: Color;
   };
 }): Promise<UpdatePublicationResult> {
-  return withPublicationUpdate(uri, async ({ normalizedPub, existingBasePath, publicationType, agent }) => {
-    // Build theme object
-    const themeData = {
-      $type: "pub.leaflet.publication#theme" as const,
-      backgroundImage: theme.backgroundImage
-        ? {
-            $type: "pub.leaflet.theme.backgroundImage",
-            image: (
-              await agent.com.atproto.repo.uploadBlob(
-                new Uint8Array(await theme.backgroundImage.arrayBuffer()),
-                { encoding: theme.backgroundImage.type },
-              )
-            )?.data.blob,
-            width: theme.backgroundRepeat || undefined,
-            repeat: !!theme.backgroundRepeat,
-          }
-        : theme.backgroundImage === null
-          ? undefined
-          : normalizedPub?.theme?.backgroundImage,
-      backgroundColor: theme.backgroundColor
-        ? {
-            ...theme.backgroundColor,
-          }
-        : undefined,
-      pageWidth: theme.pageWidth,
-      primary: {
-        ...theme.primary,
-      },
-      pageBackground: {
-        ...theme.pageBackground,
-      },
-      showPageBackground: theme.showPageBackground,
-      accentBackground: {
-        ...theme.accentBackground,
-      },
-      accentText: {
-        ...theme.accentText,
-      },
-    };
+  return withPublicationUpdate(
+    uri,
+    async ({ normalizedPub, existingBasePath, publicationType, agent }) => {
+      // Build theme object
+      const themeData = {
+        $type: "pub.leaflet.publication#theme" as const,
+        backgroundImage: theme.backgroundImage
+          ? {
+              $type: "pub.leaflet.theme.backgroundImage",
+              image: (
+                await agent.com.atproto.repo.uploadBlob(
+                  new Uint8Array(await theme.backgroundImage.arrayBuffer()),
+                  { encoding: theme.backgroundImage.type },
+                )
+              )?.data.blob,
+              width: theme.backgroundRepeat || undefined,
+              repeat: !!theme.backgroundRepeat,
+            }
+          : theme.backgroundImage === null
+            ? undefined
+            : normalizedPub?.theme?.backgroundImage,
+        backgroundColor: theme.backgroundColor
+          ? {
+              ...theme.backgroundColor,
+            }
+          : undefined,
+        pageWidth: theme.pageWidth,
+        primary: {
+          ...theme.primary,
+        },
+        pageBackground: {
+          ...theme.pageBackground,
+        },
+        showPageBackground: theme.showPageBackground,
+        accentBackground: {
+          ...theme.accentBackground,
+        },
+        accentText: {
+          ...theme.accentText,
+        },
+      };
 
-    // Derive basicTheme from the theme colors for site.standard.publication
-    const basicTheme: NormalizedPublication["basicTheme"] = {
-      $type: "site.standard.theme.basic",
-      background: { $type: "site.standard.theme.color#rgb", r: theme.backgroundColor.r, g: theme.backgroundColor.g, b: theme.backgroundColor.b },
-      foreground: { $type: "site.standard.theme.color#rgb", r: theme.primary.r, g: theme.primary.g, b: theme.primary.b },
-      accent: { $type: "site.standard.theme.color#rgb", r: theme.accentBackground.r, g: theme.accentBackground.g, b: theme.accentBackground.b },
-      accentForeground: { $type: "site.standard.theme.color#rgb", r: theme.accentText.r, g: theme.accentText.g, b: theme.accentText.b },
-    };
+      // Derive basicTheme from the theme colors for site.standard.publication
+      const basicTheme: NormalizedPublication["basicTheme"] = {
+        $type: "site.standard.theme.basic",
+        background: {
+          $type: "site.standard.theme.color#rgb",
+          r: theme.backgroundColor.r,
+          g: theme.backgroundColor.g,
+          b: theme.backgroundColor.b,
+        },
+        foreground: {
+          $type: "site.standard.theme.color#rgb",
+          r: theme.primary.r,
+          g: theme.primary.g,
+          b: theme.primary.b,
+        },
+        accent: {
+          $type: "site.standard.theme.color#rgb",
+          r: theme.accentBackground.r,
+          g: theme.accentBackground.g,
+          b: theme.accentBackground.b,
+        },
+        accentForeground: {
+          $type: "site.standard.theme.color#rgb",
+          r: theme.accentText.r,
+          g: theme.accentText.g,
+          b: theme.accentText.b,
+        },
+      };
 
-    return buildRecord(normalizedPub, existingBasePath, publicationType, {
-      theme: themeData,
-      basicTheme,
-    });
-  });
+      return buildRecord(normalizedPub, existingBasePath, publicationType, {
+        theme: themeData,
+        basicTheme,
+      });
+    },
+  );
 }

components/InteractionsPreview.tsx

···
   postUrl: string;
   showComments: boolean;
   showMentions: boolean;
+  showRecommends: boolean;
 
   share?: boolean;
 }) => {
   let smoker = useSmoker();
   let interactionsAvailable =
     (props.quotesCount > 0 && props.showMentions) ||
-    (props.showComments !== false && props.commentsCount > 0);
+    (props.showComments !== false && props.commentsCount > 0) ||
+    (props.showRecommends !== false && props.recommendsCount > 0);
 
   const tagsCount = props.tags?.length || 0;
 
   return (
     <div className={`flex gap-2 text-tertiary text-sm  items-center`}>
-      <RecommendButton
-        documentUri={props.documentUri}
-        recommendsCount={props.recommendsCount}
-      />
+      {props.showRecommends === false ? null : (
+        <RecommendButton
+          documentUri={props.documentUri}
+          recommendsCount={props.recommendsCount}
+        />
+      )}
 
       {!props.showMentions || props.quotesCount === 0 ? null : (
         <SpeedyLink

components/PostListing.tsx

···
                 tags={tags}
                 showComments={pubRecord?.preferences?.showComments !== false}
                 showMentions={pubRecord?.preferences?.showMentions !== false}
+                showRecommends={
+                  pubRecord?.preferences?.showRecommends !== false
+                }
                 share
               />
             </div>

lexicons/api/types/pub/leaflet/publication.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../lexicons'
-import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
-import type * as PubLeafletThemeColor from './theme/color'
-import type * as PubLeafletThemeBackgroundImage from './theme/backgroundImage'
+import { type ValidationResult, BlobRef } from "@atproto/lexicon";
+import { CID } from "multiformats/cid";
+import { validate as _validate } from "../../../lexicons";
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from "../../../util";
+import type * as PubLeafletThemeColor from "./theme/color";
+import type * as PubLeafletThemeBackgroundImage from "./theme/backgroundImage";
 
 const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.publication'
+  validate = _validate;
+const id = "pub.leaflet.publication";
 
 export interface Record {
-  $type: 'pub.leaflet.publication'
-  name: string
-  base_path?: string
-  description?: string
-  icon?: BlobRef
-  theme?: Theme
-  preferences?: Preferences
-  [k: string]: unknown
+  $type: "pub.leaflet.publication";
+  name: string;
+  base_path?: string;
+  description?: string;
+  icon?: BlobRef;
+  theme?: Theme;
+  preferences?: Preferences;
+  [k: string]: unknown;
 }
 
-const hashRecord = 'main'
+const hashRecord = "main";
 
 export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord)
+  return is$typed(v, id, hashRecord);
 }
 
 export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true)
+  return validate<Record & V>(v, id, hashRecord, true);
 }
 
 export interface Preferences {
-  $type?: 'pub.leaflet.publication#preferences'
-  showInDiscover: boolean
-  showComments: boolean
-  showMentions: boolean
-  showPrevNext: boolean
+  $type?: "pub.leaflet.publication#preferences";
+  showInDiscover: boolean;
+  showComments: boolean;
+  showMentions: boolean;
+  showPrevNext: boolean;
+  showRecommends: boolean;
 }
 
-const hashPreferences = 'preferences'
+const hashPreferences = "preferences";
 
 export function isPreferences<V>(v: V) {
-  return is$typed(v, id, hashPreferences)
+  return is$typed(v, id, hashPreferences);
 }
 
 export function validatePreferences<V>(v: V) {
-  return validate<Preferences & V>(v, id, hashPreferences)
+  return validate<Preferences & V>(v, id, hashPreferences);
 }
 
 export interface Theme {
-  $type?: 'pub.leaflet.publication#theme'
+  $type?: "pub.leaflet.publication#theme";
   backgroundColor?:
     | $Typed<PubLeafletThemeColor.Rgba>
     | $Typed<PubLeafletThemeColor.Rgb>
-    | { $type: string }
-  backgroundImage?: PubLeafletThemeBackgroundImage.Main
-  pageWidth?: number
+    | { $type: string };
+  backgroundImage?: PubLeafletThemeBackgroundImage.Main;
+  pageWidth?: number;
   primary?:
     | $Typed<PubLeafletThemeColor.Rgba>
     | $Typed<PubLeafletThemeColor.Rgb>
-    | { $type: string }
+    | { $type: string };
   pageBackground?:
     | $Typed<PubLeafletThemeColor.Rgba>
     | $Typed<PubLeafletThemeColor.Rgb>
-    | { $type: string }
-  showPageBackground: boolean
+    | { $type: string };
+  showPageBackground: boolean;
   accentBackground?:
     | $Typed<PubLeafletThemeColor.Rgba>
     | $Typed<PubLeafletThemeColor.Rgb>
-    | { $type: string }
+    | { $type: string };
   accentText?:
     | $Typed<PubLeafletThemeColor.Rgba>
     | $Typed<PubLeafletThemeColor.Rgb>
-    | { $type: string }
+    | { $type: string };
 }
 
-const hashTheme = 'theme'
+const hashTheme = "theme";
 
 export function isTheme<V>(v: V) {
-  return is$typed(v, id, hashTheme)
+  return is$typed(v, id, hashTheme);
 }
 
 export function validateTheme<V>(v: V) {
-  return validate<Theme & V>(v, id, hashTheme)
+  return validate<Theme & V>(v, id, hashTheme);
 }

lexicons/api/types/site/standard/publication.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../lexicons'
-import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
-import type * as SiteStandardThemeBasic from './theme/basic'
-import type * as PubLeafletPublication from '../../pub/leaflet/publication'
+import { type ValidationResult, BlobRef } from "@atproto/lexicon";
+import { CID } from "multiformats/cid";
+import { validate as _validate } from "../../../lexicons";
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from "../../../util";
+import type * as SiteStandardThemeBasic from "./theme/basic";
+import type * as PubLeafletPublication from "../../pub/leaflet/publication";
 
 const is$typed = _is$typed,
-  validate = _validate
-const id = 'site.standard.publication'
+  validate = _validate;
+const id = "site.standard.publication";
 
 export interface Record {
-  $type: 'site.standard.publication'
-  basicTheme?: SiteStandardThemeBasic.Main
-  theme?: $Typed<PubLeafletPublication.Theme> | { $type: string }
-  description?: string
-  icon?: BlobRef
-  name: string
-  preferences?: Preferences
-  url: string
-  [k: string]: unknown
+  $type: "site.standard.publication";
+  basicTheme?: SiteStandardThemeBasic.Main;
+  theme?: $Typed<PubLeafletPublication.Theme> | { $type: string };
+  description?: string;
+  icon?: BlobRef;
+  name: string;
+  preferences?: Preferences;
+  url: string;
+  [k: string]: unknown;
 }
 
-const hashRecord = 'main'
+const hashRecord = "main";
 
 export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord)
+  return is$typed(v, id, hashRecord);
 }
 
 export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true)
+  return validate<Record & V>(v, id, hashRecord, true);
 }
 
 export interface Preferences {
-  $type?: 'site.standard.publication#preferences'
-  showInDiscover: boolean
-  showComments: boolean
-  showMentions: boolean
-  showPrevNext: boolean
+  $type?: "site.standard.publication#preferences";
+  showInDiscover: boolean;
+  showComments: boolean;
+  showMentions: boolean;
+  showPrevNext: boolean;
+  showRecommends: boolean;
 }
 
-const hashPreferences = 'preferences'
+const hashPreferences = "preferences";
 
 export function isPreferences<V>(v: V) {
-  return is$typed(v, id, hashPreferences)
+  return is$typed(v, id, hashPreferences);
 }
 
 export function validatePreferences<V>(v: V) {
-  return validate<Preferences & V>(v, id, hashPreferences)
+  return validate<Preferences & V>(v, id, hashPreferences);
 }

lexicons/pub/leaflet/publication.json

···
         "showPrevNext": {
           "type": "boolean",
           "default": true
+        },
+        "showRecommends": {
+          "type": "boolean",
+          "default": true
         }
       }
     },

lexicons/site/standard/publication.json

···
         "showPrevNext": {
           "default": false,
           "type": "boolean"
+        },
+        "showRecommends": {
+          "default": true,
+          "type": "boolean"
         }
       },
       "type": "object"

lexicons/src/normalize.ts

···
  * Checks if the record is a pub.leaflet.document
  */
 export function isLeafletDocument(
-  record: unknown
+  record: unknown,
 ): record is PubLeafletDocument.Record {
   if (!record || typeof record !== "object") return false;
   const r = record as Record<string, unknown>;
···
  * Checks if the record is a site.standard.document
  */
 export function isStandardDocument(
-  record: unknown
+  record: unknown,
 ): record is SiteStandardDocument.Record {
   if (!record || typeof record !== "object") return false;
   const r = record as Record<string, unknown>;
···
  * Checks if the record is a pub.leaflet.publication
  */
 export function isLeafletPublication(
-  record: unknown
+  record: unknown,
 ): record is PubLeafletPublication.Record {
   if (!record || typeof record !== "object") return false;
   const r = record as Record<string, unknown>;
···
  * Checks if the record is a site.standard.publication
  */
 export function isStandardPublication(
-  record: unknown
+  record: unknown,
 ): record is SiteStandardPublication.Record {
   if (!record || typeof record !== "object") return false;
   const r = record as Record<string, unknown>;
···
     | $Typed<PubLeafletThemeColor.Rgba>
     | $Typed<PubLeafletThemeColor.Rgb>
     | { $type: string }
-    | undefined
+    | undefined,
 ): { r: number; g: number; b: number } | undefined {
   if (!color || typeof color !== "object") return undefined;
   const c = color as Record<string, unknown>;
···
  * Converts a pub.leaflet theme to a site.standard.theme.basic format
  */
 export function leafletThemeToBasicTheme(
-  theme: PubLeafletPublication.Theme | undefined
+  theme: PubLeafletPublication.Theme | undefined,
 ): SiteStandardThemeBasic.Main | undefined {
   if (!theme) return undefined;
 
   const background = extractRgb(theme.backgroundColor);
-  const accent = extractRgb(theme.accentBackground) || extractRgb(theme.primary);
+  const accent =
+    extractRgb(theme.accentBackground) || extractRgb(theme.primary);
   const accentForeground = extractRgb(theme.accentText);
 
   // If we don't have the required colors, return undefined
···
  * @param uri - Optional document URI, used to extract the rkey for the path field when normalizing pub.leaflet records
  * @returns A normalized document in site.standard format, or null if invalid/unrecognized
  */
-export function normalizeDocument(record: unknown, uri?: string): NormalizedDocument | null {
+export function normalizeDocument(
+  record: unknown,
+  uri?: string,
+): NormalizedDocument | null {
   if (!record || typeof record !== "object") return null;
 
   // Pass through site.standard records directly (theme is already in correct format if present)
···
  * @returns A normalized publication in site.standard format, or null if invalid/unrecognized
  */
 export function normalizePublication(
-  record: unknown
+  record: unknown,
 ): NormalizedPublication | null {
   if (!record || typeof record !== "object") return null;
 
···
             showComments: record.preferences.showComments,
             showMentions: record.preferences.showMentions,
             showPrevNext: record.preferences.showPrevNext,
+            showRecommends: record.preferences.showRecommends,
           }
         : undefined;
 
···
  * Type guard to check if a normalized document has leaflet content
  */
 export function hasLeafletContent(
-  doc: NormalizedDocument
+  doc: NormalizedDocument,
 ): doc is NormalizedDocument & {
   content: $Typed<PubLeafletContent.Main>;
 } {
···
  * Gets the pages array from a normalized document, handling both formats
  */
 export function getDocumentPages(
-  doc: NormalizedDocument
+  doc: NormalizedDocument,
 ): PubLeafletContent.Main["pages"] | undefined {
   if (!doc.content) return undefined;
 

lexicons/src/publication.ts

···
         showComments: { type: "boolean", default: true },
         showMentions: { type: "boolean", default: true },
         showPrevNext: { type: "boolean", default: true },
+        showRecommends: { type: "boolean", default: true },
       },
     },
     theme: {