Merge pull request #719 from streamplace/v/chat-mod-lexicon

Delegated moderation lexicons

Makefile

···
 	&& PKG_CONFIG_PATH=$(PKG_CONFIG_PATH) \
 	LD_LIBRARY_PATH=$(shell realpath $(BUILDDIR))/lib \
 	CGO_LDFLAGS="-lm" \
-	bash -euo pipefail -c "go test -p 1 -timeout 300s ./pkg/... -v | tee /dev/stderr | go-junit-report -out test.xml"
+	bash -euo pipefail -c "go test -p 1 -timeout 30m ./pkg/... -v | tee /dev/stderr | go-junit-report -out test.xml"
 
 .PHONY: iroh-test
 iroh-test:

js/app/components/live-dashboard/livestream-panel.tsx

···
   Button,
   Checkbox,
   ContentMetadataForm,
+  Dashboard,
   formatHandle,
   formatHandleWithAt,
   Input,
···
   const [selectedImage, setSelectedImage] = useState<
     string | File | Blob | undefined
   >();
-  const [mode, setMode] = useState<"create" | "metadata">("create");
+  const [mode, setMode] = useState<"create" | "metadata" | "moderation">(
+    "create",
+  );
 
   const [createPost, setCreatePost] = useState(true);
   const [sendPushNotification, setSendPushNotification] = useState(true);
···
     setCreatePost(typeof livestream.record.post !== "undefined");
   }, [livestream, defaultCanonicalUrl]);
 
-  const handleModeChange = useCallback((newMode: "create" | "metadata") => {
-    setMode(newMode);
-  }, []);
+  const handleModeChange = useCallback(
+    (newMode: "create" | "metadata" | "moderation") => {
+      setMode(newMode);
+    },
+    [],
+  );
 
   const handleSubmit = useCallback(async () => {
     if (!title.trim()) return;
···
               values={[
                 { label: "Create", value: "create" },
                 { label: "Metadata", value: "metadata" },
+                { label: "Moderation", value: "moderation" },
               ]}
               style={[{ marginVertical: -2 }]}
               selectedValue={mode}
···
                 showUpdateButton={!userIsLive}
                 style={{ flex: 1, height: "100%" }}
               />
+            </View>
+          ) : mode === "moderation" ? (
+            // Moderation view
+            <View style={[flex.values[1], { minHeight: 400 }]}>
+              <Dashboard.ModeratorPanel isLive={userIsLive} embedded={true} />
             </View>
           ) : (
             // Create/Edit view

js/components/src/components/chat/mod-view.tsx

···
 import { TriggerRef, useRootContext } from "@rn-primitives/dropdown-menu";
 import { forwardRef, useEffect, useRef, useState } from "react";
 import { gap, mr, w } from "../../lib/theme/atoms";
-import { useIsMyStream, usePlayerStore } from "../../player-store";
+import { usePlayerStore } from "../../player-store";
 import {
   useCreateBlockRecord,
   useCreateHideChatRecord,
+  useUpdateLivestreamRecord,
 } from "../../streamplace-store/block";
+import {
+  ModerationPermissions,
+  useCanModerate,
+} from "../../streamplace-store/moderation";
 import { usePDSAgent } from "../../streamplace-store/xrpc";
 
 import { Linking } from "react-native";
 import { ChatMessageViewHydrated } from "streamplace";
-import { useDeleteChatMessage } from "../../livestream-store";
+import {
+  useDeleteChatMessage,
+  useLivestream,
+  useLivestreamStore,
+} from "../../livestream-store";
 import { useStreamplaceStore } from "../../streamplace-store";
 import { formatHandle, formatHandleWithAt } from "../../utils/format-handle";
 import {
   atoms,
+  Button,
+  DialogFooter,
   DropdownMenu,
   DropdownMenuGroup,
   DropdownMenuItem,
   DropdownMenuTrigger,
   layout,
+  ResponsiveDialog,
   ResponsiveDropdownMenuContent,
   Text,
+  Textarea,
   useToast,
   View,
 } from "../ui";
···
 export const ModView = forwardRef<ModViewRef, ModViewProps>(() => {
   const triggerRef = useRef<TriggerRef>(null);
   const message = usePlayerStore((state) => state.modMessage);
+  const toast = useToast();
 
   let agent = usePDSAgent();
   let [messageRemoved, setMessageRemoved] = useState(false);
   let { createBlock, isLoading: isBlockLoading } = useCreateBlockRecord();
   let { createHideChat, isLoading: isHideLoading } = useCreateHideChatRecord();
+  let { updateLivestream, isLoading: isUpdateTitleLoading } =
+    useUpdateLivestreamRecord();
+  const livestream = useLivestream();
+  const [showUpdateTitleDialog, setShowUpdateTitleDialog] = useState(false);
 
   const setReportModalOpen = usePlayerStore((x) => x.setReportModalOpen);
   const setReportSubject = usePlayerStore((x) => x.setReportSubject);
   const setModMessage = usePlayerStore((x) => x.setModMessage);
   const deleteChatMessage = useDeleteChatMessage();
-  const isMyStream = useIsMyStream();
+
+  // Get the streamer's DID from the livestream profile
+  const streamerDID = useLivestreamStore((x) => x.profile?.did);
+  // Check moderation permissions for the current user on this streamer's channel
+  const modPermissions = useCanModerate(streamerDID);
 
   // get the channel did
   const channelId = usePlayerStore((state) => state.src);
   // get the logged in user's identity
   const handle = useStreamplaceStore((state) => state.handle);
 
-  if (!agent?.did) {
-    <View style={[layout.flex.row, layout.flex.alignCenter, gap.all[2]]}>
-      <Text>Log in to submit mod actions</Text>
-    </View>;
-  }
-
   const cleanup = () => {
     setModMessage(null);
   };
 
+  // Effect must be called unconditionally (before any early returns)
   useEffect(() => {
     if (message) {
       setMessageRemoved(false);
···
     }
   }, [message]);
 
+  // Early return AFTER all hooks have been called
+  if (!agent?.did) {
+    return (
+      <View style={[layout.flex.row, layout.flex.alignCenter, gap.all[2]]}>
+        <Text>Log in to submit mod actions</Text>
+      </View>
+    );
+  }
+
+  // Can show moderation actions if user can hide, ban, or manage livestream
+  const canModerate =
+    modPermissions.canHide ||
+    modPermissions.canBan ||
+    modPermissions.canManageLivestream;
+
+  // Check if any moderation actions are actually available for this message
+  // This must match the individual action checks inside the DropdownMenuGroup
+  const hasAvailableActions = !!(
+    message &&
+    agent?.did &&
+    ((modPermissions.canHide && message.author.did !== streamerDID) ||
+      (modPermissions.canBan &&
+        message.author.did !== agent.did &&
+        message.author.did !== streamerDID))
+  );
+
   return (
-    <DropdownMenu
-      style={[layout.flex.row, layout.flex.alignCenter, gap.all[2], w[80]]}
-      onOpenChange={(isOpen) => {
-        if (!isOpen) {
-          cleanup();
-        }
-      }}
-    >
-      <DropdownMenuTrigger ref={triggerRef}>
-        {/* Hidden trigger */}
-        <View />
-      </DropdownMenuTrigger>
-      <ResponsiveDropdownMenuContent>
-        {message && (
-          <>
-            <DropdownMenuGroup>
-              <DropdownMenuItem>
-                <View
-                  style={[
-                    layout.flex.column,
-                    mr[5],
-                    { gap: 6, maxWidth: "100%" },
-                  ]}
-                >
-                  <Text
-                    style={{
-                      fontVariant: ["tabular-nums"],
-                      color: atoms.colors.gray[300],
-                    }}
-                  >
-                    {new Date(message.record.createdAt).toLocaleTimeString([], {
-                      hour: "2-digit",
-                      minute: "2-digit",
-                      hour12: false,
-                    })}{" "}
-                    {formatHandleWithAt(message.author)}: {message.record.text}
-                  </Text>
-                </View>
-              </DropdownMenuItem>
-            </DropdownMenuGroup>
+    <>
+      <DropdownMenu
+        style={[layout.flex.row, layout.flex.alignCenter, gap.all[2], w[80]]}
+        onOpenChange={(isOpen) => {
+          if (!isOpen) {
+            cleanup();
+          }
+        }}
+      >
+        <DropdownMenuTrigger ref={triggerRef}>
+          {/* Hidden trigger */}
+          <View />
+        </DropdownMenuTrigger>
+        <ResponsiveDropdownMenuContent>
+          {message && (
+            <ModViewContent
+              message={message}
+              modPermissions={modPermissions}
+              agent={agent}
+              streamerDID={streamerDID}
+              hasAvailableActions={hasAvailableActions}
+              isHideLoading={isHideLoading}
+              isBlockLoading={isBlockLoading}
+              messageRemoved={messageRemoved}
+              setMessageRemoved={setMessageRemoved}
+              createHideChat={createHideChat}
+              createBlock={createBlock}
+              toast={toast}
+              setShowUpdateTitleDialog={setShowUpdateTitleDialog}
+              isUpdateTitleLoading={isUpdateTitleLoading}
+              livestream={livestream}
+              setReportModalOpen={setReportModalOpen}
+              setReportSubject={setReportSubject}
+              deleteChatMessage={deleteChatMessage}
+            />
+          )}
+        </ResponsiveDropdownMenuContent>
+      </DropdownMenu>
+
+      {/* Update Stream Title Dialog - rendered outside dropdown */}
+      {showUpdateTitleDialog && (
+        <UpdateStreamTitleDialog
+          livestream={livestream}
+          streamerDID={streamerDID}
+          updateLivestream={updateLivestream}
+          isLoading={isUpdateTitleLoading}
+          onClose={() => setShowUpdateTitleDialog(false)}
+        />
+      )}
+    </>
+  );
+});
+
+interface ModViewContentProps {
+  message: ChatMessageViewHydrated;
+  modPermissions: ModerationPermissions;
+  agent: ReturnType<typeof usePDSAgent>;
+  streamerDID?: string;
+  hasAvailableActions: boolean;
+  isHideLoading: boolean;
+  isBlockLoading: boolean;
+  messageRemoved: boolean;
+  setMessageRemoved: (removed: boolean) => void;
+  createHideChat: (uri: string, streamerDID?: string) => Promise<any>;
+  createBlock: (did: string, streamerDID?: string) => Promise<any>;
+  toast: ReturnType<typeof useToast>;
+  setShowUpdateTitleDialog: (show: boolean) => void;
+  isUpdateTitleLoading: boolean;
+  livestream: any;
+  setReportModalOpen: (open: boolean) => void;
+  setReportSubject: (subject: any) => void;
+  deleteChatMessage: (uri: string) => Promise<any>;
+}
+
+function ModViewContent({
+  message,
+  modPermissions,
+  agent,
+  streamerDID,
+  hasAvailableActions,
+  isHideLoading,
+  isBlockLoading,
+  messageRemoved,
+  setMessageRemoved,
+  createHideChat,
+  createBlock,
+  toast,
+  setShowUpdateTitleDialog,
+  isUpdateTitleLoading,
+  livestream,
+  setReportModalOpen,
+  setReportSubject,
+  deleteChatMessage,
+}: ModViewContentProps) {
+  const { onOpenChange } = useRootContext();
 
-            {/* TODO: Checking for non-owner moderators */}
-            {isMyStream() && (
-              <DropdownMenuGroup title={`Moderation actions`}>
-                <DropdownMenuItem
-                  disabled={isHideLoading || messageRemoved}
-                  onPress={() => {
-                    if (isHideLoading || messageRemoved) return;
-                    createHideChat(message.uri)
-                      .then((r) => setMessageRemoved(true))
-                      .catch((e) => console.error(e));
-                  }}
-                >
-                  <Text
-                    color={
-                      isHideLoading || messageRemoved ? "muted" : "destructive"
-                    }
-                  >
-                    {isHideLoading
-                      ? "Removing..."
-                      : messageRemoved
-                        ? "Message removed"
-                        : "Remove this message"}
-                  </Text>
-                </DropdownMenuItem>
-                <DropdownMenuItem
-                  disabled={message.author.did === agent?.did || isBlockLoading}
-                  onPress={() => {
-                    createBlock(message.author.did)
-                      .then((r) => console.log(r))
-                      .catch((e) => console.error(e));
-                  }}
-                >
-                  {message.author.did === agent?.did ? (
-                    <Text color="muted">
-                      Block yourself (you can't block yourself)
-                    </Text>
-                  ) : (
-                    <Text color="destructive">
-                      {isBlockLoading
-                        ? "Blocking..."
-                        : `Block user ${formatHandleWithAt(message.author)} from this channel`}
-                    </Text>
-                  )}
-                </DropdownMenuItem>
-              </DropdownMenuGroup>
-            )}
+  return (
+    <>
+      <DropdownMenuGroup key="message-display">
+        <DropdownMenuItem>
+          <View
+            style={[layout.flex.column, mr[5], { gap: 6, maxWidth: "100%" }]}
+          >
+            <Text
+              style={{
+                fontVariant: ["tabular-nums"],
+                color: atoms.colors.gray[300],
+              }}
+            >
+              {new Date(message.record.createdAt).toLocaleTimeString([], {
+                hour: "2-digit",
+                minute: "2-digit",
+                hour12: false,
+              })}{" "}
+              {formatHandleWithAt(message.author)}: {message.record.text}
+            </Text>
+          </View>
+        </DropdownMenuItem>
+      </DropdownMenuGroup>
 
-            <DropdownMenuGroup title={`User actions`}>
+      {hasAvailableActions && (
+        <DropdownMenuGroup
+          key="moderation-actions"
+          title={`Moderation actions`}
+        >
+          {modPermissions.canHide && message.author.did !== streamerDID && (
+            <DropdownMenuItem
+              disabled={isHideLoading || messageRemoved}
+              onPress={() => {
+                if (isHideLoading || messageRemoved) return;
+                createHideChat(message.uri, streamerDID ?? undefined)
+                  .then((r) => setMessageRemoved(true))
+                  .catch((e) => console.error(e));
+              }}
+            >
+              <Text
+                color={isHideLoading || messageRemoved ? "muted" : "warning"}
+              >
+                {isHideLoading
+                  ? "Hiding..."
+                  : messageRemoved
+                    ? "Message hidden"
+                    : "Hide this message"}
+              </Text>
+            </DropdownMenuItem>
+          )}
+          {modPermissions.canBan &&
+            agent?.did &&
+            message.author.did !== agent.did &&
+            message.author.did !== streamerDID && (
               <DropdownMenuItem
+                disabled={isBlockLoading}
                 onPress={() => {
-                  Linking.openURL(
-                    `https://${BSKY_FRONTEND_DOMAIN}/profile/${formatHandle(message.author)}`,
-                  );
+                  if (isBlockLoading) return;
+                  createBlock(message.author.did, streamerDID ?? undefined)
+                    .then((r) => {
+                      toast.show(
+                        "User blocked",
+                        `${formatHandleWithAt(message.author)} has been blocked from this channel.`,
+                        { duration: 3 },
+                      );
+                      onOpenChange?.(false);
+                    })
+                    .catch((e) => {
+                      console.error(e);
+                      toast.show(
+                        "Error blocking user",
+                        e instanceof Error ? e.message : "Failed to block user",
+                        { duration: 5 },
+                      );
+                    });
                 }}
               >
-                <Text color="primary">View user on {BSKY_FRONTEND_DOMAIN}</Text>
+                <Text color="destructive">
+                  {isBlockLoading
+                    ? "Blocking..."
+                    : `Block user ${formatHandleWithAt(message.author)} from this channel`}
+                </Text>
               </DropdownMenuItem>
-              {message.author.did === agent?.did && (
-                <DeleteButton
-                  message={message}
-                  deleteChatMessage={deleteChatMessage}
-                />
-              )}
-              {message.author.did !== agent?.did && (
-                <ReportButton
-                  message={message}
-                  setReportModalOpen={setReportModalOpen}
-                  setReportSubject={setReportSubject}
-                />
-              )}
-            </DropdownMenuGroup>
-          </>
+            )}
+        </DropdownMenuGroup>
+      )}
+
+      {modPermissions.canManageLivestream && (
+        <DropdownMenuGroup key="stream-actions" title={`Stream actions`}>
+          <DropdownMenuItem
+            onPress={() => {
+              setShowUpdateTitleDialog(true);
+            }}
+            disabled={isUpdateTitleLoading || !livestream}
+          >
+            <Text
+              color={isUpdateTitleLoading || !livestream ? "muted" : "primary"}
+            >
+              {isUpdateTitleLoading ? "Updating..." : "Update stream title"}
+            </Text>
+          </DropdownMenuItem>
+        </DropdownMenuGroup>
+      )}
+
+      <DropdownMenuGroup key="user-actions" title={`User actions`}>
+        <DropdownMenuItem
+          onPress={() => {
+            Linking.openURL(
+              `https://${BSKY_FRONTEND_DOMAIN}/profile/${formatHandle(message.author)}`,
+            );
+          }}
+        >
+          <Text color="primary">View user on {BSKY_FRONTEND_DOMAIN}</Text>
+        </DropdownMenuItem>
+        {message.author.did === agent?.did && (
+          <DeleteButton
+            message={message}
+            deleteChatMessage={deleteChatMessage}
+            onOpenChange={onOpenChange}
+          />
+        )}
+        {message.author.did !== agent?.did && (
+          <ReportButton
+            message={message}
+            setReportModalOpen={setReportModalOpen}
+            setReportSubject={setReportSubject}
+            onOpenChange={onOpenChange}
+          />
         )}
-      </ResponsiveDropdownMenuContent>
-    </DropdownMenu>
+      </DropdownMenuGroup>
+    </>
   );
-});
+}
 
 enum DeleteState {
   None,
···
 export function DeleteButton({
   message,
   deleteChatMessage,
+  onOpenChange,
 }: {
   message: ChatMessageViewHydrated;
   deleteChatMessage: (uri: string) => Promise<any>;
+  onOpenChange?: (open: boolean) => void;
 }) {
   const [confirming, setConfirming] = useState<DeleteState>(DeleteState.None);
-  const { onOpenChange } = useRootContext();
   const toast = useToast();
   return (
     <DropdownMenuItem
···
   message,
   setReportModalOpen,
   setReportSubject,
+  onOpenChange,
 }: {
   message: ChatMessageViewHydrated;
   setReportModalOpen: (open: boolean) => void;
   setReportSubject: (subject: any) => void;
+  onOpenChange?: (open: boolean) => void;
 }) {
-  const { onOpenChange } = useRootContext();
   return (
     <DropdownMenuItem
       onPress={() => {
···
     </DropdownMenuItem>
   );
 }
+
+interface UpdateStreamTitleDialogProps {
+  livestream: any;
+  streamerDID?: string;
+  updateLivestream: (
+    livestreamUri: string,
+    title: string,
+    streamerDID?: string,
+  ) => Promise<any>;
+  isLoading: boolean;
+  onClose: () => void;
+}
+
+function UpdateStreamTitleDialog({
+  livestream,
+  streamerDID,
+  updateLivestream,
+  isLoading,
+  onClose,
+}: UpdateStreamTitleDialogProps) {
+  const [title, setTitle] = useState(livestream?.record?.title || "");
+  const [error, setError] = useState<string | null>(null);
+  const toast = useToast();
+
+  useEffect(() => {
+    if (livestream?.record?.title) {
+      setTitle(livestream.record.title);
+    }
+  }, [livestream?.record?.title]);
+
+  const handleUpdate = async () => {
+    setError(null);
+
+    if (!title.trim()) {
+      setError("Please enter a stream title");
+      return;
+    }
+
+    if (!livestream?.uri) {
+      setError("No livestream found");
+      return;
+    }
+
+    try {
+      await updateLivestream(livestream.uri, title.trim(), streamerDID);
+      toast.show(
+        "Stream title updated",
+        "The stream title has been successfully updated.",
+        { duration: 3 },
+      );
+      onClose();
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : "Failed to update stream title",
+      );
+    }
+  };
+
+  return (
+    <ResponsiveDialog
+      open={true}
+      onOpenChange={(open) => {
+        if (!open) {
+          onClose();
+          setError(null);
+          setTitle(livestream?.record?.title || "");
+        }
+      }}
+      title="Update Stream Title"
+      description="Update the title of the livestream."
+      size="md"
+      dismissible={false}
+    >
+      <View style={[{ padding: 16, paddingBottom: 0 }]}>
+        <View style={[{ marginBottom: 16 }]}>
+          <Text
+            style={[
+              { color: atoms.colors.gray[300], fontSize: 13, marginBottom: 8 },
+            ]}
+          >
+            Stream Title
+          </Text>
+          <Textarea
+            value={title}
+            onChangeText={(text) => {
+              setTitle(text);
+              setError(null);
+            }}
+            placeholder="Enter stream title..."
+            maxLength={140}
+            multiline
+            style={[
+              {
+                padding: 12,
+                borderRadius: 8,
+                backgroundColor: atoms.colors.neutral[800],
+                color: atoms.colors.white,
+                borderWidth: 1,
+                borderColor: atoms.colors.neutral[600],
+                minHeight: 100,
+                fontSize: 16,
+              },
+            ]}
+          />
+          <Text
+            style={[
+              { color: atoms.colors.gray[400], fontSize: 12, marginTop: 4 },
+            ]}
+          >
+            {title.length}/140 characters
+          </Text>
+        </View>
+
+        {error && (
+          <View
+            style={[
+              {
+                backgroundColor: atoms.colors.red[900],
+                padding: 12,
+                borderRadius: 8,
+                borderWidth: 1,
+                borderColor: atoms.colors.red[700],
+                marginBottom: 16,
+              },
+            ]}
+          >
+            <Text style={[{ color: atoms.colors.red[400], fontSize: 13 }]}>
+              {error}
+            </Text>
+          </View>
+        )}
+      </View>
+
+      <DialogFooter>
+        <Button
+          width="min"
+          variant="secondary"
+          onPress={() => {
+            onClose();
+            setError(null);
+            setTitle(livestream?.record?.title || "");
+          }}
+          disabled={isLoading}
+        >
+          <Text>Cancel</Text>
+        </Button>
+        <Button
+          variant="primary"
+          width="min"
+          onPress={handleUpdate}
+          disabled={isLoading || !title.trim()}
+        >
+          <Text>{isLoading ? "Updating..." : "Update Title"}</Text>
+        </Button>
+      </DialogFooter>
+    </ResponsiveDialog>
+  );
+}

js/components/src/components/dashboard/index.tsx

···
 export { default as Header } from "./header";
 export { default as InformationWidget } from "./information-widget";
 export { default as ModActions } from "./mod-actions";
+export { default as ModeratorPanel } from "./moderator-panel";
 export { default as Problems, ProblemsWrapperRef } from "./problems";

js/components/src/components/dashboard/moderator-panel.tsx

···
+import { Check, Shield, Trash2, UserPlus } from "lucide-react-native";
+import { useEffect, useMemo, useState } from "react";
+import { Pressable, ScrollView, Text, View } from "react-native";
+import {
+  Button,
+  Dialog,
+  DialogFooter,
+  Input,
+  ResponsiveDialog,
+  useToast,
+} from "../../components/ui";
+import { useAvatars } from "../../hooks/useAvatars";
+import { atoms } from "../../lib/theme";
+import {
+  useAddModerator,
+  useListModerators,
+  useRemoveModerator,
+} from "../../streamplace-store/moderator-management";
+import { formatHandleWithAt } from "../../utils/format-handle";
+
+const {
+  flex,
+  bg,
+  r,
+  borders,
+  p,
+  text: textStyle,
+  layout,
+  gap,
+  mb,
+  my,
+  px,
+  py,
+} = atoms;
+
+interface ModeratorPanelProps {
+  isLive?: boolean;
+  embedded?: boolean; // If true, removes outer container styling (for use inside other panels)
+}
+
+export default function ModeratorPanel({
+  isLive,
+  embedded = false,
+}: ModeratorPanelProps) {
+  const { moderators, isLoading, error, refresh } = useListModerators();
+  const [showAddDialog, setShowAddDialog] = useState(false);
+
+  // Collect all moderator DIDs for batch fetching profiles
+  const moderatorDIDs = useMemo(
+    () => moderators.map((mod) => mod.value.moderator),
+    [moderators],
+  );
+
+  const containerStyle = embedded
+    ? [flex.values[1], layout.flex.column]
+    : [
+        flex.values[1],
+        bg.neutral[900],
+        r.lg,
+        borders.width.thin,
+        borders.color.neutral[700],
+        layout.flex.column,
+      ];
+
+  return (
+    <View style={containerStyle}>
+      {/* Header */}
+      <View
+        style={[
+          layout.flex.row,
+          layout.flex.spaceBetween,
+          layout.flex.alignCenter,
+          borders.bottom.width.thin,
+          borders.bottom.color.neutral[700],
+          p[4],
+        ]}
+      >
+        <View style={[layout.flex.row, layout.flex.alignCenter, gap.all[2]]}>
+          <Shield size={18} color="#ffffff" />
+          <Text style={[textStyle.white, { fontSize: 18, fontWeight: "600" }]}>
+            Moderators
+          </Text>
+        </View>
+        <Pressable
+          onPress={() => setShowAddDialog(true)}
+          style={[
+            layout.flex.row,
+            layout.flex.alignCenter,
+            gap.all[2],
+            bg.blue[600],
+            px[3],
+            py[2],
+            r.md,
+          ]}
+        >
+          <UserPlus size={16} color="#ffffff" />
+          <Text style={[textStyle.white, { fontSize: 13, fontWeight: "500" }]}>
+            Add
+          </Text>
+        </Pressable>
+      </View>
+
+      {/* Content */}
+      <ScrollView style={[flex.values[1], p[4]]}>
+        {isLoading && moderators.length === 0 && (
+          <Text
+            style={[textStyle.gray[400], { fontSize: 14, textAlign: "center" }]}
+          >
+            Loading moderators...
+          </Text>
+        )}
+
+        {error && (
+          <View
+            style={[
+              bg.red[900],
+              p[3],
+              r.md,
+              borders.width.thin,
+              borders.color.red[700],
+            ]}
+          >
+            <Text style={[textStyle.red[400], { fontSize: 13 }]}>{error}</Text>
+          </View>
+        )}
+
+        {!isLoading && moderators.length === 0 && !error && (
+          <View style={[layout.flex.center, p[6]]}>
+            <Shield size={48} color="#6b7280" style={[mb[4]]} />
+            <Text
+              style={[
+                textStyle.gray[400],
+                { fontSize: 14, textAlign: "center", marginBottom: 8 },
+              ]}
+            >
+              No moderators yet
+            </Text>
+            <Text
+              style={[
+                textStyle.gray[500],
+                { fontSize: 12, textAlign: "center" },
+              ]}
+            >
+              Add moderators to help manage your chat
+            </Text>
+          </View>
+        )}
+
+        {moderators.map((mod, index) => (
+          <ModeratorCard
+            key={mod.rkey}
+            moderator={mod}
+            onRemove={refresh}
+            isLast={index === moderators.length - 1}
+            moderatorDIDs={moderatorDIDs}
+          />
+        ))}
+      </ScrollView>
+
+      {/* Add Moderator Dialog */}
+      <AddModeratorDialog
+        visible={showAddDialog}
+        onClose={() => setShowAddDialog(false)}
+        onSuccess={() => {
+          setShowAddDialog(false);
+          refresh();
+        }}
+      />
+    </View>
+  );
+}
+
+interface ModeratorCardProps {
+  moderator: {
+    uri: string;
+    cid: string;
+    value: {
+      moderator: string;
+      permissions: string[];
+      createdAt: string;
+      expirationTime?: string;
+    };
+    rkey: string;
+  };
+  onRemove: () => void;
+  isLast: boolean;
+  moderatorDIDs: string[]; // All moderator DIDs for batch fetching
+}
+
+function ModeratorCard({
+  moderator,
+  onRemove,
+  isLast,
+  moderatorDIDs,
+}: ModeratorCardProps) {
+  const { removeModerator, isLoading } = useRemoveModerator();
+  const [showConfirm, setShowConfirm] = useState(false);
+  const toast = useToast();
+
+  // Use useAvatars hook to batch-fetch profiles for all moderators
+  const profiles = useAvatars(moderatorDIDs);
+  const profile = profiles[moderator.value.moderator];
+
+  // Format display name using existing utility
+  const displayName = useMemo(() => {
+    if (profile) {
+      return formatHandleWithAt(profile);
+    }
+    return moderator.value.moderator; // Fall back to DID
+  }, [profile, moderator.value.moderator]);
+
+  const handleRemove = async () => {
+    try {
+      await removeModerator(moderator.rkey);
+      setShowConfirm(false);
+      toast.show(
+        "Moderator removed",
+        "The moderator has been successfully removed.",
+        { duration: 3 },
+      );
+      onRemove();
+    } catch (err) {
+      console.error("Failed to remove moderator:", err);
+      toast.show(
+        "Error removing moderator",
+        err instanceof Error ? err.message : "Failed to remove moderator",
+        { duration: 5 },
+      );
+    }
+  };
+
+  const isExpired =
+    moderator.value.expirationTime &&
+    new Date(moderator.value.expirationTime) < new Date();
+
+  return (
+    <View
+      style={[
+        layout.flex.row,
+        layout.flex.spaceBetween,
+        layout.flex.alignCenter,
+        p[3],
+        bg.neutral[800],
+        r.md,
+        !isLast && mb[2],
+        borders.width.thin,
+        borders.color.neutral[700],
+      ]}
+    >
+      <View style={[flex.values[1]]}>
+        <Text
+          style={[
+            textStyle.white,
+            { fontSize: 14, fontWeight: "500", marginBottom: 4 },
+          ]}
+          numberOfLines={1}
+        >
+          {displayName}
+        </Text>
+        <View style={[layout.flex.row, { flexWrap: "wrap" }, gap.all[1]]}>
+          {moderator.value.permissions.map((perm) => (
+            <View
+              key={perm}
+              style={[
+                bg.blue[900],
+                px[2],
+                py[1],
+                r.sm,
+                borders.width.thin,
+                borders.color.blue[700],
+              ]}
+            >
+              <Text
+                style={[
+                  textStyle.blue[300],
+                  { fontSize: 11, fontWeight: "500" },
+                ]}
+              >
+                {perm}
+              </Text>
+            </View>
+          ))}
+          {isExpired && (
+            <View
+              style={[
+                bg.red[900],
+                px[2],
+                py[1],
+                r.sm,
+                borders.width.thin,
+                borders.color.red[700],
+              ]}
+            >
+              <Text
+                style={[
+                  textStyle.red[300],
+                  { fontSize: 11, fontWeight: "500" },
+                ]}
+              >
+                Expired
+              </Text>
+            </View>
+          )}
+        </View>
+        {moderator.value.expirationTime && !isExpired && (
+          <Text style={[textStyle.gray[400], { fontSize: 11, marginTop: 4 }]}>
+            Expires:{" "}
+            {new Date(moderator.value.expirationTime).toLocaleDateString()}
+          </Text>
+        )}
+      </View>
+      <Pressable
+        onPress={() => setShowConfirm(true)}
+        disabled={isLoading}
+        style={[
+          p[2],
+          r.md,
+          bg.red[900],
+          borders.width.thin,
+          borders.color.red[700],
+          isLoading && { opacity: 0.5 },
+        ]}
+      >
+        <Trash2 size={16} color="#f87171" />
+      </Pressable>
+
+      {/* Confirm Delete Dialog */}
+      <Dialog
+        open={showConfirm}
+        onOpenChange={setShowConfirm}
+        title="Remove Moderator?"
+        description="This will revoke all moderation permissions for this user."
+        dismissible={false}
+      >
+        <DialogFooter>
+          <Button
+            variant="secondary"
+            onPress={() => setShowConfirm(false)}
+            disabled={isLoading}
+          >
+            <Text>Cancel</Text>
+          </Button>
+          <Button
+            variant="destructive"
+            onPress={handleRemove}
+            disabled={isLoading}
+          >
+            <Text>{isLoading ? "Removing..." : "Remove"}</Text>
+          </Button>
+        </DialogFooter>
+      </Dialog>
+    </View>
+  );
+}
+
+interface AddModeratorDialogProps {
+  visible: boolean;
+  onClose: () => void;
+  onSuccess: () => void;
+}
+
+function AddModeratorDialog({
+  visible,
+  onClose,
+  onSuccess,
+}: AddModeratorDialogProps) {
+  const { addModerator, isLoading } = useAddModerator();
+  const [moderatorDID, setModeratorDID] = useState("");
+  const [permissions, setPermissions] = useState({
+    ban: false,
+    hide: false,
+    "livestream.manage": false,
+  });
+  const [error, setError] = useState<string | null>(null);
+  const toast = useToast();
+
+  // Reset form when dialog closes
+  useEffect(() => {
+    if (!visible) {
+      setModeratorDID("");
+      setPermissions({ ban: false, hide: false, "livestream.manage": false });
+      setError(null);
+    }
+  }, [visible]);
+
+  // Clear error when user starts typing
+  const handleDIDChange = (text: string) => {
+    setModeratorDID(text);
+    if (error) setError(null);
+  };
+
+  const handleAdd = async () => {
+    setError(null);
+
+    if (!moderatorDID.trim()) {
+      setError("Please enter a DID or handle");
+      return;
+    }
+
+    const selectedPermissions = Object.entries(permissions)
+      .filter(([_, enabled]) => enabled)
+      .map(([perm]) => perm) as ("ban" | "hide" | "livestream.manage")[];
+
+    if (selectedPermissions.length === 0) {
+      setError("Please select at least one permission");
+      return;
+    }
+
+    try {
+      await addModerator({
+        moderatorDID: moderatorDID.trim(),
+        permissions: selectedPermissions,
+      });
+      toast.show(
+        "Moderator added",
+        "The new moderator has been added successfully.",
+        { duration: 3 },
+      );
+      onSuccess();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to add moderator");
+    }
+  };
+
+  return (
+    <ResponsiveDialog
+      open={visible}
+      onOpenChange={(open) => {
+        if (!open) onClose();
+      }}
+      title="Add Moderator"
+      description="Enter the DID or handle of the user you want to add as a moderator and select their permissions."
+      size="md"
+      dismissible={false}
+    >
+      {/* DID Input */}
+      <View style={[my[4]]}>
+        <Text style={[textStyle.gray[300], { fontSize: 13, marginBottom: 8 }]}>
+          Moderator DID or Handle
+        </Text>
+        <Input
+          value={moderatorDID}
+          onChangeText={handleDIDChange}
+          placeholder="did:plc:... or @handle.bsky.social"
+          onSubmitEditing={handleAdd}
+          returnKeyType="done"
+        />
+      </View>
+
+      {/* Permissions */}
+      <View style={[mb[4]]}>
+        <Text style={[textStyle.gray[300], { fontSize: 13, marginBottom: 8 }]}>
+          Permissions
+        </Text>
+        <View style={[gap.all[2]]}>
+          <Pressable
+            onPress={() => setPermissions((p) => ({ ...p, ban: !p.ban }))}
+            style={[
+              layout.flex.row,
+              layout.flex.alignCenter,
+              p[3],
+              r.md,
+              bg.neutral[800],
+              borders.width.thin,
+              borders.color.neutral[700],
+            ]}
+          >
+            <View
+              style={[
+                {
+                  width: 20,
+                  height: 20,
+                  borderRadius: 4,
+                },
+                borders.width.thin,
+                borders.color.neutral[600],
+                permissions.ban ? bg.blue[600] : bg.neutral[900],
+                layout.flex.center,
+                { marginRight: 12 },
+              ]}
+            >
+              {permissions.ban && <Check size={12} color="white" />}
+            </View>
+            <View>
+              <Text
+                style={[textStyle.white, { fontSize: 14, fontWeight: "500" }]}
+              >
+                Ban Users
+              </Text>
+              <Text style={[textStyle.gray[400], { fontSize: 12 }]}>
+                Block users from chat
+              </Text>
+            </View>
+          </Pressable>
+
+          <Pressable
+            onPress={() => setPermissions((p) => ({ ...p, hide: !p.hide }))}
+            style={[
+              layout.flex.row,
+              layout.flex.alignCenter,
+              p[3],
+              r.md,
+              bg.neutral[800],
+              borders.width.thin,
+              borders.color.neutral[700],
+            ]}
+          >
+            <View
+              style={[
+                {
+                  width: 20,
+                  height: 20,
+                  borderRadius: 4,
+                },
+                borders.width.thin,
+                borders.color.neutral[600],
+                permissions.hide ? bg.blue[600] : bg.neutral[900],
+                layout.flex.center,
+                { marginRight: 12 },
+              ]}
+            >
+              {permissions.hide && (
+                <Text style={[textStyle.white, { fontSize: 12 }]}>✓</Text>
+              )}
+            </View>
+            <View>
+              <Text
+                style={[textStyle.white, { fontSize: 14, fontWeight: "500" }]}
+              >
+                Hide Messages
+              </Text>
+              <Text style={[textStyle.gray[400], { fontSize: 12 }]}>
+                Hide individual chat messages
+              </Text>
+            </View>
+          </Pressable>
+
+          <Pressable
+            onPress={() =>
+              setPermissions((p) => ({
+                ...p,
+                "livestream.manage": !p["livestream.manage"],
+              }))
+            }
+            style={[
+              layout.flex.row,
+              layout.flex.alignCenter,
+              p[3],
+              r.md,
+              bg.neutral[800],
+              borders.width.thin,
+              borders.color.neutral[700],
+            ]}
+          >
+            <View
+              style={[
+                {
+                  width: 20,
+                  height: 20,
+                  borderRadius: 4,
+                },
+                borders.width.thin,
+                borders.color.neutral[600],
+                permissions["livestream.manage"]
+                  ? bg.blue[600]
+                  : bg.neutral[900],
+                layout.flex.center,
+                { marginRight: 12 },
+              ]}
+            >
+              {permissions["livestream.manage"] && (
+                <Text style={[textStyle.white, { fontSize: 12 }]}>✓</Text>
+              )}
+            </View>
+            <View>
+              <Text
+                style={[textStyle.white, { fontSize: 14, fontWeight: "500" }]}
+              >
+                Manage Livestream
+              </Text>
+              <Text style={[textStyle.gray[400], { fontSize: 12 }]}>
+                Update stream title
+              </Text>
+            </View>
+          </Pressable>
+        </View>
+      </View>
+
+      {/* Error */}
+      {error && (
+        <View
+          style={[
+            bg.red[900],
+            p[3],
+            r.md,
+            borders.width.thin,
+            borders.color.red[700],
+            mb[4],
+          ]}
+        >
+          <Text style={[textStyle.red[400], { fontSize: 13 }]}>{error}</Text>
+        </View>
+      )}
+
+      {/* Actions */}
+      <DialogFooter>
+        <Button
+          width="min"
+          variant="secondary"
+          onPress={onClose}
+          disabled={isLoading}
+        >
+          Cancel
+        </Button>
+        <Button
+          width="min"
+          variant="primary"
+          onPress={handleAdd}
+          disabled={
+            isLoading ||
+            !moderatorDID.trim() ||
+            Object.values(permissions).every((p) => !p)
+          }
+        >
+          {isLoading ? "Adding..." : "Add Moderator"}
+        </Button>
+      </DialogFooter>
+    </ResponsiveDialog>
+  );
+}

js/components/src/livestream-store/chat.tsx

···
       subject: ComAtprotoModerationCreateReport.InputSchema["subject"],
       reasonType: string,
       reason?: string,
-      // no clue about this
-      moderationSvcDid: string = "did:web:stream.place",
     ) => {
       if (!pdsAgent || !userDID) {
         throw new Error("No PDS agent or user DID found");

js/components/src/livestream-store/livestream-state.tsx

···
   ChatMessageViewHydrated,
   LivestreamViewHydrated,
   PlaceStreamDefs,
+  PlaceStreamModerationPermission,
   PlaceStreamSegment,
 } from "streamplace";
 
···
   setStreamKey: (key: string | null) => void;
   websocketConnected: boolean;
   hasReceivedSegment: boolean;
+  moderationPermissions: PlaceStreamModerationPermission.Record[];
+  setModerationPermissions: (
+    permissions: PlaceStreamModerationPermission.Record[],
+  ) => void;
 }
 
 export interface LivestreamProblem {

js/components/src/livestream-store/livestream-store.tsx

···
     problems: [],
     websocketConnected: false,
     hasReceivedSegment: false,
+    moderationPermissions: [],
+    setModerationPermissions: (perms) => set({ moderationPermissions: perms }),
   }));
 };
 

js/components/src/livestream-store/websocket-consumer.tsx

···
   PlaceStreamChatMessage,
   PlaceStreamDefs,
   PlaceStreamLivestream,
+  PlaceStreamModerationPermission,
   PlaceStreamSegment,
 } from "streamplace";
 import { SystemMessages } from "../lib/system-messages";
···
           pendingHides: newPendingHides,
         };
         state = reduceChat(state, [], [], [hiddenMessageUri]);
+      } else if (
+        PlaceStreamModerationPermission.isRecord(message) ||
+        (message &&
+          typeof message === "object" &&
+          "$type" in message &&
+          (message as { $type?: string }).$type ===
+            "place.stream.moderation.permission")
+      ) {
+        // Handle moderation permission record updates
+        // This can be a new permission or a deletion marker
+        const permRecord = message as
+          | PlaceStreamModerationPermission.Record
+          | { deleted?: boolean; rkey?: string; streamer?: string };
+
+        if ((permRecord as any).deleted) {
+          // Handle deletion: clear permissions to trigger refetch
+          // The useCanModerate hook will refetch and repopulate
+          state = {
+            ...state,
+            moderationPermissions: [],
+          };
+        } else {
+          // Handle new/updated permission: add or update in the list
+          // Use createdAt as a unique identifier since multiple records can exist for the same moderator
+          // (e.g., one record with "ban" permission, another with "hide" permission)
+          // Note: rkey would be ideal but isn't always present in the WebSocket message
+          const newPerm =
+            permRecord as PlaceStreamModerationPermission.Record & {
+              rkey?: string;
+            };
+          const existingIndex = state.moderationPermissions.findIndex((p) => {
+            const pWithRkey = p as PlaceStreamModerationPermission.Record & {
+              rkey?: string;
+            };
+            // Prefer matching by rkey if available, fall back to createdAt
+            if (newPerm.rkey && pWithRkey.rkey) {
+              return pWithRkey.rkey === newPerm.rkey;
+            }
+            return (
+              p.moderator === newPerm.moderator &&
+              p.createdAt === newPerm.createdAt
+            );
+          });
+
+          let newPermissions: PlaceStreamModerationPermission.Record[];
+          if (existingIndex >= 0) {
+            // Update existing record with same moderator AND createdAt
+            newPermissions = [...state.moderationPermissions];
+            newPermissions[existingIndex] = newPerm;
+          } else {
+            // Add new record (could be a new record for an existing moderator with different permissions)
+            newPermissions = [...state.moderationPermissions, newPerm];
+          }
+
+          state = {
+            ...state,
+            moderationPermissions: newPermissions,
+          };
+        }
       }
     }
   }

js/components/src/streamplace-store/block.tsx

···
 import { useState } from "react";
 import { usePDSAgent } from "./xrpc";
 
+/**
+ * Hook to create a block record (ban user from chat).
+ *
+ * When the caller is the stream owner (agent.did === streamerDID), creates the
+ * block record directly via ATProto writes to their repo.
+ *
+ * When the caller is a delegated moderator, uses the place.stream.moderation.createBlock
+ * XRPC endpoint which validates permissions and creates the record using the
+ * streamer's OAuth session.
+ */
 export function useCreateBlockRecord() {
   let agent = usePDSAgent();
   const [isLoading, setIsLoading] = useState(false);
 
-  const createBlock = async (subjectDID: string) => {
+  const createBlock = async (subjectDID: string, streamerDID?: string) => {
     if (!agent) {
       throw new Error("No PDS agent found");
     }
···
 
     setIsLoading(true);
     try {
-      const record: AppBskyGraphBlock.Record = {
-        $type: "app.bsky.graph.block",
+      // If no streamerDID provided or caller is the streamer, use direct ATProto write
+      if (!streamerDID || agent.did === streamerDID) {
+        const record: AppBskyGraphBlock.Record = {
+          $type: "app.bsky.graph.block",
+          subject: subjectDID,
+          createdAt: new Date().toISOString(),
+        };
+        const result = await agent.com.atproto.repo.createRecord({
+          repo: agent.did,
+          collection: "app.bsky.graph.block",
+          record,
+        });
+        return result;
+      }
+
+      // Otherwise, use delegated moderation endpoint
+      const result = await agent.place.stream.moderation.createBlock({
+        streamer: streamerDID,
         subject: subjectDID,
-        createdAt: new Date().toISOString(),
-      };
-      const result = await agent.com.atproto.repo.createRecord({
-        repo: agent.did,
-        collection: "app.bsky.graph.block",
-        record,
       });
       return result;
     } finally {
···
   return { createBlock, isLoading };
 }
 
+/**
+ * Hook to create a gate record (hide a chat message).
+ *
+ * When the caller is the stream owner (agent.did === streamerDID), creates the
+ * gate record directly via ATProto writes to their repo.
+ *
+ * When the caller is a delegated moderator, uses the place.stream.moderation.createGate
+ * XRPC endpoint which validates permissions and creates the record using the
+ * streamer's OAuth session.
+ */
 export function useCreateHideChatRecord() {
   let agent = usePDSAgent();
   const [isLoading, setIsLoading] = useState(false);
 
-  const createHideChat = async (chatMessageUri: string) => {
+  const createHideChat = async (
+    chatMessageUri: string,
+    streamerDID?: string,
+  ) => {
     if (!agent) {
       throw new Error("No PDS agent found");
     }
···
 
     setIsLoading(true);
     try {
-      const record = {
-        $type: "place.stream.chat.gate",
-        hiddenMessage: chatMessageUri,
-      };
+      // If no streamerDID provided or caller is the streamer, use direct ATProto write
+      if (!streamerDID || agent.did === streamerDID) {
+        const record = {
+          $type: "place.stream.chat.gate",
+          hiddenMessage: chatMessageUri,
+        };
+
+        const result = await agent.com.atproto.repo.createRecord({
+          repo: agent.did,
+          collection: "place.stream.chat.gate",
+          record,
+        });
+        return result;
+      }
 
-      const result = await agent.com.atproto.repo.createRecord({
-        repo: agent.did,
-        collection: "place.stream.chat.gate",
-        record,
+      // Otherwise, use delegated moderation endpoint
+      const result = await agent.place.stream.moderation.createGate({
+        streamer: streamerDID,
+        messageUri: chatMessageUri,
       });
       return result;
     } finally {
···
 
   return { createHideChat, isLoading };
 }
+
+/**
+ * Hook to update a livestream record (update stream title).
+ *
+ * When the caller is the stream owner (agent.did === streamerDID), updates the
+ * livestream record directly via ATProto writes to their repo.
+ *
+ * When the caller is a delegated moderator, uses the place.stream.moderation.updateLivestream
+ * XRPC endpoint which validates permissions and updates the record using the
+ * streamer's OAuth session.
+ */
+export function useUpdateLivestreamRecord() {
+  let agent = usePDSAgent();
+  const [isLoading, setIsLoading] = useState(false);
+
+  const updateLivestream = async (
+    livestreamUri: string,
+    title: string,
+    streamerDID?: string,
+  ) => {
+    if (!agent) {
+      throw new Error("No PDS agent found");
+    }
+
+    if (!agent.did) {
+      throw new Error("No user DID found, assuming not logged in");
+    }
+
+    setIsLoading(true);
+    try {
+      // If no streamerDID provided or caller is the streamer, use direct ATProto write
+      if (!streamerDID || agent.did === streamerDID) {
+        // Extract rkey from URI
+        const rkey = livestreamUri.split("/").pop();
+        if (!rkey) {
+          throw new Error("Invalid livestream URI");
+        }
+
+        // Get existing record to copy fields
+        const getResult = await agent.com.atproto.repo.getRecord({
+          repo: agent.did,
+          collection: "place.stream.livestream",
+          rkey,
+        });
+
+        const oldRecord = getResult.data.value as any;
+
+        // Create new record (don't edit - old records are "chapter markers")
+        // Spread entire record to preserve all fields (agent, canonicalUrl, notificationSettings, etc.)
+        const record = {
+          ...oldRecord,
+          title: title, // Override title
+          createdAt: new Date().toISOString(), // Override timestamp for new chapter marker
+        };
+
+        const result = await agent.com.atproto.repo.createRecord({
+          repo: agent.did,
+          collection: "place.stream.livestream",
+          record,
+        });
+        return result;
+      }
+
+      // Otherwise, use delegated moderation endpoint
+      const result = await agent.place.stream.moderation.updateLivestream({
+        streamer: streamerDID,
+        livestreamUri: livestreamUri,
+        title: title,
+      });
+      return result;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return { updateLivestream, isLoading };
+}

js/components/src/streamplace-store/index.tsx

···
+export * from "./block";
+export * from "./moderation";
+export * from "./moderator-management";
 export * from "./stream";
 export * from "./streamplace-store";
 export * from "./user";

js/components/src/streamplace-store/moderation.tsx

···
+import { useEffect, useState } from "react";
+import { PlaceStreamModerationPermission } from "streamplace";
+import { useLivestreamStore } from "../livestream-store/livestream-store";
+import { usePDSAgent } from "./xrpc";
+
+export interface ModerationPermissions {
+  canBan: boolean;
+  canHide: boolean;
+  canManageLivestream: boolean;
+  isOwner: boolean;
+  isLoading: boolean;
+  error: string | null;
+}
+
+/**
+ * Hook to check if the current user can moderate for a given streamer.
+ * Returns permission flags based on:
+ * - Owner: full permissions if userDID === streamerDID
+ * - Delegated: permissions from place.stream.moderation.permission records
+ */
+export function useCanModerate(
+  streamerDID: string | null | undefined,
+): ModerationPermissions {
+  const agent = usePDSAgent();
+  const userDID = agent?.did;
+
+  // Get moderation permissions from livestream store (updated via WebSocket)
+  const moderationPermissions = useLivestreamStore(
+    (state) => state.moderationPermissions,
+  );
+  const setModerationPermissions = useLivestreamStore(
+    (state) => state.setModerationPermissions,
+  );
+
+  const [isOwner, setIsOwner] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!userDID || !streamerDID) {
+      setModerationPermissions([]);
+      setIsOwner(false);
+      setError(null);
+      return;
+    }
+
+    // If user is the streamer, they have full permissions
+    if (userDID === streamerDID) {
+      setIsOwner(true);
+      setModerationPermissions([]); // Not needed for owner
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+
+    // Otherwise, fetch delegation records from the streamer's repo
+    // This initial fetch populates the store, then WebSocket updates will keep it in sync
+    const fetchDelegation = async () => {
+      if (!agent) {
+        setModerationPermissions([]);
+        setIsLoading(false);
+        return;
+      }
+
+      setIsLoading(true);
+      setError(null);
+      setIsOwner(false);
+
+      try {
+        // Use authenticated agent to list permission records from the streamer's repo
+        const result = await agent.com.atproto.repo.listRecords({
+          repo: streamerDID,
+          collection: "place.stream.moderation.permission",
+          limit: 100,
+        });
+
+        const records = result.data.records || [];
+        const permissionRecords: PlaceStreamModerationPermission.Record[] =
+          records
+            .map((r: { value: any }) => r.value)
+            .filter(
+              (v: any) => v && v.$type === "place.stream.moderation.permission",
+            );
+
+        // Store all permissions in the livestream store
+        // WebSocket updates will keep this in sync
+        setModerationPermissions(permissionRecords);
+      } catch (err) {
+        console.error("[useCanModerate] Error fetching permissions:", err);
+        setError(
+          `Could not fetch moderation permissions: ${err instanceof Error ? err.message : `Unknown error: ${err}`}`,
+        );
+        setModerationPermissions([]);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    // Fetch immediately on mount or when dependencies change
+    fetchDelegation();
+  }, [userDID, streamerDID, agent, setModerationPermissions]);
+
+  // If permissions were cleared (e.g., due to deletion), trigger a refetch
+  useEffect(() => {
+    // If permissions were cleared and we're not the owner, refetch
+    if (
+      moderationPermissions.length === 0 &&
+      !isOwner &&
+      userDID &&
+      streamerDID &&
+      agent
+    ) {
+      const fetchDelegation = async () => {
+        try {
+          const result = await agent.com.atproto.repo.listRecords({
+            repo: streamerDID,
+            collection: "place.stream.moderation.permission",
+            limit: 100,
+          });
+
+          const records = result.data.records || [];
+          const permissionRecords: PlaceStreamModerationPermission.Record[] =
+            records
+              .map((r: { value: any }) => r.value)
+              .filter(
+                (v: any) =>
+                  v && v.$type === "place.stream.moderation.permission",
+              );
+
+          setModerationPermissions(permissionRecords);
+        } catch (err) {
+          console.error("[useCanModerate] Error refetching permissions:", err);
+        }
+      };
+
+      // Small delay to avoid rapid refetches
+      const timeout = setTimeout(fetchDelegation, 100);
+      return () => clearTimeout(timeout);
+    }
+  }, [
+    moderationPermissions.length,
+    isOwner,
+    userDID,
+    streamerDID,
+    agent,
+    setModerationPermissions,
+  ]);
+
+  // Find ALL delegation records for this moderator and merge their permissions
+  const delegations = moderationPermissions.filter(
+    (perm) => perm.moderator === userDID,
+  );
+
+  // Merge permissions from all delegation records for this moderator
+  const permissions: string[] = delegations.reduce(
+    (acc: string[], delegation) => {
+      // Check if delegation has expired
+      if (delegation.expirationTime) {
+        const expiration = new Date(delegation.expirationTime);
+        if (new Date() > expiration) {
+          return acc; // Skip expired delegations
+        }
+      }
+
+      // Add all permissions from this delegation, avoiding duplicates
+      const delegationPerms = delegation.permissions || [];
+      for (const perm of delegationPerms) {
+        if (!acc.includes(perm)) {
+          acc.push(perm);
+        }
+      }
+      return acc;
+    },
+    [],
+  );
+
+  return {
+    canBan: isOwner || permissions.includes("ban"),
+    canHide: isOwner || permissions.includes("hide"),
+    canManageLivestream: isOwner || permissions.includes("livestream.manage"),
+    isOwner,
+    isLoading,
+    error,
+  };
+}

js/components/src/streamplace-store/moderator-management.tsx

···
+import { useCallback, useEffect, useState } from "react";
+import { PlaceStreamModerationPermission } from "streamplace";
+import { usePDSAgent } from "./xrpc";
+
+interface ModeratorRecord {
+  uri: string;
+  cid: string;
+  value: PlaceStreamModerationPermission.Record;
+  rkey: string;
+}
+
+interface ListModeratorsResult {
+  moderators: ModeratorRecord[];
+  isLoading: boolean;
+  error: string | null;
+  refresh: () => void;
+}
+
+/**
+ * Hook to list all moderators for the current user's stream.
+ * Fetches place.stream.moderation.permission records from the user's repo.
+ */
+export function useListModerators(): ListModeratorsResult {
+  const agent = usePDSAgent();
+  const [moderators, setModerators] = useState<ModeratorRecord[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [refreshTrigger, setRefreshTrigger] = useState(0);
+
+  const refresh = useCallback(() => {
+    setRefreshTrigger((prev) => prev + 1);
+  }, []);
+
+  useEffect(() => {
+    if (!agent?.did) {
+      setModerators([]);
+      setError(null);
+      return;
+    }
+
+    const fetchModerators = async () => {
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const result = await agent.place.stream.moderation.permission.list({
+          repo: agent.did!,
+        });
+
+        const records = result.records.map((record: any) => {
+          const rkey = record.uri.split("/").pop();
+          return {
+            uri: record.uri,
+            cid: record.cid || "",
+            value: record.value,
+            rkey: rkey || "",
+          };
+        });
+
+        setModerators(records);
+      } catch (err) {
+        setError(
+          `Failed to fetch moderators: ${err instanceof Error ? err.message : "Unknown error"}`,
+        );
+        setModerators([]);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    fetchModerators();
+  }, [agent?.did, refreshTrigger]);
+
+  return {
+    moderators,
+    isLoading,
+    error,
+    refresh,
+  };
+}
+
+interface AddModeratorParams {
+  moderatorDID: string;
+  permissions: ("ban" | "hide" | "livestream.manage")[];
+  expirationTime?: string; // ISO 8601 datetime string
+}
+
+/**
+ * Hook to add a new moderator.
+ * Creates a place.stream.moderation.permission record in the current user's repo.
+ */
+export function useAddModerator() {
+  const agent = usePDSAgent();
+  const [isLoading, setIsLoading] = useState(false);
+
+  const addModerator = async (params: AddModeratorParams) => {
+    if (!agent?.did) {
+      throw new Error("Not logged in");
+    }
+
+    if (params.permissions.length === 0) {
+      throw new Error("At least one permission must be selected");
+    }
+
+    setIsLoading(true);
+    try {
+      // Resolve handle to DID if needed
+      let moderatorDID = params.moderatorDID.trim();
+      if (!moderatorDID.startsWith("did:")) {
+        if (moderatorDID.startsWith("@")) {
+          moderatorDID = moderatorDID.substring(1); // Remove @
+        }
+        try {
+          const resolved = await agent.com.atproto.identity.resolveHandle({
+            handle: moderatorDID,
+          });
+          moderatorDID = resolved.data.did;
+        } catch (e) {
+          throw new Error(
+            `Invalid DID or handle: ${moderatorDID}. Please use a valid DID (did:plc:...) or handle (@handle.bsky.social)`,
+          );
+        }
+      }
+
+      const record: PlaceStreamModerationPermission.Record = {
+        $type: "place.stream.moderation.permission",
+        moderator: moderatorDID,
+        permissions: params.permissions,
+        createdAt: new Date().toISOString(),
+      };
+
+      if (params.expirationTime) {
+        (record as any).expirationTime = params.expirationTime;
+      }
+
+      const result = await agent.place.stream.moderation.permission.create(
+        { repo: agent.did },
+        record,
+      );
+
+      return result;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return { addModerator, isLoading };
+}
+
+/**
+ * Hook to remove a moderator.
+ * Deletes a place.stream.moderation.permission record by its rkey.
+ */
+export function useRemoveModerator() {
+  const agent = usePDSAgent();
+  const [isLoading, setIsLoading] = useState(false);
+
+  const removeModerator = async (rkey: string) => {
+    if (!agent?.did) {
+      throw new Error("Not logged in");
+    }
+
+    setIsLoading(true);
+    try {
+      await agent.place.stream.moderation.permission.delete({
+        repo: agent.did,
+        rkey,
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return { removeModerator, isLoading };
+}

js/docs/src/content/docs/lex-reference/livestream/place-stream-livestream-update.md

···
+---
+title: place.stream.livestream.update
+description: Reference for the place.stream.livestream.update lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `procedure`
+
+Update livestream metadata on behalf of a streamer. Requires 'livestream.manage'
+permission. Updates a place.stream.livestream record in the streamer's
+repository.
+
+**Parameters:** _(None defined)_
+
+**Input:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name            | Type     | Req'd | Description                                    | Constraints                             |
+| --------------- | -------- | ----- | ---------------------------------------------- | --------------------------------------- |
+| `streamer`      | `string` | ✅    | The DID of the streamer.                       | Format: `did`                           |
+| `livestreamUri` | `string` | ✅    | The AT-URI of the livestream record to update. | Format: `at-uri`                        |
+| `title`         | `string` | ❌    | New title for the livestream.                  | Max Length: 1400<br/>Max Graphemes: 140 |
+
+**Output:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name  | Type     | Req'd | Description                                  | Constraints      |
+| ----- | -------- | ----- | -------------------------------------------- | ---------------- |
+| `uri` | `string` | ✅    | The AT-URI of the updated livestream record. | Format: `at-uri` |
+| `cid` | `string` | ✅    | The CID of the updated livestream record.    | Format: `cid`    |
+
+**Possible Errors:**
+
+- `Unauthorized`: The request lacks valid authentication credentials.
+- `Forbidden`: The caller does not have permission to update livestream metadata
+  for this streamer.
+- `SessionNotFound`: The streamer's OAuth session could not be found or is
+  invalid.
+- `RecordNotFound`: The specified livestream record does not exist.
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.livestream.update",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Update livestream metadata on behalf of a streamer. Requires 'livestream.manage' permission. Updates a place.stream.livestream record in the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "livestreamUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "livestreamUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the livestream record to update."
+            },
+            "title": {
+              "type": "string",
+              "maxLength": 1400,
+              "maxGraphemes": 140,
+              "description": "New title for the livestream."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the updated livestream record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the updated livestream record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to update livestream metadata for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        },
+        {
+          "name": "RecordNotFound",
+          "description": "The specified livestream record does not exist."
+        }
+      ]
+    }
+  }
+}
+```

js/docs/src/content/docs/lex-reference/moderation/place-stream-moderation-createblock.md

···
+---
+title: place.stream.moderation.createBlock
+description: Reference for the place.stream.moderation.createBlock lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `procedure`
+
+Create a block (ban) on behalf of a streamer. Requires 'ban' permission. Creates
+an app.bsky.graph.block record in the streamer's repository.
+
+**Parameters:** _(None defined)_
+
+**Input:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name       | Type     | Req'd | Description                                               | Constraints     |
+| ---------- | -------- | ----- | --------------------------------------------------------- | --------------- |
+| `streamer` | `string` | ✅    | The DID of the streamer whose chat this block applies to. | Format: `did`   |
+| `subject`  | `string` | ✅    | The DID of the user being blocked from chat.              | Format: `did`   |
+| `reason`   | `string` | ❌    | Optional reason for the block.                            | Max Length: 300 |
+
+**Output:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name  | Type     | Req'd | Description                             | Constraints      |
+| ----- | -------- | ----- | --------------------------------------- | ---------------- |
+| `uri` | `string` | ✅    | The AT-URI of the created block record. | Format: `at-uri` |
+| `cid` | `string` | ✅    | The CID of the created block record.    | Format: `cid`    |
+
+**Possible Errors:**
+
+- `Unauthorized`: The request lacks valid authentication credentials.
+- `Forbidden`: The caller does not have permission to create blocks for this
+  streamer.
+- `SessionNotFound`: The streamer's OAuth session could not be found or is
+  invalid.
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.createBlock",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a block (ban) on behalf of a streamer. Requires 'ban' permission. Creates an app.bsky.graph.block record in the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "subject"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer whose chat this block applies to."
+            },
+            "subject": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the user being blocked from chat."
+            },
+            "reason": {
+              "type": "string",
+              "maxLength": 300,
+              "description": "Optional reason for the block."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the created block record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the created block record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to create blocks for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}
+```

js/docs/src/content/docs/lex-reference/moderation/place-stream-moderation-creategate.md

···
+---
+title: place.stream.moderation.createGate
+description: Reference for the place.stream.moderation.createGate lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `procedure`
+
+Create a gate (hide message) on behalf of a streamer. Requires 'hide'
+permission. Creates a place.stream.chat.gate record in the streamer's
+repository.
+
+**Parameters:** _(None defined)_
+
+**Input:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name         | Type     | Req'd | Description                             | Constraints      |
+| ------------ | -------- | ----- | --------------------------------------- | ---------------- |
+| `streamer`   | `string` | ✅    | The DID of the streamer.                | Format: `did`    |
+| `messageUri` | `string` | ✅    | The AT-URI of the chat message to hide. | Format: `at-uri` |
+
+**Output:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name  | Type     | Req'd | Description                            | Constraints      |
+| ----- | -------- | ----- | -------------------------------------- | ---------------- |
+| `uri` | `string` | ✅    | The AT-URI of the created gate record. | Format: `at-uri` |
+| `cid` | `string` | ✅    | The CID of the created gate record.    | Format: `cid`    |
+
+**Possible Errors:**
+
+- `Unauthorized`: The request lacks valid authentication credentials.
+- `Forbidden`: The caller does not have permission to hide messages for this
+  streamer.
+- `SessionNotFound`: The streamer's OAuth session could not be found or is
+  invalid.
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.createGate",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a gate (hide message) on behalf of a streamer. Requires 'hide' permission. Creates a place.stream.chat.gate record in the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "messageUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "messageUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the chat message to hide."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the created gate record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the created gate record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to hide messages for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}
+```

js/docs/src/content/docs/lex-reference/moderation/place-stream-moderation-defs.md

···
+---
+title: place.stream.moderation.defs
+description: Reference for the place.stream.moderation.defs lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="permissionview"></a>
+
+### `permissionView`
+
+**Type:** `object`
+
+**Properties:**
+
+| Name     | Type                                                                                                                                             | Req'd | Description                                 | Constraints      |
+| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ----- | ------------------------------------------- | ---------------- |
+| `uri`    | `string`                                                                                                                                         | ✅    | AT-URI of the permission record             | Format: `at-uri` |
+| `cid`    | `string`                                                                                                                                         | ✅    | Content identifier of the permission record | Format: `cid`    |
+| `author` | [`app.bsky.actor.defs#profileViewBasic`](https://github.com/bluesky-social/atproto/tree/main/lexicons/app/bsky/actor/defs.json#profileViewBasic) | ✅    | The streamer who granted these permissions  |                  |
+| `record` | `unknown`                                                                                                                                        | ✅    | The permission record itself                |                  |
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.defs",
+  "defs": {
+    "permissionView": {
+      "type": "object",
+      "required": ["uri", "cid", "author", "record"],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri",
+          "description": "AT-URI of the permission record"
+        },
+        "cid": {
+          "type": "string",
+          "format": "cid",
+          "description": "Content identifier of the permission record"
+        },
+        "author": {
+          "type": "ref",
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "description": "The streamer who granted these permissions"
+        },
+        "record": {
+          "type": "unknown",
+          "description": "The permission record itself"
+        }
+      }
+    }
+  }
+}
+```

js/docs/src/content/docs/lex-reference/moderation/place-stream-moderation-deleteblock.md

···
+---
+title: place.stream.moderation.deleteBlock
+description: Reference for the place.stream.moderation.deleteBlock lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `procedure`
+
+Delete a block (unban) on behalf of a streamer. Requires 'ban' permission.
+Deletes an app.bsky.graph.block record from the streamer's repository.
+
+**Parameters:** _(None defined)_
+
+**Input:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name       | Type     | Req'd | Description                               | Constraints      |
+| ---------- | -------- | ----- | ----------------------------------------- | ---------------- |
+| `streamer` | `string` | ✅    | The DID of the streamer.                  | Format: `did`    |
+| `blockUri` | `string` | ✅    | The AT-URI of the block record to delete. | Format: `at-uri` |
+
+**Output:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+_(No properties defined)_ **Possible Errors:**
+
+- `Unauthorized`: The request lacks valid authentication credentials.
+- `Forbidden`: The caller does not have permission to delete blocks for this
+  streamer.
+- `SessionNotFound`: The streamer's OAuth session could not be found or is
+  invalid.
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.deleteBlock",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a block (unban) on behalf of a streamer. Requires 'ban' permission. Deletes an app.bsky.graph.block record from the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "blockUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "blockUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the block record to delete."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {}
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to delete blocks for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}
+```

js/docs/src/content/docs/lex-reference/moderation/place-stream-moderation-deletegate.md

···
+---
+title: place.stream.moderation.deleteGate
+description: Reference for the place.stream.moderation.deleteGate lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `procedure`
+
+Delete a gate (unhide message) on behalf of a streamer. Requires 'hide'
+permission. Deletes a place.stream.chat.gate record from the streamer's
+repository.
+
+**Parameters:** _(None defined)_
+
+**Input:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name       | Type     | Req'd | Description                              | Constraints      |
+| ---------- | -------- | ----- | ---------------------------------------- | ---------------- |
+| `streamer` | `string` | ✅    | The DID of the streamer.                 | Format: `did`    |
+| `gateUri`  | `string` | ✅    | The AT-URI of the gate record to delete. | Format: `at-uri` |
+
+**Output:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+_(No properties defined)_ **Possible Errors:**
+
+- `Unauthorized`: The request lacks valid authentication credentials.
+- `Forbidden`: The caller does not have permission to unhide messages for this
+  streamer.
+- `SessionNotFound`: The streamer's OAuth session could not be found or is
+  invalid.
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.deleteGate",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a gate (unhide message) on behalf of a streamer. Requires 'hide' permission. Deletes a place.stream.chat.gate record from the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "gateUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "gateUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the gate record to delete."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {}
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to unhide messages for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}
+```

js/docs/src/content/docs/lex-reference/moderation/place-stream-moderation-permission.md

···
+---
+title: place.stream.moderation.permission
+description: Reference for the place.stream.moderation.permission lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `record`
+
+Record granting moderation permissions to a user for this streamer's content.
+
+**Record Key:** `tid`
+
+**Record Properties:**
+
+| Name             | Type              | Req'd | Description                                                                                                                                                                                | Constraints        |
+| ---------------- | ----------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ |
+| `moderator`      | `string`          | ✅    | The DID of the user granted moderator permissions.                                                                                                                                         | Format: `did`      |
+| `permissions`    | Array of `string` | ✅    | Array of permissions granted to this moderator. 'ban' covers blocks/bans (with optional expiration), 'hide' covers message gates, 'livestream.manage' allows updating livestream metadata. |                    |
+| `createdAt`      | `string`          | ✅    | Client-declared timestamp when this moderator was added.                                                                                                                                   | Format: `datetime` |
+| `expirationTime` | `string`          | ❌    | Optional expiration time for this delegation. If set, the delegation is invalid after this time.                                                                                           | Format: `datetime` |
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.permission",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "description": "Record granting moderation permissions to a user for this streamer's content.",
+      "record": {
+        "type": "object",
+        "required": ["moderator", "permissions", "createdAt"],
+        "properties": {
+          "moderator": {
+            "type": "string",
+            "format": "did",
+            "description": "The DID of the user granted moderator permissions."
+          },
+          "permissions": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": ["ban", "hide", "livestream.manage"]
+            },
+            "description": "Array of permissions granted to this moderator. 'ban' covers blocks/bans (with optional expiration), 'hide' covers message gates, 'livestream.manage' allows updating livestream metadata."
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Client-declared timestamp when this moderator was added."
+          },
+          "expirationTime": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Optional expiration time for this delegation. If set, the delegation is invalid after this time."
+          }
+        }
+      }
+    }
+  }
+}
+```

js/docs/src/content/docs/lex-reference/moderation/place-stream-moderation-updatelivestream.md

···
+---
+title: place.stream.moderation.updateLivestream
+description: Reference for the place.stream.moderation.updateLivestream lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `procedure`
+
+Update livestream metadata on behalf of a streamer. Requires 'livestream.manage'
+permission. Updates a place.stream.livestream record in the streamer's
+repository.
+
+**Parameters:** _(None defined)_
+
+**Input:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name            | Type     | Req'd | Description                                    | Constraints                             |
+| --------------- | -------- | ----- | ---------------------------------------------- | --------------------------------------- |
+| `streamer`      | `string` | ✅    | The DID of the streamer.                       | Format: `did`                           |
+| `livestreamUri` | `string` | ✅    | The AT-URI of the livestream record to update. | Format: `at-uri`                        |
+| `title`         | `string` | ❌    | New title for the livestream.                  | Max Length: 1400<br/>Max Graphemes: 140 |
+
+**Output:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name  | Type     | Req'd | Description                                  | Constraints      |
+| ----- | -------- | ----- | -------------------------------------------- | ---------------- |
+| `uri` | `string` | ✅    | The AT-URI of the updated livestream record. | Format: `at-uri` |
+| `cid` | `string` | ✅    | The CID of the updated livestream record.    | Format: `cid`    |
+
+**Possible Errors:**
+
+- `Unauthorized`: The request lacks valid authentication credentials.
+- `Forbidden`: The caller does not have permission to update livestream metadata
+  for this streamer.
+- `SessionNotFound`: The streamer's OAuth session could not be found or is
+  invalid.
+- `RecordNotFound`: The specified livestream record does not exist.
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.updateLivestream",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Update livestream metadata on behalf of a streamer. Requires 'livestream.manage' permission. Updates a place.stream.livestream record in the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "livestreamUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "livestreamUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the livestream record to update."
+            },
+            "title": {
+              "type": "string",
+              "maxLength": 1400,
+              "maxGraphemes": 140,
+              "description": "New title for the livestream."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the updated livestream record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the updated livestream record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to update livestream metadata for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        },
+        {
+          "name": "RecordNotFound",
+          "description": "The specified livestream record does not exist."
+        }
+      ]
+    }
+  }
+}
+```

js/docs/src/content/docs/lex-reference/openapi.json

···
         }
       }
     },
+    "/xrpc/place.stream.moderation.createBlock": {
+      "post": {
+        "summary": "Create a block (ban) on behalf of a streamer. Requires 'ban' permission. Creates an app.bsky.graph.block record in the streamer's repository.",
+        "operationId": "place.stream.moderation.createBlock",
+        "tags": ["place.stream.moderation"],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "uri": {
+                      "type": "string",
+                      "description": "The AT-URI of the created block record.",
+                      "format": "uri"
+                    },
+                    "cid": {
+                      "type": "string",
+                      "description": "The CID of the created block record.",
+                      "format": "cid"
+                    }
+                  },
+                  "required": ["uri", "cid"]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "required": ["error", "message"],
+                  "properties": {
+                    "error": {
+                      "type": "string",
+                      "oneOf": [
+                        {
+                          "const": "Unauthorized"
+                        },
+                        {
+                          "const": "Forbidden"
+                        },
+                        {
+                          "const": "SessionNotFound"
+                        }
+                      ]
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "streamer": {
+                    "type": "string",
+                    "description": "The DID of the streamer whose chat this block applies to.",
+                    "format": "did"
+                  },
+                  "subject": {
+                    "type": "string",
+                    "description": "The DID of the user being blocked from chat.",
+                    "format": "did"
+                  },
+                  "reason": {
+                    "type": "string",
+                    "description": "Optional reason for the block.",
+                    "maxLength": 300
+                  }
+                },
+                "required": ["streamer", "subject"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "/xrpc/place.stream.moderation.createGate": {
+      "post": {
+        "summary": "Create a gate (hide message) on behalf of a streamer. Requires 'hide' permission. Creates a place.stream.chat.gate record in the streamer's repository.",
+        "operationId": "place.stream.moderation.createGate",
+        "tags": ["place.stream.moderation"],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "uri": {
+                      "type": "string",
+                      "description": "The AT-URI of the created gate record.",
+                      "format": "uri"
+                    },
+                    "cid": {
+                      "type": "string",
+                      "description": "The CID of the created gate record.",
+                      "format": "cid"
+                    }
+                  },
+                  "required": ["uri", "cid"]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "required": ["error", "message"],
+                  "properties": {
+                    "error": {
+                      "type": "string",
+                      "oneOf": [
+                        {
+                          "const": "Unauthorized"
+                        },
+                        {
+                          "const": "Forbidden"
+                        },
+                        {
+                          "const": "SessionNotFound"
+                        }
+                      ]
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "streamer": {
+                    "type": "string",
+                    "description": "The DID of the streamer.",
+                    "format": "did"
+                  },
+                  "messageUri": {
+                    "type": "string",
+                    "description": "The AT-URI of the chat message to hide.",
+                    "format": "uri"
+                  }
+                },
+                "required": ["streamer", "messageUri"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "/xrpc/place.stream.moderation.deleteBlock": {
+      "post": {
+        "summary": "Delete a block (unban) on behalf of a streamer. Requires 'ban' permission. Deletes an app.bsky.graph.block record from the streamer's repository.",
+        "operationId": "place.stream.moderation.deleteBlock",
+        "tags": ["place.stream.moderation"],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {}
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "required": ["error", "message"],
+                  "properties": {
+                    "error": {
+                      "type": "string",
+                      "oneOf": [
+                        {
+                          "const": "Unauthorized"
+                        },
+                        {
+                          "const": "Forbidden"
+                        },
+                        {
+                          "const": "SessionNotFound"
+                        }
+                      ]
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "streamer": {
+                    "type": "string",
+                    "description": "The DID of the streamer.",
+                    "format": "did"
+                  },
+                  "blockUri": {
+                    "type": "string",
+                    "description": "The AT-URI of the block record to delete.",
+                    "format": "uri"
+                  }
+                },
+                "required": ["streamer", "blockUri"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "/xrpc/place.stream.moderation.deleteGate": {
+      "post": {
+        "summary": "Delete a gate (unhide message) on behalf of a streamer. Requires 'hide' permission. Deletes a place.stream.chat.gate record from the streamer's repository.",
+        "operationId": "place.stream.moderation.deleteGate",
+        "tags": ["place.stream.moderation"],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {}
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "required": ["error", "message"],
+                  "properties": {
+                    "error": {
+                      "type": "string",
+                      "oneOf": [
+                        {
+                          "const": "Unauthorized"
+                        },
+                        {
+                          "const": "Forbidden"
+                        },
+                        {
+                          "const": "SessionNotFound"
+                        }
+                      ]
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "streamer": {
+                    "type": "string",
+                    "description": "The DID of the streamer.",
+                    "format": "did"
+                  },
+                  "gateUri": {
+                    "type": "string",
+                    "description": "The AT-URI of the gate record to delete.",
+                    "format": "uri"
+                  }
+                },
+                "required": ["streamer", "gateUri"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "/xrpc/place.stream.moderation.updateLivestream": {
+      "post": {
+        "summary": "Update livestream metadata on behalf of a streamer. Requires 'livestream.manage' permission. Updates a place.stream.livestream record in the streamer's repository.",
+        "operationId": "place.stream.moderation.updateLivestream",
+        "tags": ["place.stream.moderation"],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "uri": {
+                      "type": "string",
+                      "description": "The AT-URI of the updated livestream record.",
+                      "format": "uri"
+                    },
+                    "cid": {
+                      "type": "string",
+                      "description": "The CID of the updated livestream record.",
+                      "format": "cid"
+                    }
+                  },
+                  "required": ["uri", "cid"]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "required": ["error", "message"],
+                  "properties": {
+                    "error": {
+                      "type": "string",
+                      "oneOf": [
+                        {
+                          "const": "Unauthorized"
+                        },
+                        {
+                          "const": "Forbidden"
+                        },
+                        {
+                          "const": "SessionNotFound"
+                        },
+                        {
+                          "const": "RecordNotFound"
+                        }
+                      ]
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "streamer": {
+                    "type": "string",
+                    "description": "The DID of the streamer.",
+                    "format": "did"
+                  },
+                  "livestreamUri": {
+                    "type": "string",
+                    "description": "The AT-URI of the livestream record to update.",
+                    "format": "uri"
+                  },
+                  "title": {
+                    "type": "string",
+                    "description": "New title for the livestream.",
+                    "maxLength": 1400
+                  }
+                },
+                "required": ["streamer", "livestreamUri"]
+              }
+            }
+          }
+        }
+      }
+    },
     "/xrpc/place.stream.live.getLiveUsers": {
       "get": {
         "summary": "Get a list of livestream segments for a user",

lexicons/place/stream/moderation/createBlock.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.createBlock",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a block (ban) on behalf of a streamer. Requires 'ban' permission. Creates an app.bsky.graph.block record in the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "subject"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer whose chat this block applies to."
+            },
+            "subject": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the user being blocked from chat."
+            },
+            "reason": {
+              "type": "string",
+              "maxLength": 300,
+              "description": "Optional reason for the block."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the created block record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the created block record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to create blocks for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}

lexicons/place/stream/moderation/createGate.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.createGate",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a gate (hide message) on behalf of a streamer. Requires 'hide' permission. Creates a place.stream.chat.gate record in the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "messageUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "messageUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the chat message to hide."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the created gate record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the created gate record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to hide messages for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}

lexicons/place/stream/moderation/defs.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.defs",
+  "defs": {
+    "permissionView": {
+      "type": "object",
+      "required": ["uri", "cid", "author", "record"],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri",
+          "description": "AT-URI of the permission record"
+        },
+        "cid": {
+          "type": "string",
+          "format": "cid",
+          "description": "Content identifier of the permission record"
+        },
+        "author": {
+          "type": "ref",
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "description": "The streamer who granted these permissions"
+        },
+        "record": {
+          "type": "unknown",
+          "description": "The permission record itself"
+        }
+      }
+    }
+  }
+}

lexicons/place/stream/moderation/deleteBlock.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.deleteBlock",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a block (unban) on behalf of a streamer. Requires 'ban' permission. Deletes an app.bsky.graph.block record from the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "blockUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "blockUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the block record to delete."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {}
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to delete blocks for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}

lexicons/place/stream/moderation/deleteGate.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.deleteGate",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a gate (unhide message) on behalf of a streamer. Requires 'hide' permission. Deletes a place.stream.chat.gate record from the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "gateUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "gateUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the gate record to delete."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {}
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to unhide messages for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}

lexicons/place/stream/moderation/permission.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.permission",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "description": "Record granting moderation permissions to a user for this streamer's content.",
+      "record": {
+        "type": "object",
+        "required": ["moderator", "permissions", "createdAt"],
+        "properties": {
+          "moderator": {
+            "type": "string",
+            "format": "did",
+            "description": "The DID of the user granted moderator permissions."
+          },
+          "permissions": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": ["ban", "hide", "livestream.manage"]
+            },
+            "description": "Array of permissions granted to this moderator. 'ban' covers blocks/bans (with optional expiration), 'hide' covers message gates, 'livestream.manage' allows updating livestream metadata."
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Client-declared timestamp when this moderator was added."
+          },
+          "expirationTime": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Optional expiration time for this delegation. If set, the delegation is invalid after this time."
+          }
+        }
+      }
+    }
+  }
+}

lexicons/place/stream/moderation/updateLivestream.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.updateLivestream",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Update livestream metadata on behalf of a streamer. Requires 'livestream.manage' permission. Updates a place.stream.livestream record in the streamer's repository.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "livestreamUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "livestreamUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the livestream record to update."
+            },
+            "title": {
+              "type": "string",
+              "maxLength": 1400,
+              "maxGraphemes": 140,
+              "description": "New title for the livestream."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the updated livestream record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the updated livestream record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to update livestream metadata for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        },
+        {
+          "name": "RecordNotFound",
+          "description": "The specified livestream record does not exist."
+        }
+      ]
+    }
+  }
+}

pkg/atproto/firehose.go

···
 				atsync.Bus.Publish(msg.StreamerRepoDID, mv)
 			}
 
+			if collection.String() == constants.PLACE_STREAM_MODERATION_PERMISSION {
+				log.Debug(ctx, "deleting moderation delegation", "userDID", evt.Repo, "rkey", rkey.String())
+				err := atsync.Model.DeleteModerationDelegation(ctx, rkey.String())
+				if err != nil {
+					log.Error(ctx, "failed to delete moderation delegation", "err", err)
+				}
+				// Publish deletion to WebSocket bus for real-time updates
+				// Create a deleted record marker to notify frontend
+				deletedRecord := map[string]any{
+					"$type":    "place.stream.moderation.permission",
+					"deleted":  true,
+					"rkey":     rkey.String(),
+					"streamer": evt.Repo,
+				}
+				go atsync.Bus.Publish(evt.Repo, deletedRecord)
+			}
+
+			if collection.String() == constants.PLACE_STREAM_CHAT_GATE {
+				log.Debug(ctx, "deleting gate", "userDID", evt.Repo, "rkey", rkey.String())
+				err := atsync.Model.DeleteGate(ctx, rkey.String())
+				if err != nil {
+					log.Error(ctx, "failed to delete gate", "err", err)
+				}
+			}
+
 		default:
 			log.Error(ctx, "unexpected record op kind")
 		}

pkg/atproto/moderation_test.go

···
+package atproto
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+	"github.com/bluesky-social/indigo/util"
+	"github.com/stretchr/testify/require"
+	"stream.place/streamplace/pkg/bus"
+	"stream.place/streamplace/pkg/config"
+	"stream.place/streamplace/pkg/constants"
+	"stream.place/streamplace/pkg/devenv"
+	"stream.place/streamplace/pkg/model"
+	"stream.place/streamplace/pkg/statedb"
+	"stream.place/streamplace/pkg/streamplace"
+)
+
+func TestDelegatedModeration(t *testing.T) {
+	dev := devenv.WithDevEnv(t)
+	t.Logf("dev: %+v", dev)
+	cli := config.CLI{
+		BroadcasterHost: "example.com",
+		DBURL:           ":memory:",
+		RelayHost:       strings.ReplaceAll(dev.PDSURL, "http://", "ws://"),
+		PLCURL:          dev.PLCURL,
+	}
+	t.Logf("cli: %+v", cli)
+	b := bus.NewBus()
+	cli.DataDir = t.TempDir()
+	mod, err := model.MakeDB(":memory:")
+	require.NoError(t, err)
+	state, err := statedb.MakeDB(context.Background(), &cli, nil, mod)
+	require.NoError(t, err)
+	atsync := &ATProtoSynchronizer{
+		CLI:        &cli,
+		StatefulDB: state,
+		Model:      mod,
+		Bus:        b,
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	done := make(chan struct{})
+
+	go func() {
+		err := atsync.StartFirehose(ctx)
+		require.NoError(t, err)
+		close(done)
+	}()
+
+	streamer := dev.CreateAccount(t)
+	moderator := dev.CreateAccount(t)
+	user := dev.CreateAccount(t)
+
+	// Test 1: Create delegation record with expiration time
+	t.Log("Test 1: Creating delegation record with expiration time")
+	expirationTime := time.Now().Add(24 * time.Hour).Format(time.RFC3339)
+	delegationRecord := &streamplace.ModerationPermission{
+		LexiconTypeID:  "place.stream.moderation.permission",
+		Moderator:      moderator.DID,
+		Permissions:    []string{"ban", "hide", "livestream.manage"},
+		CreatedAt:      time.Now().Format(util.ISO8601),
+		ExpirationTime: &expirationTime,
+	}
+
+	_, err = comatproto.RepoCreateRecord(ctx, streamer.XRPC, &comatproto.RepoCreateRecord_Input{
+		Collection: constants.PLACE_STREAM_MODERATION_PERMISSION,
+		Repo:       streamer.DID,
+		Record:     &lexutil.LexiconTypeDecoder{Val: delegationRecord},
+	})
+	require.NoError(t, err)
+
+	// Wait for firehose ingestion
+	err = untilNoErrors(t, func() error {
+		delegation, err := mod.GetModerationDelegation(ctx, streamer.DID, moderator.DID)
+		if err != nil {
+			return err
+		}
+		if delegation == nil {
+			return fmt.Errorf("delegation not found")
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	t.Log("✓ Delegation record ingested successfully")
+
+	// Verify delegation details including expiration time
+	view, err := mod.GetModerationDelegation(ctx, streamer.DID, moderator.DID)
+	require.NoError(t, err)
+	require.NotNil(t, view)
+	require.Equal(t, streamer.DID, view.Author.Did)
+
+	delegation := view.Record.Val.(*streamplace.ModerationPermission)
+	require.NotNil(t, delegation)
+	require.Equal(t, moderator.DID, delegation.Moderator)
+	require.NotNil(t, delegation.ExpirationTime, "expiration time should be set")
+
+	exp, err := time.Parse(time.RFC3339, *delegation.ExpirationTime)
+	require.NoError(t, err)
+	require.True(t, exp.After(time.Now()), "expiration time should be in the future")
+	t.Log("✓ Delegation details verified (including expiration time)")
+
+	// Test 2: Create block (ban user)
+	t.Log("Test 2: Creating block record")
+	block := &bsky.GraphBlock{
+		Subject:   user.DID,
+		CreatedAt: time.Now().UTC().Format(time.RFC3339),
+	}
+
+	blockRec, err := comatproto.RepoCreateRecord(ctx, streamer.XRPC, &comatproto.RepoCreateRecord_Input{
+		Collection: constants.APP_BSKY_GRAPH_BLOCK,
+		Repo:       streamer.DID,
+		Record:     &lexutil.LexiconTypeDecoder{Val: block},
+	})
+	require.NoError(t, err)
+	t.Logf("✓ Block record created: %s", blockRec.Uri)
+
+	// Wait for firehose to process block
+	blockRkey := strings.TrimPrefix(blockRec.Uri, fmt.Sprintf("at://%s/%s/", streamer.DID, constants.APP_BSKY_GRAPH_BLOCK))
+	err = untilNoErrors(t, func() error {
+		block, err := mod.GetBlock(ctx, blockRkey)
+		if err != nil {
+			return err
+		}
+		if block == nil {
+			return fmt.Errorf("block not found")
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	t.Log("✓ Block record ingested successfully")
+
+	// Test 3: Create chat message and gate
+	t.Log("Test 3: Creating chat message and gate")
+	msg := &streamplace.ChatMessage{
+		LexiconTypeID: "place.stream.chat.message",
+		Text:          "Test message to be hidden",
+		CreatedAt:     time.Now().Format(util.ISO8601),
+		Streamer:      streamer.DID,
+	}
+
+	msgRec, err := comatproto.RepoCreateRecord(ctx, user.XRPC, &comatproto.RepoCreateRecord_Input{
+		Collection: constants.PLACE_STREAM_CHAT_MESSAGE,
+		Repo:       user.DID,
+		Record:     &lexutil.LexiconTypeDecoder{Val: msg},
+	})
+	require.NoError(t, err)
+	t.Logf("✓ Chat message created: %s", msgRec.Uri)
+
+	// Create gate to hide the message
+	gate := &streamplace.ChatGate{
+		LexiconTypeID: "place.stream.chat.gate",
+		HiddenMessage: msgRec.Uri,
+	}
+
+	gateRec, err := comatproto.RepoCreateRecord(ctx, streamer.XRPC, &comatproto.RepoCreateRecord_Input{
+		Collection: constants.PLACE_STREAM_CHAT_GATE,
+		Repo:       streamer.DID,
+		Record:     &lexutil.LexiconTypeDecoder{Val: gate},
+	})
+	require.NoError(t, err)
+	t.Logf("✓ Gate record created: %s", gateRec.Uri)
+
+	// Wait for firehose to process gate
+	gateRkey := strings.TrimPrefix(gateRec.Uri, fmt.Sprintf("at://%s/%s/", streamer.DID, constants.PLACE_STREAM_CHAT_GATE))
+	err = untilNoErrors(t, func() error {
+		gate, err := mod.GetGate(ctx, gateRkey)
+		if err != nil {
+			return err
+		}
+		if gate == nil {
+			return fmt.Errorf("gate not found")
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	t.Log("✓ Gate record ingested successfully")
+
+	// Test 4: Delete gate (unhide message)
+	t.Log("Test 4: Deleting gate record")
+
+	_, err = comatproto.RepoDeleteRecord(ctx, streamer.XRPC, &comatproto.RepoDeleteRecord_Input{
+		Collection: constants.PLACE_STREAM_CHAT_GATE,
+		Repo:       streamer.DID,
+		Rkey:       gateRkey,
+	})
+	require.NoError(t, err)
+
+	// Wait for firehose to process deletion
+	err = untilNoErrors(t, func() error {
+		gate, err := mod.GetGate(ctx, gateRkey)
+		if err != nil {
+			return err
+		}
+		if gate != nil {
+			return fmt.Errorf("gate still exists")
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	t.Log("✓ Gate record deleted successfully")
+
+	// Test 5: Delete delegation (revoke permissions)
+	t.Log("Test 5: Deleting delegation record")
+	uri, err := syntax.ParseATURI(view.Uri)
+	require.NoError(t, err)
+
+	_, err = comatproto.RepoDeleteRecord(ctx, streamer.XRPC, &comatproto.RepoDeleteRecord_Input{
+		Collection: constants.PLACE_STREAM_MODERATION_PERMISSION,
+		Repo:       streamer.DID,
+		Rkey:       uri.RecordKey().String(),
+	})
+	require.NoError(t, err)
+
+	// Wait for firehose to process deletion
+	err = untilNoErrors(t, func() error {
+		delegation, err := mod.GetModerationDelegation(ctx, streamer.DID, moderator.DID)
+		if err != nil {
+			return err
+		}
+		if delegation != nil {
+			return fmt.Errorf("delegation still exists")
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	t.Log("✓ Delegation record deleted successfully")
+
+	t.Log("All moderation tests passed!")
+	cancel()
+	<-done
+}

pkg/atproto/sync.go

···
 			log.Error(ctx, "failed to create metadata configuration", "err", err)
 		}
 
+	case *streamplace.ModerationPermission:
+		repo, err := atsync.SyncBlueskyRepoCached(ctx, userDID, atsync.Model)
+		if err != nil {
+			return fmt.Errorf("failed to sync bluesky repo: %w", err)
+		}
+		log.Debug(ctx, "creating moderation delegation", "streamerDID", userDID, "moderatorDID", rec.Moderator)
+
+		err = atsync.Model.CreateModerationDelegation(ctx, rec, aturi)
+		if err != nil {
+			return fmt.Errorf("failed to create moderation delegation: %w", err)
+		}
+
+		view := &streamplace.ModerationDefs_PermissionView{
+			Uri: aturi.String(),
+			Cid: cid,
+			Author: &bsky.ActorDefs_ProfileViewBasic{
+				Did:    userDID,
+				Handle: repo.Handle,
+			},
+			Record: &lexutil.LexiconTypeDecoder{Val: rec},
+		}
+		// Publish moderation permission view to WebSocket bus for real-time updates
+		// This allows moderators to see their permissions instantly without page refresh
+		go atsync.Bus.Publish(userDID, view)
+
 	case *streamplace.LiveRecommendations:
 		log.Debug(ctx, "creating recommendations", "userDID", userDID, "count", len(rec.Streamers))
 

pkg/constants/constants.go

···
 package constants
 
-var PLACE_STREAM_KEY = "place.stream.key"                                   //nolint:all
-var PLACE_STREAM_LIVESTREAM = "place.stream.livestream"                     //nolint:all
-var PLACE_STREAM_CHAT_MESSAGE = "place.stream.chat.message"                 //nolint:all
-var PLACE_STREAM_CHAT_PROFILE = "place.stream.chat.profile"                 //nolint:all
-var PLACE_STREAM_SERVER_SETTINGS = "place.stream.server.settings"           //nolint:all
-var STREAMPLACE_SIGNING_KEY = "signingKey"                                  //nolint:all
-var APP_BSKY_GRAPH_FOLLOW = "app.bsky.graph.follow"                         //nolint:all
-var APP_BSKY_FEED_POST = "app.bsky.feed.post"                               //nolint:all
-var APP_BSKY_GRAPH_BLOCK = "app.bsky.graph.block"                           //nolint:all
-var PLACE_STREAM_CHAT_GATE = "place.stream.chat.gate"                       //nolint:all
-var PLACE_STREAM_DEFAULT_METADATA = "place.stream.metadata.configuration"   //nolint:all
-var PLACE_STREAM_LIVE_RECOMMENDATIONS = "place.stream.live.recommendations" //nolint:all
+var PLACE_STREAM_KEY = "place.stream.key"                                     //nolint:all
+var PLACE_STREAM_LIVESTREAM = "place.stream.livestream"                       //nolint:all
+var PLACE_STREAM_CHAT_MESSAGE = "place.stream.chat.message"                   //nolint:all
+var PLACE_STREAM_CHAT_PROFILE = "place.stream.chat.profile"                   //nolint:all
+var PLACE_STREAM_SERVER_SETTINGS = "place.stream.server.settings"             //nolint:all
+var PLACE_STREAM_MODERATION_PERMISSION = "place.stream.moderation.permission" //nolint:all
+var STREAMPLACE_SIGNING_KEY = "signingKey"                                    //nolint:all
+var APP_BSKY_GRAPH_FOLLOW = "app.bsky.graph.follow"                           //nolint:all
+var APP_BSKY_FEED_POST = "app.bsky.feed.post"                                 //nolint:all
+var APP_BSKY_GRAPH_BLOCK = "app.bsky.graph.block"                             //nolint:all
+var PLACE_STREAM_CHAT_GATE = "place.stream.chat.gate"                         //nolint:all
+var PLACE_STREAM_DEFAULT_METADATA = "place.stream.metadata.configuration"     //nolint:all
+var PLACE_STREAM_LIVE_RECOMMENDATIONS = "place.stream.live.recommendations"   //nolint:all
 
 const DID_KEY_PREFIX = "did:key" //nolint:all
 const ADDRESS_KEY_PREFIX = "0x"  //nolint:all

pkg/gen/gen.go

···
 		streamplace.MetadataDistributionPolicy{},
 		streamplace.MetadataContentRights{},
 		streamplace.MetadataContentWarnings{},
+		streamplace.ModerationPermission{},
 		streamplace.LiveRecommendations{},
 	); err != nil {
 		panic(err)

pkg/model/model.go

···
 	GetMetadataConfiguration(ctx context.Context, repoDID string) (*MetadataConfiguration, error)
 	DeleteMetadataConfiguration(ctx context.Context, repoDID string) error
 
+	CreateModerationDelegation(ctx context.Context, rec *streamplace.ModerationPermission, aturi syntax.ATURI) error
+	DeleteModerationDelegation(ctx context.Context, rkey string) error
+	GetModerationDelegation(ctx context.Context, streamerDID, moderatorDID string) (*streamplace.ModerationDefs_PermissionView, error)
+	GetModerationDelegations(ctx context.Context, streamerDID, moderatorDID string) ([]*streamplace.ModerationDefs_PermissionView, error)
+	GetModeratorDelegations(ctx context.Context, moderatorDID string) ([]*streamplace.ModerationDefs_PermissionView, error)
+	GetStreamerModerators(ctx context.Context, streamerDID string) ([]*streamplace.ModerationDefs_PermissionView, error)
+
 	GetRecommendation(userDID string) (*Recommendation, error)
 	UpsertRecommendation(rec *Recommendation) error
 }
···
 		Label{},
 		BroadcastOrigin{},
 		MetadataConfiguration{},
+		ModerationDelegation{},
 		Recommendation{},
 	} {
 		err = db.AutoMigrate(model)

pkg/model/moderation_delegation.go

···
+package model
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+	"gorm.io/gorm"
+	"stream.place/streamplace/pkg/aqtime"
+	"stream.place/streamplace/pkg/spid"
+	"stream.place/streamplace/pkg/streamplace"
+)
+
+type ModerationDelegation struct {
+	RKey         string    `gorm:"primaryKey;column:rkey"`
+	CID          string    `gorm:"column:cid"`
+	RepoDID      string    `json:"repoDID" gorm:"column:repo_did;index:idx_repo_moderator,priority:1"`
+	Repo         *Repo     `json:"repo,omitempty" gorm:"foreignKey:DID;references:RepoDID"`
+	ModeratorDID string    `gorm:"column:moderator_did;index:idx_repo_moderator,priority:2;index:idx_moderator"`
+	Record       []byte    `gorm:"column:record"` // Full CBOR record
+	CreatedAt    time.Time `gorm:"column:created_at"`
+	IndexedAt    time.Time `gorm:"column:indexed_at"`
+}
+
+func (md *ModerationDelegation) ToPermissionView() (*streamplace.ModerationDefs_PermissionView, error) {
+	rec, err := lexutil.CborDecodeValue(md.Record)
+	if err != nil {
+		return nil, fmt.Errorf("error decoding moderation permission: %w", err)
+	}
+
+	uri := fmt.Sprintf("at://%s/place.stream.moderation.permission/%s", md.RepoDID, md.RKey)
+
+	view := &streamplace.ModerationDefs_PermissionView{
+		Author: &bsky.ActorDefs_ProfileViewBasic{
+			Did: md.RepoDID,
+		},
+		Cid:    md.CID,
+		Record: &lexutil.LexiconTypeDecoder{Val: rec},
+		Uri:    uri,
+	}
+
+	if md.Repo != nil {
+		view.Author.Handle = md.Repo.Handle
+	}
+
+	return view, nil
+}
+
+func (m *DBModel) CreateModerationDelegation(ctx context.Context, rec *streamplace.ModerationPermission, aturi syntax.ATURI) error {
+	repoDID, err := aturi.Authority().AsDID()
+	if err != nil {
+		return fmt.Errorf("invalid ATURI authority: %w", err)
+	}
+	cid, err := spid.GetCID(rec)
+	if err != nil {
+		return fmt.Errorf("failed to get CID: %w", err)
+	}
+	rkey := aturi.RecordKey().String()
+
+	buf := bytes.Buffer{}
+	err = rec.MarshalCBOR(&buf)
+	if err != nil {
+		return fmt.Errorf("failed to marshal moderation permission: %w", err)
+	}
+
+	now := aqtime.FromTime(time.Now().UTC())
+
+	delegation := &ModerationDelegation{
+		RKey:         rkey,
+		CID:          cid.String(),
+		RepoDID:      repoDID.String(),
+		ModeratorDID: rec.Moderator,
+		Record:       buf.Bytes(),
+		CreatedAt:    now.Time().UTC(),
+		IndexedAt:    now.Time().UTC(),
+	}
+
+	return m.DB.WithContext(ctx).Create(delegation).Error
+}
+
+func (m *DBModel) DeleteModerationDelegation(ctx context.Context, rkey string) error {
+	return m.DB.WithContext(ctx).Where("rkey = ?", rkey).Delete(&ModerationDelegation{}).Error
+}
+
+func (m *DBModel) GetModerationDelegation(ctx context.Context, streamerDID, moderatorDID string) (*streamplace.ModerationDefs_PermissionView, error) {
+	var delegation ModerationDelegation
+	err := m.DB.WithContext(ctx).Preload("Repo").
+		Where("repo_did = ? AND moderator_did = ?", streamerDID, moderatorDID).
+		Order("created_at DESC").
+		First(&delegation).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return delegation.ToPermissionView()
+}
+
+// GetModerationDelegations returns ALL delegation records for a moderator from a specific streamer.
+// This allows multiple separate permission records (e.g., one for "ban", one for "hide") to be merged.
+func (m *DBModel) GetModerationDelegations(ctx context.Context, streamerDID, moderatorDID string) ([]*streamplace.ModerationDefs_PermissionView, error) {
+	var delegations []*ModerationDelegation
+	err := m.DB.WithContext(ctx).Preload("Repo").
+		Where("repo_did = ? AND moderator_did = ?", streamerDID, moderatorDID).
+		Find(&delegations).Error
+	if err != nil {
+		return nil, err
+	}
+
+	views := make([]*streamplace.ModerationDefs_PermissionView, len(delegations))
+	for i, d := range delegations {
+		view, err := d.ToPermissionView()
+		if err != nil {
+			return nil, err
+		}
+		views[i] = view
+	}
+	return views, nil
+}
+
+func (m *DBModel) GetModeratorDelegations(ctx context.Context, moderatorDID string) ([]*streamplace.ModerationDefs_PermissionView, error) {
+	var delegations []*ModerationDelegation
+	err := m.DB.WithContext(ctx).Preload("Repo").
+		Where("moderator_did = ?", moderatorDID).
+		Find(&delegations).Error
+	if err != nil {
+		return nil, err
+	}
+
+	views := make([]*streamplace.ModerationDefs_PermissionView, len(delegations))
+	for i, d := range delegations {
+		view, err := d.ToPermissionView()
+		if err != nil {
+			return nil, err
+		}
+		views[i] = view
+	}
+	return views, nil
+}
+
+func (m *DBModel) GetStreamerModerators(ctx context.Context, streamerDID string) ([]*streamplace.ModerationDefs_PermissionView, error) {
+	var delegations []*ModerationDelegation
+	err := m.DB.WithContext(ctx).Preload("Repo").
+		Where("repo_did = ?", streamerDID).
+		Find(&delegations).Error
+	if err != nil {
+		return nil, err
+	}
+
+	views := make([]*streamplace.ModerationDefs_PermissionView, len(delegations))
+	for i, d := range delegations {
+		view, err := d.ToPermissionView()
+		if err != nil {
+			return nil, err
+		}
+		views[i] = view
+	}
+	return views, nil
+}

pkg/moderation/permissions.go

···
+package moderation
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"stream.place/streamplace/pkg/streamplace"
+)
+
+type delegationGetter interface {
+	GetModerationDelegations(ctx context.Context, streamerDID, moderatorDID string) ([]*streamplace.ModerationDefs_PermissionView, error)
+}
+
+// Permission scope constants
+const (
+	PermissionBan              = "ban"
+	PermissionHide             = "hide"
+	PermissionLivestreamManage = "livestream.manage"
+)
+
+// ActionPermissions maps moderation actions to required permissions
+var ActionPermissions = map[string]string{
+	"createBlock":      PermissionBan,
+	"deleteBlock":      PermissionBan,
+	"createGate":       PermissionHide,
+	"deleteGate":       PermissionHide,
+	"updateLivestream": PermissionLivestreamManage,
+}
+
+// PermissionChecker validates moderation permissions
+type PermissionChecker struct {
+	model delegationGetter
+}
+
+// NewPermissionChecker creates a new permission checker
+func NewPermissionChecker(m delegationGetter) *PermissionChecker {
+	return &PermissionChecker{model: m}
+}
+
+// CheckPermission validates that a moderator has permission to perform an action
+// Returns an error if the moderator lacks the required permission
+func (pc *PermissionChecker) CheckPermission(ctx context.Context, moderatorDID, streamerDID, action string) error {
+	// Get required permission for this action (validate action first)
+	requiredPermission, ok := ActionPermissions[action]
+	if !ok {
+		return fmt.Errorf("unknown action: %s", action)
+	}
+
+	// Streamers always have permission for their own content
+	if moderatorDID == streamerDID {
+		return nil
+	}
+
+	// Check if moderator has the required permission
+	hasPermission, err := pc.HasPermission(ctx, moderatorDID, streamerDID, requiredPermission)
+	if err != nil {
+		return fmt.Errorf("failed to check permissions: %w", err)
+	}
+
+	if !hasPermission {
+		return fmt.Errorf("moderator %s does not have permission '%s' for streamer %s", moderatorDID, requiredPermission, streamerDID)
+	}
+
+	return nil
+}
+
+// HasPermission checks if a moderator has a specific permission for a streamer.
+// It merges permissions from ALL delegation records for the moderator.
+func (pc *PermissionChecker) HasPermission(ctx context.Context, moderatorDID, streamerDID, permission string) (bool, error) {
+	// Streamers always have all permissions for their own content
+	if moderatorDID == streamerDID {
+		return true, nil
+	}
+
+	// Look up ALL delegation records for this moderator
+	delegations, err := pc.model.GetModerationDelegations(ctx, streamerDID, moderatorDID)
+	if err != nil {
+		return false, fmt.Errorf("failed to get moderation delegations: %w", err)
+	}
+
+	if len(delegations) == 0 {
+		return false, nil
+	}
+
+	// Check all delegation records and merge their permissions
+	for _, delegationView := range delegations {
+		// Extract the actual permission record from the view
+		permRecord, ok := delegationView.Record.Val.(*streamplace.ModerationPermission)
+		if !ok {
+			return false, fmt.Errorf("failed to cast record to ModerationPermission")
+		}
+
+		// Skip expired delegations
+		if permRecord.ExpirationTime != nil {
+			expirationTime, err := time.Parse(time.RFC3339, *permRecord.ExpirationTime)
+			if err != nil {
+				return false, fmt.Errorf("failed to parse expiration time: %w", err)
+			}
+			if time.Now().After(expirationTime) {
+				continue
+			}
+		}
+
+		// Check if this delegation has the required permission
+		for _, p := range permRecord.Permissions {
+			if p == permission {
+				return true, nil
+			}
+		}
+	}
+
+	return false, nil
+}

pkg/moderation/permissions_test.go

···
+package moderation
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+	"github.com/stretchr/testify/require"
+	"stream.place/streamplace/pkg/streamplace"
+)
+
+func TestPermissionChecker_CheckPermission_StreamerSelfModeration(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	streamerDID := "did:plc:streamer123"
+
+	err := pc.CheckPermission(context.Background(), streamerDID, streamerDID, "createBlock")
+	require.NoError(t, err, "streamer should have permission for self-moderation")
+
+	err = pc.CheckPermission(context.Background(), streamerDID, streamerDID, "createGate")
+	require.NoError(t, err, "streamer should have permission for self-moderation")
+
+	err = pc.CheckPermission(context.Background(), streamerDID, streamerDID, "updateLivestream")
+	require.NoError(t, err, "streamer should have permission for self-moderation")
+}
+
+func TestPermissionChecker_CheckPermission_WithCorrectPermission(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	ctx := context.Background()
+	streamerDID := "did:plc:streamer123"
+	moderatorDID := "did:plc:moderator456"
+
+	mod.addPermissionView(streamerDID, moderatorDID, []string{"ban", "hide"}, nil)
+
+	err := pc.CheckPermission(ctx, moderatorDID, streamerDID, "createBlock")
+	require.NoError(t, err, "moderator with 'ban' permission should be able to createBlock")
+
+	err = pc.CheckPermission(ctx, moderatorDID, streamerDID, "createGate")
+	require.NoError(t, err, "moderator with 'hide' permission should be able to createGate")
+}
+
+func TestPermissionChecker_CheckPermission_WithWrongPermission(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	ctx := context.Background()
+	streamerDID := "did:plc:streamer123"
+	moderatorDID := "did:plc:moderator456"
+
+	mod.addPermissionView(streamerDID, moderatorDID, []string{"hide"}, nil)
+
+	err := pc.CheckPermission(ctx, moderatorDID, streamerDID, "createBlock")
+	require.Error(t, err, "moderator with only 'hide' permission should not be able to createBlock")
+	require.Contains(t, err.Error(), "does not have permission 'ban'")
+}
+
+func TestPermissionChecker_CheckPermission_WithoutAnyPermission(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	ctx := context.Background()
+	streamerDID := "did:plc:streamer123"
+	moderatorDID := "did:plc:moderator456"
+
+	err := pc.CheckPermission(ctx, moderatorDID, streamerDID, "createBlock")
+	require.Error(t, err, "moderator without any delegation should be denied")
+	require.Contains(t, err.Error(), "does not have permission")
+}
+
+func TestPermissionChecker_CheckPermission_UnknownAction(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	streamerDID := "did:plc:streamer123"
+
+	err := pc.CheckPermission(context.Background(), streamerDID, streamerDID, "unknownAction")
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "unknown action")
+}
+
+func TestPermissionChecker_HasPermission(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	ctx := context.Background()
+	streamerDID := "did:plc:streamer123"
+	moderatorDID := "did:plc:moderator456"
+
+	mod.addPermissionView(streamerDID, moderatorDID, []string{"ban", "hide"}, nil)
+
+	has, err := pc.HasPermission(ctx, moderatorDID, streamerDID, PermissionBan)
+	require.NoError(t, err)
+	require.True(t, has, "should have 'ban' permission")
+
+	has, err = pc.HasPermission(ctx, moderatorDID, streamerDID, PermissionHide)
+	require.NoError(t, err)
+	require.True(t, has, "should have 'hide' permission")
+
+	has, err = pc.HasPermission(ctx, moderatorDID, streamerDID, PermissionLivestreamManage)
+	require.NoError(t, err)
+	require.False(t, has, "should not have 'livestream.manage' permission")
+}
+
+func TestActionPermissions_Mapping(t *testing.T) {
+	require.Equal(t, PermissionBan, ActionPermissions["createBlock"])
+	require.Equal(t, PermissionBan, ActionPermissions["deleteBlock"])
+	require.Equal(t, PermissionHide, ActionPermissions["createGate"])
+	require.Equal(t, PermissionHide, ActionPermissions["deleteGate"])
+	require.Equal(t, PermissionLivestreamManage, ActionPermissions["updateLivestream"])
+}
+
+func TestPermissionChecker_HasPermission_MultipleSeparateRecords(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	ctx := context.Background()
+	streamerDID := "did:plc:streamer123"
+	moderatorDID := "did:plc:moderator456"
+
+	mod.addPermissionView(streamerDID, moderatorDID, []string{"ban"}, nil)
+	mod.addPermissionView(streamerDID, moderatorDID, []string{"hide"}, nil)
+
+	hasBan, err := pc.HasPermission(ctx, moderatorDID, streamerDID, PermissionBan)
+	require.NoError(t, err)
+	require.True(t, hasBan, "should have 'ban' permission from first record")
+
+	hasHide, err := pc.HasPermission(ctx, moderatorDID, streamerDID, PermissionHide)
+	require.NoError(t, err)
+	require.True(t, hasHide, "should have 'hide' permission from second record")
+
+	err = pc.CheckPermission(ctx, moderatorDID, streamerDID, "createBlock")
+	require.NoError(t, err, "should allow createBlock with 'ban' permission from separate record")
+
+	err = pc.CheckPermission(ctx, moderatorDID, streamerDID, "createGate")
+	require.NoError(t, err, "should allow createGate with 'hide' permission from separate record")
+}
+
+func TestPermissionChecker_HasPermission_ExpiredDelegation(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	ctx := context.Background()
+	streamerDID := "did:plc:streamer123"
+	moderatorDID := "did:plc:moderator456"
+
+	expiredTime := time.Now().Add(-1 * time.Hour)
+	mod.addPermissionView(streamerDID, moderatorDID, []string{"ban"}, &expiredTime)
+
+	hasPermission, err := pc.HasPermission(ctx, moderatorDID, streamerDID, PermissionBan)
+	require.NoError(t, err)
+	require.False(t, hasPermission, "should deny permission for expired delegation")
+
+	err = pc.CheckPermission(ctx, moderatorDID, streamerDID, "createBlock")
+	require.Error(t, err, "should deny action for expired delegation")
+	require.Contains(t, err.Error(), "does not have permission")
+}
+
+func TestPermissionChecker_HasPermission_NotYetExpired(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	ctx := context.Background()
+	streamerDID := "did:plc:streamer123"
+	moderatorDID := "did:plc:moderator456"
+
+	futureTime := time.Now().Add(1 * time.Hour)
+	mod.addPermissionView(streamerDID, moderatorDID, []string{"ban", "hide"}, &futureTime)
+
+	hasPermission, err := pc.HasPermission(ctx, moderatorDID, streamerDID, PermissionBan)
+	require.NoError(t, err)
+	require.True(t, hasPermission, "should allow permission for not-yet-expired delegation")
+
+	err = pc.CheckPermission(ctx, moderatorDID, streamerDID, "createBlock")
+	require.NoError(t, err, "should allow action for not-yet-expired delegation")
+}
+
+func TestPermissionChecker_HasPermission_NoExpiration(t *testing.T) {
+	mod := newMockModel()
+	pc := NewPermissionChecker(mod)
+
+	ctx := context.Background()
+	streamerDID := "did:plc:streamer123"
+	moderatorDID := "did:plc:moderator456"
+
+	mod.addPermissionView(streamerDID, moderatorDID, []string{"ban", "hide"}, nil)
+
+	hasPermission, err := pc.HasPermission(ctx, moderatorDID, streamerDID, PermissionBan)
+	require.NoError(t, err)
+	require.True(t, hasPermission, "should allow permission for delegation with no expiration")
+
+	err = pc.CheckPermission(ctx, moderatorDID, streamerDID, "createBlock")
+	require.NoError(t, err, "should allow action for delegation with no expiration")
+}
+
+type mockModel struct {
+	delegations map[string][]*streamplace.ModerationDefs_PermissionView
+}
+
+func newMockModel() *mockModel {
+	return &mockModel{
+		delegations: make(map[string][]*streamplace.ModerationDefs_PermissionView),
+	}
+}
+
+func (m *mockModel) addPermissionView(streamerDID, moderatorDID string, permissions []string, expirationTime *time.Time) {
+	key := streamerDID + "_" + moderatorDID
+
+	var expTimeStr *string
+	if expirationTime != nil {
+		str := expirationTime.Format(time.RFC3339)
+		expTimeStr = &str
+	}
+
+	permRecord := &streamplace.ModerationPermission{
+		Moderator:      moderatorDID,
+		Permissions:    permissions,
+		ExpirationTime: expTimeStr,
+	}
+
+	view := &streamplace.ModerationDefs_PermissionView{
+		Uri:    fmt.Sprintf("at://%s/place.stream.moderation.permission/test", streamerDID),
+		Cid:    "bafytest",
+		Author: &bsky.ActorDefs_ProfileViewBasic{Did: streamerDID},
+		Record: &lexutil.LexiconTypeDecoder{Val: permRecord},
+	}
+
+	m.delegations[key] = append(m.delegations[key], view)
+}
+
+func (m *mockModel) GetModerationDelegations(ctx context.Context, streamerDID, moderatorDID string) ([]*streamplace.ModerationDefs_PermissionView, error) {
+	key := streamerDID + "_" + moderatorDID
+	delegations, exists := m.delegations[key]
+	if !exists {
+		return nil, nil
+	}
+	return delegations, nil
+}

pkg/spxrpc/moderation_helpers.go

···
+package spxrpc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/streamplace/oatproxy/pkg/oatproxy"
+	"stream.place/streamplace/pkg/log"
+	"stream.place/streamplace/pkg/moderation"
+)
+
+// DelegatedModerationContext contains validated session and client for delegated moderation actions
+type DelegatedModerationContext struct {
+	ModeratorDID     string
+	ModeratorSession *oatproxy.OAuthSession
+	StreamerClient   *oatproxy.XrpcClient
+	StreamerSession  *oatproxy.OAuthSession
+}
+
+// GetDelegatedModerationContext validates moderator OAuth, checks permission, and returns streamer client
+// This consolidates the repeated pattern in all moderation handlers to eliminate duplication and fix security issues
+func (s *Server) GetDelegatedModerationContext(
+	ctx context.Context,
+	streamerDID string,
+	action string,
+) (*DelegatedModerationContext, error) {
+
+	// Step 1: Get and validate moderator OAuth session
+	// NOTE: GetOAuthSession returns (*OAuthSession, *XrpcClient), not (*OAuthSession, error)
+	moderatorSession, _ := oatproxy.GetOAuthSession(ctx)
+	if moderatorSession == nil {
+		return nil, echo.NewHTTPError(http.StatusUnauthorized, "oauth session not found")
+	}
+	moderatorDID := moderatorSession.DID
+
+	// Step 2: Check permission
+	permChecker := moderation.NewPermissionChecker(s.model)
+	if err := permChecker.CheckPermission(ctx, moderatorDID, streamerDID, action); err != nil {
+		log.Warn(ctx, "permission denied", "moderator", moderatorDID, "streamer", streamerDID, "action", action, "error", err)
+		return nil, echo.NewHTTPError(http.StatusForbidden, fmt.Sprintf("permission denied: %v", err))
+	}
+
+	// Step 3: Get streamer session
+	streamerSession, err := s.statefulDB.GetSessionByDID(streamerDID)
+	if err != nil {
+		log.Error(ctx, "failed to get streamer session", "streamer", streamerDID, "error", err)
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to get streamer session: %v", err))
+	}
+	if streamerSession == nil {
+		return nil, echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("session not found for streamer %s", streamerDID))
+	}
+
+	// Step 4: Refresh session if needed
+	streamerSession, err = s.op.RefreshIfNeeded(streamerSession)
+	if err != nil {
+		log.Error(ctx, "failed to refresh streamer session", "streamer", streamerDID, "error", err)
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to refresh session: %v", err))
+	}
+	if streamerSession == nil {
+		return nil, echo.NewHTTPError(http.StatusNotFound, "streamer session not found after refresh")
+	}
+
+	// Step 5: Get XRPC client for streamer
+	client, err := s.op.GetXrpcClient(streamerSession)
+	if err != nil {
+		log.Error(ctx, "failed to get xrpc client", "streamer", streamerDID, "error", err)
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to get xrpc client: %v", err))
+	}
+
+	return &DelegatedModerationContext{
+		ModeratorDID:     moderatorDID,
+		ModeratorSession: moderatorSession,
+		StreamerClient:   client,
+		StreamerSession:  streamerSession,
+	}, nil
+}

pkg/spxrpc/place_stream_moderation.go

···
+package spxrpc
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/labstack/echo/v4"
+	"stream.place/streamplace/pkg/constants"
+	"stream.place/streamplace/pkg/log"
+	"stream.place/streamplace/pkg/statedb"
+	"stream.place/streamplace/pkg/streamplace"
+)
+
+// handlePlaceStreamModerationCreateBlock creates a block (ban) on behalf of a streamer
+func (s *Server) handlePlaceStreamModerationCreateBlock(ctx context.Context, input *streamplace.ModerationCreateBlock_Input) (*streamplace.ModerationCreateBlock_Output, error) {
+	// Validate input
+	if err := validateDID(input.Streamer); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid streamer DID: %v", err))
+	}
+	if err := validateDID(input.Subject); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid subject DID: %v", err))
+	}
+
+	// Get delegated moderation context (validates OAuth, permission, and returns client)
+	modCtx, err := s.GetDelegatedModerationContext(ctx, input.Streamer, "createBlock")
+	if err != nil {
+		return nil, err
+	}
+
+	// Create block record in streamer's repo
+	block := &bsky.GraphBlock{
+		Subject:   input.Subject,
+		CreatedAt: time.Now().UTC().Format(time.RFC3339),
+	}
+
+	createInput := comatproto.RepoCreateRecord_Input{
+		Collection: constants.APP_BSKY_GRAPH_BLOCK,
+		Record:     &lexutil.LexiconTypeDecoder{Val: block},
+		Repo:       input.Streamer,
+	}
+	createOutput := comatproto.RepoCreateRecord_Output{}
+
+	err = modCtx.StreamerClient.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", map[string]any{}, createInput, &createOutput)
+	if err != nil {
+		log.Error(ctx, "failed to create block record", "err", err)
+		if auditErr := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "createBlock", "", input.Subject, "", false, err.Error()); auditErr != nil {
+			log.Error(ctx, "failed to create audit log", "error", auditErr)
+		}
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to create block: %v", err))
+	}
+
+	// Log successful audit entry
+	if err := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "createBlock", "", input.Subject, createOutput.Uri, true, ""); err != nil {
+		log.Error(ctx, "failed to create audit log", "error", err)
+	}
+
+	return &streamplace.ModerationCreateBlock_Output{
+		Uri: createOutput.Uri,
+		Cid: createOutput.Cid,
+	}, nil
+}
+
+// handlePlaceStreamModerationDeleteBlock deletes a block (unban) on behalf of a streamer
+func (s *Server) handlePlaceStreamModerationDeleteBlock(ctx context.Context, input *streamplace.ModerationDeleteBlock_Input) (*streamplace.ModerationDeleteBlock_Output, error) {
+	// Validate input
+	if err := validateDID(input.Streamer); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid streamer DID: %v", err))
+	}
+	if err := validateATURI(input.BlockUri); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid block URI: %v", err))
+	}
+
+	// Get delegated moderation context (validates OAuth, permission, and returns client)
+	modCtx, err := s.GetDelegatedModerationContext(ctx, input.Streamer, "deleteBlock")
+	if err != nil {
+		return nil, err
+	}
+
+	// Parse blockUri to extract rkey
+	// AT-URI format: at://did:plc:xxx/collection/rkey
+	rkey, err := extractRKey(input.BlockUri)
+	if err != nil {
+		log.Error(ctx, "failed to extract rkey from blockUri", "uri", input.BlockUri, "err", err)
+		return nil, echo.NewHTTPError(http.StatusBadRequest, "invalid blockUri format")
+	}
+
+	// Delete block record from streamer's repo
+	deleteInput := comatproto.RepoDeleteRecord_Input{
+		Collection: constants.APP_BSKY_GRAPH_BLOCK,
+		Rkey:       rkey,
+		Repo:       input.Streamer,
+	}
+	deleteOutput := comatproto.RepoDeleteRecord_Output{}
+
+	err = modCtx.StreamerClient.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.deleteRecord", map[string]any{}, deleteInput, &deleteOutput)
+	if err != nil {
+		log.Error(ctx, "failed to delete block record", "err", err)
+		if auditErr := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "deleteBlock", input.BlockUri, "", "", false, err.Error()); auditErr != nil {
+			log.Error(ctx, "failed to create audit log", "error", auditErr)
+		}
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to delete block: %v", err))
+	}
+
+	// Log successful audit entry
+	if err := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "deleteBlock", input.BlockUri, "", "", true, ""); err != nil {
+		log.Error(ctx, "failed to create audit log", "error", err)
+	}
+
+	return &streamplace.ModerationDeleteBlock_Output{}, nil
+}
+
+// handlePlaceStreamModerationCreateGate creates a gate (hide message) on behalf of a streamer
+func (s *Server) handlePlaceStreamModerationCreateGate(ctx context.Context, input *streamplace.ModerationCreateGate_Input) (*streamplace.ModerationCreateGate_Output, error) {
+	// Validate input
+	if err := validateDID(input.Streamer); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid streamer DID: %v", err))
+	}
+	if err := validateATURI(input.MessageUri); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid message URI: %v", err))
+	}
+
+	// Get delegated moderation context (validates OAuth, permission, and returns client)
+	modCtx, err := s.GetDelegatedModerationContext(ctx, input.Streamer, "createGate")
+	if err != nil {
+		return nil, err
+	}
+
+	// Create gate record in streamer's repo
+	gate := &streamplace.ChatGate{
+		HiddenMessage: input.MessageUri,
+	}
+
+	createInput := comatproto.RepoCreateRecord_Input{
+		Collection: constants.PLACE_STREAM_CHAT_GATE,
+		Record:     &lexutil.LexiconTypeDecoder{Val: gate},
+		Repo:       input.Streamer,
+	}
+	createOutput := comatproto.RepoCreateRecord_Output{}
+
+	err = modCtx.StreamerClient.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", map[string]any{}, createInput, &createOutput)
+	if err != nil {
+		log.Error(ctx, "failed to create gate record", "err", err)
+		if auditErr := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "createGate", input.MessageUri, "", "", false, err.Error()); auditErr != nil {
+			log.Error(ctx, "failed to create audit log", "error", auditErr)
+		}
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to create gate: %v", err))
+	}
+
+	// Log successful audit entry
+	if err := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "createGate", input.MessageUri, "", createOutput.Uri, true, ""); err != nil {
+		log.Error(ctx, "failed to create audit log", "error", err)
+	}
+
+	return &streamplace.ModerationCreateGate_Output{
+		Uri: createOutput.Uri,
+		Cid: createOutput.Cid,
+	}, nil
+}
+
+// handlePlaceStreamModerationDeleteGate deletes a gate (unhide message) on behalf of a streamer
+func (s *Server) handlePlaceStreamModerationDeleteGate(ctx context.Context, input *streamplace.ModerationDeleteGate_Input) (*streamplace.ModerationDeleteGate_Output, error) {
+	// Validate input
+	if err := validateDID(input.Streamer); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid streamer DID: %v", err))
+	}
+	if err := validateATURI(input.GateUri); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid gate URI: %v", err))
+	}
+
+	// Get delegated moderation context (validates OAuth, permission, and returns client)
+	modCtx, err := s.GetDelegatedModerationContext(ctx, input.Streamer, "deleteGate")
+	if err != nil {
+		return nil, err
+	}
+
+	// Parse gateUri to extract rkey
+	rkey, err := extractRKey(input.GateUri)
+	if err != nil {
+		log.Error(ctx, "failed to extract rkey from gateUri", "uri", input.GateUri, "err", err)
+		return nil, echo.NewHTTPError(http.StatusBadRequest, "invalid gateUri format")
+	}
+
+	// Delete gate record from streamer's repo
+	deleteInput := comatproto.RepoDeleteRecord_Input{
+		Collection: constants.PLACE_STREAM_CHAT_GATE,
+		Rkey:       rkey,
+		Repo:       input.Streamer,
+	}
+	deleteOutput := comatproto.RepoDeleteRecord_Output{}
+
+	err = modCtx.StreamerClient.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.deleteRecord", map[string]any{}, deleteInput, &deleteOutput)
+	if err != nil {
+		log.Error(ctx, "failed to delete gate record", "err", err)
+		if auditErr := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "deleteGate", input.GateUri, "", "", false, err.Error()); auditErr != nil {
+			log.Error(ctx, "failed to create audit log", "error", auditErr)
+		}
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to delete gate: %v", err))
+	}
+
+	// Log successful audit entry
+	if err := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "deleteGate", input.GateUri, "", "", true, ""); err != nil {
+		log.Error(ctx, "failed to create audit log", "error", err)
+	}
+
+	return &streamplace.ModerationDeleteGate_Output{}, nil
+}
+
+// handlePlaceStreamModerationUpdateLivestream updates livestream metadata on behalf of a streamer
+func (s *Server) handlePlaceStreamModerationUpdateLivestream(ctx context.Context, input *streamplace.ModerationUpdateLivestream_Input) (*streamplace.ModerationUpdateLivestream_Output, error) {
+	// Validate input
+	if err := validateDID(input.Streamer); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid streamer DID: %v", err))
+	}
+	if err := validateATURI(input.LivestreamUri); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid livestream URI: %v", err))
+	}
+
+	// Get delegated moderation context (validates OAuth, permission, and returns client)
+	modCtx, err := s.GetDelegatedModerationContext(ctx, input.Streamer, "updateLivestream")
+	if err != nil {
+		return nil, err
+	}
+
+	// Parse livestreamUri to extract rkey
+	rkey, err := extractRKey(input.LivestreamUri)
+	if err != nil {
+		log.Error(ctx, "failed to extract rkey from livestreamUri", "uri", input.LivestreamUri, "err", err)
+		return nil, echo.NewHTTPError(http.StatusBadRequest, "invalid livestreamUri format")
+	}
+
+	// Get existing livestream record
+	getInput := map[string]any{
+		"repo":       input.Streamer,
+		"collection": constants.PLACE_STREAM_LIVESTREAM,
+		"rkey":       rkey,
+	}
+	getOutput := comatproto.RepoGetRecord_Output{}
+	err = modCtx.StreamerClient.Do(ctx, xrpc.Query, "application/json", "com.atproto.repo.getRecord", getInput, nil, &getOutput)
+	if err != nil {
+		log.Error(ctx, "failed to get livestream record", "err", err)
+		if auditErr := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "updateLivestream", input.LivestreamUri, "", "", false, fmt.Sprintf("failed to get record: %v", err)); auditErr != nil {
+			log.Error(ctx, "failed to create audit log", "error", auditErr)
+		}
+		return nil, echo.NewHTTPError(http.StatusNotFound, "livestream record not found")
+	}
+
+	// Decode existing record
+	if getOutput.Value == nil || getOutput.Value.Val == nil {
+		log.Error(ctx, "livestream record value is nil")
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to decode livestream record")
+	}
+
+	// Convert the decoded value to our struct
+	livestream := &streamplace.Livestream{}
+	recordBytes, err := json.Marshal(getOutput.Value.Val)
+	if err != nil {
+		log.Error(ctx, "failed to marshal livestream record", "err", err)
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to decode livestream record")
+	}
+	err = json.Unmarshal(recordBytes, livestream)
+	if err != nil {
+		log.Error(ctx, "failed to unmarshal livestream record", "err", err)
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to decode livestream record")
+	}
+
+	// Create new record (don't edit existing - old records serve as "chapter markers")
+	// Copy fields from existing record and update title
+	if input.Title != nil {
+		livestream.Title = *input.Title
+	}
+
+	// Ensure notificationSettings.pushNotification is false for mods
+	if livestream.NotificationSettings == nil {
+		livestream.NotificationSettings = &streamplace.Livestream_NotificationSettings{}
+	}
+	pushNotificationFalse := false
+	livestream.NotificationSettings.PushNotification = &pushNotificationFalse
+
+	// Update createdAt to current time for new record
+	livestream.CreatedAt = time.Now().UTC().Format(time.RFC3339)
+
+	// Create new record instead of updating existing
+	createInput := comatproto.RepoCreateRecord_Input{
+		Collection: constants.PLACE_STREAM_LIVESTREAM,
+		Record:     &lexutil.LexiconTypeDecoder{Val: livestream},
+		Repo:       input.Streamer,
+	}
+	createOutput := comatproto.RepoCreateRecord_Output{}
+
+	err = modCtx.StreamerClient.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", map[string]any{}, createInput, &createOutput)
+	if err != nil {
+		log.Error(ctx, "failed to create livestream record", "err", err)
+		if auditErr := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "updateLivestream", input.LivestreamUri, "", "", false, err.Error()); auditErr != nil {
+			log.Error(ctx, "failed to create audit log", "error", auditErr)
+		}
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to create livestream: %v", err))
+	}
+
+	// Log successful audit entry
+	if err := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "updateLivestream", input.LivestreamUri, "", createOutput.Uri, true, ""); err != nil {
+		log.Error(ctx, "failed to create audit log", "error", err)
+	}
+
+	return &streamplace.ModerationUpdateLivestream_Output{
+		Uri: createOutput.Uri,
+		Cid: createOutput.Cid,
+	}, nil
+}
+
+// Helper functions
+
+// extractRKey extracts the rkey from an AT-URI (at://did:plc:xxx/collection/rkey)
+func extractRKey(uri string) (string, error) {
+	aturi, err := syntax.ParseATURI(uri)
+	if err != nil {
+		return "", fmt.Errorf("invalid AT-URI: %w", err)
+	}
+	return aturi.RecordKey().String(), nil
+}
+
+// validateDID checks if string is a valid AT Protocol DID format
+func validateDID(did string) error {
+	_, err := syntax.ParseDID(did)
+	if err != nil {
+		return fmt.Errorf("invalid DID format: %w", err)
+	}
+	return nil
+}
+
+// validateATURI checks if string is a valid AT-URI format
+func validateATURI(uri string) error {
+	_, err := syntax.ParseATURI(uri)
+	if err != nil {
+		return fmt.Errorf("invalid AT-URI format: %w", err)
+	}
+	return nil
+}
+
+// logAudit logs a moderation action to the audit log
+func (s *Server) logAudit(ctx context.Context, streamerDID, moderatorDID, action, targetURI, targetDID, resultURI string, success bool, errorMsg string) error {
+	auditLog := &statedb.ModerationAuditLog{
+		StreamerDID:  streamerDID,
+		ModeratorDID: moderatorDID,
+		Action:       action,
+		TargetURI:    targetURI,
+		TargetDID:    targetDID,
+		ResultURI:    resultURI,
+		Success:      success,
+		ErrorMsg:     errorMsg,
+		CreatedAt:    time.Now(),
+	}
+
+	return s.statefulDB.CreateAuditLog(ctx, auditLog)
+}

pkg/spxrpc/spxrpc.go

···
 	ATSync       *atproto.ATProtoSynchronizer
 	statefulDB   *statedb.StatefulDB
 	bus          *bus.Bus
+	op           *oatproxy.OATProxy
 }
 
 func NewServer(ctx context.Context, cli *config.CLI, model model.Model, statefulDB *statedb.StatefulDB, op *oatproxy.OATProxy, mdlw middleware.Middleware, atsync *atproto.ATProtoSynchronizer, bus *bus.Bus) (*Server, error) {
···
 		ATSync:       atsync,
 		statefulDB:   statefulDB,
 		bus:          bus,
+		op:           op,
 	}
 	e.Use(s.ErrorHandlingMiddleware())
 	e.Use(s.ContextPreservingMiddleware())

pkg/spxrpc/stubs.go

···
 	e.GET("/xrpc/place.stream.live.getRecommendations", s.HandlePlaceStreamLiveGetRecommendations)
 	e.GET("/xrpc/place.stream.live.getSegments", s.HandlePlaceStreamLiveGetSegments)
 	e.GET("/xrpc/place.stream.live.searchActorsTypeahead", s.HandlePlaceStreamLiveSearchActorsTypeahead)
+	e.POST("/xrpc/place.stream.moderation.createBlock", s.HandlePlaceStreamModerationCreateBlock)
+	e.POST("/xrpc/place.stream.moderation.createGate", s.HandlePlaceStreamModerationCreateGate)
+	e.POST("/xrpc/place.stream.moderation.deleteBlock", s.HandlePlaceStreamModerationDeleteBlock)
+	e.POST("/xrpc/place.stream.moderation.deleteGate", s.HandlePlaceStreamModerationDeleteGate)
+	e.POST("/xrpc/place.stream.moderation.updateLivestream", s.HandlePlaceStreamModerationUpdateLivestream)
 	e.POST("/xrpc/place.stream.server.createWebhook", s.HandlePlaceStreamServerCreateWebhook)
 	e.POST("/xrpc/place.stream.server.deleteWebhook", s.HandlePlaceStreamServerDeleteWebhook)
 	e.GET("/xrpc/place.stream.server.getServerTime", s.HandlePlaceStreamServerGetServerTime)
···
 	var handleErr error
 	// func (s *Server) handlePlaceStreamLiveSearchActorsTypeahead(ctx context.Context,limit int,q string) (*placestream.LiveSearchActorsTypeahead_Output, error)
 	out, handleErr = s.handlePlaceStreamLiveSearchActorsTypeahead(ctx, limit, q)
+	if handleErr != nil {
+		return handleErr
+	}
+	return c.JSON(200, out)
+}
+
+func (s *Server) HandlePlaceStreamModerationCreateBlock(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandlePlaceStreamModerationCreateBlock")
+	defer span.End()
+
+	var body placestream.ModerationCreateBlock_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
+	var out *placestream.ModerationCreateBlock_Output
+	var handleErr error
+	// func (s *Server) handlePlaceStreamModerationCreateBlock(ctx context.Context,body *placestream.ModerationCreateBlock_Input) (*placestream.ModerationCreateBlock_Output, error)
+	out, handleErr = s.handlePlaceStreamModerationCreateBlock(ctx, &body)
+	if handleErr != nil {
+		return handleErr
+	}
+	return c.JSON(200, out)
+}
+
+func (s *Server) HandlePlaceStreamModerationCreateGate(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandlePlaceStreamModerationCreateGate")
+	defer span.End()
+
+	var body placestream.ModerationCreateGate_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
+	var out *placestream.ModerationCreateGate_Output
+	var handleErr error
+	// func (s *Server) handlePlaceStreamModerationCreateGate(ctx context.Context,body *placestream.ModerationCreateGate_Input) (*placestream.ModerationCreateGate_Output, error)
+	out, handleErr = s.handlePlaceStreamModerationCreateGate(ctx, &body)
+	if handleErr != nil {
+		return handleErr
+	}
+	return c.JSON(200, out)
+}
+
+func (s *Server) HandlePlaceStreamModerationDeleteBlock(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandlePlaceStreamModerationDeleteBlock")
+	defer span.End()
+
+	var body placestream.ModerationDeleteBlock_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
+	var out *placestream.ModerationDeleteBlock_Output
+	var handleErr error
+	// func (s *Server) handlePlaceStreamModerationDeleteBlock(ctx context.Context,body *placestream.ModerationDeleteBlock_Input) (*placestream.ModerationDeleteBlock_Output, error)
+	out, handleErr = s.handlePlaceStreamModerationDeleteBlock(ctx, &body)
+	if handleErr != nil {
+		return handleErr
+	}
+	return c.JSON(200, out)
+}
+
+func (s *Server) HandlePlaceStreamModerationDeleteGate(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandlePlaceStreamModerationDeleteGate")
+	defer span.End()
+
+	var body placestream.ModerationDeleteGate_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
+	var out *placestream.ModerationDeleteGate_Output
+	var handleErr error
+	// func (s *Server) handlePlaceStreamModerationDeleteGate(ctx context.Context,body *placestream.ModerationDeleteGate_Input) (*placestream.ModerationDeleteGate_Output, error)
+	out, handleErr = s.handlePlaceStreamModerationDeleteGate(ctx, &body)
+	if handleErr != nil {
+		return handleErr
+	}
+	return c.JSON(200, out)
+}
+
+func (s *Server) HandlePlaceStreamModerationUpdateLivestream(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandlePlaceStreamModerationUpdateLivestream")
+	defer span.End()
+
+	var body placestream.ModerationUpdateLivestream_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
+	var out *placestream.ModerationUpdateLivestream_Output
+	var handleErr error
+	// func (s *Server) handlePlaceStreamModerationUpdateLivestream(ctx context.Context,body *placestream.ModerationUpdateLivestream_Input) (*placestream.ModerationUpdateLivestream_Output, error)
+	out, handleErr = s.handlePlaceStreamModerationUpdateLivestream(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}

pkg/statedb/moderation_audit_log.go

···
+package statedb
+
+import (
+	"context"
+	"time"
+)
+
+type ModerationAuditLog struct {
+	ID           uint      `gorm:"primaryKey;autoIncrement"`
+	StreamerDID  string    `gorm:"column:streamer_did;index:idx_streamer_time,priority:1"`
+	ModeratorDID string    `gorm:"column:moderator_did;index:idx_audit_moderator"`
+	Action       string    `gorm:"column:action"`     // "createBlock", "deleteBlock", "createGate", "deleteGate", "updateLivestream"
+	TargetURI    string    `gorm:"column:target_uri"` // URI of affected resource
+	TargetDID    string    `gorm:"column:target_did"` // DID of affected user (for blocks)
+	ResultURI    string    `gorm:"column:result_uri"` // URI of created/deleted record
+	Success      bool      `gorm:"column:success"`
+	ErrorMsg     string    `gorm:"column:error_msg"`
+	CreatedAt    time.Time `gorm:"column:created_at;index:idx_streamer_time,priority:2"`
+}
+
+func (ModerationAuditLog) TableName() string {
+	return "moderation_audit_logs"
+}
+
+func (state *StatefulDB) CreateAuditLog(ctx context.Context, log *ModerationAuditLog) error {
+	return state.DB.WithContext(ctx).Create(log).Error
+}
+
+func (state *StatefulDB) GetAuditLogs(ctx context.Context, streamerDID string, limit int, before *time.Time) ([]*ModerationAuditLog, error) {
+	var logs []*ModerationAuditLog
+	query := state.DB.WithContext(ctx).Where("streamer_did = ?", streamerDID).
+		Order("created_at DESC").
+		Limit(limit)
+
+	if before != nil {
+		query = query.Where("created_at < ?", *before)
+	}
+
+	err := query.Find(&logs).Error
+	if err != nil {
+		return nil, err
+	}
+	return logs, nil
+}
+
+func (state *StatefulDB) GetModeratorAuditLogs(ctx context.Context, moderatorDID string, limit int, before *time.Time) ([]*ModerationAuditLog, error) {
+	var logs []*ModerationAuditLog
+	query := state.DB.WithContext(ctx).Where("moderator_did = ?", moderatorDID).
+		Order("created_at DESC").
+		Limit(limit)
+
+	if before != nil {
+		query = query.Where("created_at < ?", *before)
+	}
+
+	err := query.Find(&logs).Error
+	if err != nil {
+		return nil, err
+	}
+	return logs, nil
+}

pkg/statedb/statedb.go

···
 	AppTask{},
 	Repo{},
 	Webhook{},
+	ModerationAuditLog{},
 }
 
 var NoPostgresDatabaseCode = "3D000"

pkg/streamplace/cbor_gen.go

···
 
 	return nil
 }
+func (t *ModerationPermission) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 5
+
+	if t.ExpirationTime == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+		return err
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if len("$type") > 1000000 {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("place.stream.moderation.permission"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("place.stream.moderation.permission")); err != nil {
+		return err
+	}
+
+	// t.CreatedAt (string) (string)
+	if len("createdAt") > 1000000 {
+		return xerrors.Errorf("Value in field \"createdAt\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("createdAt")); err != nil {
+		return err
+	}
+
+	if len(t.CreatedAt) > 1000000 {
+		return xerrors.Errorf("Value in field t.CreatedAt was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
+		return err
+	}
+
+	// t.Moderator (string) (string)
+	if len("moderator") > 1000000 {
+		return xerrors.Errorf("Value in field \"moderator\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("moderator"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("moderator")); err != nil {
+		return err
+	}
+
+	if len(t.Moderator) > 1000000 {
+		return xerrors.Errorf("Value in field t.Moderator was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Moderator))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Moderator)); err != nil {
+		return err
+	}
+
+	// t.Permissions ([]string) (slice)
+	if len("permissions") > 1000000 {
+		return xerrors.Errorf("Value in field \"permissions\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("permissions"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("permissions")); err != nil {
+		return err
+	}
+
+	if len(t.Permissions) > 8192 {
+		return xerrors.Errorf("Slice value in field t.Permissions was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Permissions))); err != nil {
+		return err
+	}
+	for _, v := range t.Permissions {
+		if len(v) > 1000000 {
+			return xerrors.Errorf("Value in field v was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string(v)); err != nil {
+			return err
+		}
+
+	}
+
+	// t.ExpirationTime (string) (string)
+	if t.ExpirationTime != nil {
+
+		if len("expirationTime") > 1000000 {
+			return xerrors.Errorf("Value in field \"expirationTime\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("expirationTime"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("expirationTime")); err != nil {
+			return err
+		}
+
+		if t.ExpirationTime == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.ExpirationTime) > 1000000 {
+				return xerrors.Errorf("Value in field t.ExpirationTime was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ExpirationTime))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.ExpirationTime)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (t *ModerationPermission) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = ModerationPermission{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("ModerationPermission: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 14)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.CreatedAt = string(sval)
+			}
+			// t.Moderator (string) (string)
+		case "moderator":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Moderator = string(sval)
+			}
+			// t.Permissions ([]string) (slice)
+		case "permissions":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 8192 {
+				return fmt.Errorf("t.Permissions: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.Permissions = make([]string, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+						sval, err := cbg.ReadStringWithMax(cr, 1000000)
+						if err != nil {
+							return err
+						}
+
+						t.Permissions[i] = string(sval)
+					}
+
+				}
+			}
+			// t.ExpirationTime (string) (string)
+		case "expirationTime":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.ExpirationTime = (*string)(&sval)
+				}
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
 func (t *LiveRecommendations) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)

pkg/streamplace/moderationcreateBlock.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: place.stream.moderation.createBlock
+
+package streamplace
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ModerationCreateBlock_Input is the input argument to a place.stream.moderation.createBlock call.
+type ModerationCreateBlock_Input struct {
+	// reason: Optional reason for the block.
+	Reason *string `json:"reason,omitempty" cborgen:"reason,omitempty"`
+	// streamer: The DID of the streamer whose chat this block applies to.
+	Streamer string `json:"streamer" cborgen:"streamer"`
+	// subject: The DID of the user being blocked from chat.
+	Subject string `json:"subject" cborgen:"subject"`
+}
+
+// ModerationCreateBlock_Output is the output of a place.stream.moderation.createBlock call.
+type ModerationCreateBlock_Output struct {
+	// cid: The CID of the created block record.
+	Cid string `json:"cid" cborgen:"cid"`
+	// uri: The AT-URI of the created block record.
+	Uri string `json:"uri" cborgen:"uri"`
+}
+
+// ModerationCreateBlock calls the XRPC method "place.stream.moderation.createBlock".
+func ModerationCreateBlock(ctx context.Context, c lexutil.LexClient, input *ModerationCreateBlock_Input) (*ModerationCreateBlock_Output, error) {
+	var out ModerationCreateBlock_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "place.stream.moderation.createBlock", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

pkg/streamplace/moderationcreateGate.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: place.stream.moderation.createGate
+
+package streamplace
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ModerationCreateGate_Input is the input argument to a place.stream.moderation.createGate call.
+type ModerationCreateGate_Input struct {
+	// messageUri: The AT-URI of the chat message to hide.
+	MessageUri string `json:"messageUri" cborgen:"messageUri"`
+	// streamer: The DID of the streamer.
+	Streamer string `json:"streamer" cborgen:"streamer"`
+}
+
+// ModerationCreateGate_Output is the output of a place.stream.moderation.createGate call.
+type ModerationCreateGate_Output struct {
+	// cid: The CID of the created gate record.
+	Cid string `json:"cid" cborgen:"cid"`
+	// uri: The AT-URI of the created gate record.
+	Uri string `json:"uri" cborgen:"uri"`
+}
+
+// ModerationCreateGate calls the XRPC method "place.stream.moderation.createGate".
+func ModerationCreateGate(ctx context.Context, c lexutil.LexClient, input *ModerationCreateGate_Input) (*ModerationCreateGate_Output, error) {
+	var out ModerationCreateGate_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "place.stream.moderation.createGate", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

pkg/streamplace/moderationdefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: place.stream.moderation.defs
+
+package streamplace
+
+import (
+	appbsky "github.com/bluesky-social/indigo/api/bsky"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ModerationDefs_PermissionView is a "permissionView" in the place.stream.moderation.defs schema.
+type ModerationDefs_PermissionView struct {
+	// author: The streamer who granted these permissions
+	Author *appbsky.ActorDefs_ProfileViewBasic `json:"author" cborgen:"author"`
+	// cid: Content identifier of the permission record
+	Cid string `json:"cid" cborgen:"cid"`
+	// record: The permission record itself
+	Record *lexutil.LexiconTypeDecoder `json:"record" cborgen:"record"`
+	// uri: AT-URI of the permission record
+	Uri string `json:"uri" cborgen:"uri"`
+}

pkg/streamplace/moderationdeleteBlock.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: place.stream.moderation.deleteBlock
+
+package streamplace
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ModerationDeleteBlock_Input is the input argument to a place.stream.moderation.deleteBlock call.
+type ModerationDeleteBlock_Input struct {
+	// blockUri: The AT-URI of the block record to delete.
+	BlockUri string `json:"blockUri" cborgen:"blockUri"`
+	// streamer: The DID of the streamer.
+	Streamer string `json:"streamer" cborgen:"streamer"`
+}
+
+// ModerationDeleteBlock_Output is the output of a place.stream.moderation.deleteBlock call.
+type ModerationDeleteBlock_Output struct {
+}
+
+// ModerationDeleteBlock calls the XRPC method "place.stream.moderation.deleteBlock".
+func ModerationDeleteBlock(ctx context.Context, c lexutil.LexClient, input *ModerationDeleteBlock_Input) (*ModerationDeleteBlock_Output, error) {
+	var out ModerationDeleteBlock_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "place.stream.moderation.deleteBlock", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

pkg/streamplace/moderationdeleteGate.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: place.stream.moderation.deleteGate
+
+package streamplace
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ModerationDeleteGate_Input is the input argument to a place.stream.moderation.deleteGate call.
+type ModerationDeleteGate_Input struct {
+	// gateUri: The AT-URI of the gate record to delete.
+	GateUri string `json:"gateUri" cborgen:"gateUri"`
+	// streamer: The DID of the streamer.
+	Streamer string `json:"streamer" cborgen:"streamer"`
+}
+
+// ModerationDeleteGate_Output is the output of a place.stream.moderation.deleteGate call.
+type ModerationDeleteGate_Output struct {
+}
+
+// ModerationDeleteGate calls the XRPC method "place.stream.moderation.deleteGate".
+func ModerationDeleteGate(ctx context.Context, c lexutil.LexClient, input *ModerationDeleteGate_Input) (*ModerationDeleteGate_Output, error) {
+	var out ModerationDeleteGate_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "place.stream.moderation.deleteGate", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

pkg/streamplace/moderationpermission.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: place.stream.moderation.permission
+
+package streamplace
+
+import (
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+func init() {
+	lexutil.RegisterType("place.stream.moderation.permission", &ModerationPermission{})
+}
+
+type ModerationPermission struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=place.stream.moderation.permission"`
+	// createdAt: Client-declared timestamp when this moderator was added.
+	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
+	// expirationTime: Optional expiration time for this delegation. If set, the delegation is invalid after this time.
+	ExpirationTime *string `json:"expirationTime,omitempty" cborgen:"expirationTime,omitempty"`
+	// moderator: The DID of the user granted moderator permissions.
+	Moderator string `json:"moderator" cborgen:"moderator"`
+	// permissions: Array of permissions granted to this moderator. 'ban' covers blocks/bans (with optional expiration), 'hide' covers message gates, 'livestream.manage' allows updating livestream metadata.
+	Permissions []string `json:"permissions" cborgen:"permissions"`
+}

pkg/streamplace/moderationupdateLivestream.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: place.stream.moderation.updateLivestream
+
+package streamplace
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ModerationUpdateLivestream_Input is the input argument to a place.stream.moderation.updateLivestream call.
+type ModerationUpdateLivestream_Input struct {
+	// livestreamUri: The AT-URI of the livestream record to update.
+	LivestreamUri string `json:"livestreamUri" cborgen:"livestreamUri"`
+	// streamer: The DID of the streamer.
+	Streamer string `json:"streamer" cborgen:"streamer"`
+	// title: New title for the livestream.
+	Title *string `json:"title,omitempty" cborgen:"title,omitempty"`
+}
+
+// ModerationUpdateLivestream_Output is the output of a place.stream.moderation.updateLivestream call.
+type ModerationUpdateLivestream_Output struct {
+	// cid: The CID of the updated livestream record.
+	Cid string `json:"cid" cborgen:"cid"`
+	// uri: The AT-URI of the updated livestream record.
+	Uri string `json:"uri" cborgen:"uri"`
+}
+
+// ModerationUpdateLivestream calls the XRPC method "place.stream.moderation.updateLivestream".
+func ModerationUpdateLivestream(ctx context.Context, c lexutil.LexClient, input *ModerationUpdateLivestream_Input) (*ModerationUpdateLivestream_Output, error) {
+	var out ModerationUpdateLivestream_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "place.stream.moderation.updateLivestream", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}