lint

web/src/api/client.ts

···
   NotificationItem,
   Target,
   Selector,
+  HydratedLabel,
 } from "../types";
 export type { Collection } from "../types";
 
···
     if (!res.ok) return false;
     const data = await res.json();
     return data.isAdmin || false;
-  } catch (e) {
+  } catch {
     return false;
   }
 }
···
 export async function adminGetLabels(
   limit = 50,
   offset = 0,
-): Promise<{ items: any[] }> {
+): Promise<{ items: HydratedLabel[] }> {
   try {
     const res = await apiRequest(
       `/api/moderation/admin/labels?limit=${limit}&offset=${offset}`,

web/src/components/common/Card.tsx

···
   const [showReportModal, setShowReportModal] = useState(false);
   const [showEditModal, setShowEditModal] = useState(false);
   const [contentRevealed, setContentRevealed] = useState(false);
+  const [ogData, setOgData] = useState<{
+    title?: string;
+    description?: string;
+    image?: string;
+    icon?: string;
+  } | null>(null);
+  const [imgError, setImgError] = useState(false);
+  const [iconError, setIconError] = useState(false);
 
   const contentWarning = getContentWarning(item.labels, preferences);
-
-  if (contentWarning?.visibility === "hide") return null;
 
   React.useEffect(() => {
     setItem(initialItem);
···
   const isSemble =
     item.uri?.includes("network.cosmik") || item.uri?.includes("semble");
 
+  const safeUrlHostname = (url: string | null | undefined) => {
+    if (!url) return null;
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return null;
+    }
+  };
+
+  const pageUrl = item.target?.source || item.source;
+  const isBookmark = type === "bookmark";
+
+  React.useEffect(() => {
+    if (isBookmark && item.uri && !ogData && pageUrl) {
+      const fetchMetadata = async () => {
+        try {
+          const res = await fetch(
+            `/api/url-metadata?url=${encodeURIComponent(pageUrl)}`,
+          );
+          if (res.ok) {
+            const data = await res.json();
+            setOgData(data);
+          }
+        } catch (e) {
+          console.error("Failed to fetch metadata", e);
+        }
+      };
+      fetchMetadata();
+    }
+  }, [isBookmark, item.uri, pageUrl, ogData]);
+
+  if (contentWarning?.visibility === "hide") return null;
+
   const handleLike = async () => {
     const prev = { liked, likes };
     setLiked(!liked);
···
 
   const detailUrl = `/${item.author?.handle || item.author?.did}/${type}/${(item.uri || "").split("/").pop()}`;
 
-  const safeUrlHostname = (url: string | null | undefined) => {
-    if (!url) return null;
-    try {
-      return new URL(url).hostname;
-    } catch {
-      return null;
-    }
-  };
-
-  const pageUrl = item.target?.source || item.source;
   const pageTitle =
     item.target?.title ||
     item.title ||
···
         return clean.length > 60 ? clean.slice(0, 57) + "..." : clean;
       })()
     : null;
-  const isBookmark = type === "bookmark";
-
-  const [ogData, setOgData] = useState<{
-    title?: string;
-    description?: string;
-    image?: string;
-    icon?: string;
-  } | null>(null);
-
-  const [imgError, setImgError] = useState(false);
-  const [iconError, setIconError] = useState(false);
-
-  React.useEffect(() => {
-    if (isBookmark && item.uri && !ogData && pageUrl) {
-      const fetchMetadata = async () => {
-        try {
-          const res = await fetch(
-            `/api/url-metadata?url=${encodeURIComponent(pageUrl)}`,
-          );
-          if (res.ok) {
-            const data = await res.json();
-            setOgData(data);
-          }
-        } catch (e) {
-          console.error("Failed to fetch metadata", e);
-        }
-      };
-      fetchMetadata();
-    }
-  }, [isBookmark, item.uri, pageUrl, ogData]);
 
   const displayTitle =
     item.title || ogData?.title || pageTitle || "Untitled Bookmark";

web/src/components/modals/EditItemModal.tsx

···
-import React, { useState, useEffect } from "react";
+import React, { useState } from "react";
 import { X, ShieldAlert } from "lucide-react";
 import {
   updateAnnotation,
···
   type,
   onSaved,
 }: EditItemModalProps) {
+  if (!isOpen) return null;
+  return (
+    <EditItemModalContent
+      key={item.uri || item.id || JSON.stringify(item)}
+      item={item}
+      type={type}
+      onClose={onClose}
+      onSaved={onSaved}
+    />
+  );
+}
+
+function EditItemModalContent({
+  item,
+  type,
+  onClose,
+  onSaved,
+}: Omit<EditItemModalProps, "isOpen">) {
   const [text, setText] = useState(item.body?.value || "");
   const [tags, setTags] = useState<string[]>(item.tags || []);
   const [tagInput, setTagInput] = useState("");
-
   const [color, setColor] = useState(item.color || "yellow");
-
   const [title, setTitle] = useState(item.title || item.target?.title || "");
   const [description, setDescription] = useState(item.description || "");
-
   const existingLabels = (item.labels || [])
     .filter((l) => l.src === item.author?.did)
     .map((l) => l.val as ContentLabelValue);
···
   const [showLabelPicker, setShowLabelPicker] = useState(
     existingLabels.length > 0,
   );
-
   const [saving, setSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    if (isOpen) {
-      setText(item.body?.value || "");
-      setTags(item.tags || []);
-      setTagInput("");
-      setColor(item.color || "yellow");
-      setTitle(item.title || item.target?.title || "");
-      setDescription(item.description || "");
-      const labels = (item.labels || [])
-        .filter((l) => l.src === item.author?.did)
-        .map((l) => l.val as ContentLabelValue);
-      setSelfLabels(labels);
-      setShowLabelPicker(labels.length > 0);
-    }
-  }, [isOpen, item]);
-
-  if (!isOpen) return null;
 
   const addTag = () => {
     const t = tagInput.trim().toLowerCase();

web/src/types.ts

···
   name: string;
   labels: LabelDefinition[];
 }
+
+export interface HydratedLabel {
+  id: number;
+  src: string;
+  uri: string;
+  val: string;
+  createdBy: {
+    did: string;
+    handle: string;
+    displayName?: string;
+    avatar?: string;
+  };
+  createdAt: string;
+  subject?: {
+    did: string;
+    handle: string;
+    displayName?: string;
+    avatar?: string;
+  };
+}

web/src/views/core/AdminModeration.tsx

···
   adminDeleteLabel,
   adminGetLabels,
 } from "../../api/client";
-import type { ModerationReport } from "../../types";
+import type { ModerationReport, HydratedLabel } from "../../types";
 import {
   Shield,
   CheckCircle,
···
   { val: "misleading", label: "Misleading" },
 ];
 
-interface HydratedLabel {
-  id: number;
-  src: string;
-  uri: string;
-  val: string;
-  createdBy: {
-    did: string;
-    handle: string;
-    displayName?: string;
-    avatar?: string;
-  };
-  createdAt: string;
-  subject?: {
-    did: string;
-    handle: string;
-    displayName?: string;
-    avatar?: string;
-  };
-}
-
 type Tab = "reports" | "labels" | "actions";
 
 export default function AdminModeration() {
···
   const [labelSubmitting, setLabelSubmitting] = useState(false);
   const [labelSuccess, setLabelSuccess] = useState(false);
 
-  useEffect(() => {
-    const init = async () => {
-      const admin = await checkAdminAccess();
-      setIsAdmin(admin);
-      if (admin) await loadReports("pending");
-      setLoading(false);
-    };
-    init();
-  }, []);
-
   const loadReports = async (status: string) => {
     const data = await getAdminReports(status || undefined);
     setReports(data.items);
···
     const data = await adminGetLabels();
     setLabels(data.items || []);
   };
+
+  useEffect(() => {
+    const init = async () => {
+      const admin = await checkAdminAccess();
+      setIsAdmin(admin);
+      if (admin) await loadReports("pending");
+      setLoading(false);
+    };
+    init();
+  }, []);
 
   const handleTabChange = async (tab: Tab) => {
     setActiveTab(tab);

web/src/views/profile/Profile.tsx

···
   unblockUser,
   muteUser,
   unmuteUser,
+  getModerationRelationship,
 } from "../../api/client";
 import Card from "../../components/common/Card";
 import RichText from "../../components/common/RichText";
···
   Collection,
   ModerationRelationship,
   ContentLabel,
-  LabelVisibility,
 } from "../../types";
 import { useStore } from "@nanostores/react";
 import { $user } from "../../store/auth";
···
 
         if (user && user.did !== did) {
           try {
-            const { getModerationRelationship } =
-              await import("../../api/client");
             const rel = await getModerationRelationship(did);
             setModRelation(rel);
           } catch {
···
       }
     };
     if (did) loadProfile();
-  }, [did]);
+  }, [did, user]);
 
   useEffect(() => {
     loadPreferences();