Merge pull request #979 from streamplace/natb/pinners

feat: chat pinning

js/app/src/screens/chat-popout.native.tsx

···
   ChatBox,
   LivestreamProvider,
   PlayerProvider,
+  StreamNotificationProvider,
   Text,
   useKeyboard,
   useLivestreamInfo,
···
           </View>
         </View>
         <View style={[zero.flex.values[1], zero.p[4]]}>
-          <Chat />
+          <StreamNotificationProvider position="top">
+            <Chat />
+          </StreamNotificationProvider>
           {profile && <ChatBox emojiData={emojiData} isPopout={true} />}
         </View>
       </View>

js/app/src/screens/chat-popout.tsx

···
   ChatBox,
   LivestreamProvider,
   PlayerProvider,
+  StreamNotificationProvider,
   Text,
   tokens,
   usePlayerStore,
···
   reverse?: string;
   hideAfter?: string;
   hideChatBox?: string;
+  showNotifications?: string;
 }
 
 export default function PopoutChat({ route }) {
···
     ? parseInt(params.hideAfter, 10)
     : undefined;
   const hideChatBox = params.hideChatBox === "true";
+  const showNotifications = params.showNotifications === "true";
 
   useEffect(() => {
     setSrc(params.user);
   }, [params.user, setSrc]);
 
+  const chat = (
+    <Chat
+      reverse={reverseChat}
+      hideAfter={hideAfter}
+      style={[zero.flex.values[1]]}
+    />
+  );
+
   return (
-    <View style={[{ position: "relative" }, zero.flex.values[1], zero.m[2]]}>
-      <View
-        style={[
-          zero.flex.values[1],
-          { position: "absolute", width: "100%", minHeight: "100%", bottom: 0 },
-        ]}
-      >
-        <Chat reverse={reverseChat} hideAfter={hideAfter} />
-        {!hideChatBox &&
-          (profile ? (
-            <ChatBox
-              emojiData={emojiData}
-              isPopout={true}
-              emojiPicker={(isOpen, onClose, onSelect) => (
-                <EmojiPicker
-                  isOpen={isOpen}
-                  onClose={onClose}
-                  onSelect={onSelect}
-                  customEmoji={[]}
-                />
-              )}
-            />
-          ) : (
-            <Pressable
-              onPress={() => openLoginModal({ name: "ChatPopout" })}
-              style={[
-                zero.layout.flex.row,
-                zero.layout.flex.center,
-                zero.gap.all[4],
-                zero.r.xl,
-                {
-                  padding: 18,
-                  backgroundColor: "rgba(255, 255, 255, 0.1)",
-                  maxWidth: tokens.breakpoints.sm,
-                },
-              ]}
-            >
-              <Text>Log in or sign up to chat</Text>
-              <ArrowRight />
-            </Pressable>
-          ))}
-      </View>
+    <View
+      style={[
+        zero.flex.values[1],
+        zero.layout.flex.column,
+        zero.m[2],
+        { maxHeight: "100vh" },
+      ]}
+    >
+      {showNotifications ? (
+        <StreamNotificationProvider position="top">
+          {chat}
+        </StreamNotificationProvider>
+      ) : (
+        chat
+      )}
+      {!hideChatBox &&
+        (profile ? (
+          <ChatBox
+            emojiData={emojiData}
+            isPopout={true}
+            emojiPicker={(isOpen, onClose, onSelect) => (
+              <EmojiPicker
+                isOpen={isOpen}
+                onClose={onClose}
+                onSelect={onSelect}
+                customEmoji={[]}
+              />
+            )}
+          />
+        ) : (
+          <Pressable
+            onPress={() => openLoginModal({ name: "ChatPopout" })}
+            style={[
+              zero.layout.flex.row,
+              zero.layout.flex.center,
+              zero.gap.all[4],
+              zero.r.xl,
+              {
+                padding: 18,
+                backgroundColor: "rgba(255, 255, 255, 0.1)",
+                maxWidth: tokens.breakpoints.sm,
+              },
+            ]}
+          >
+            <Text>Log in or sign up to chat</Text>
+            <ArrowRight />
+          </Pressable>
+        ))}
     </View>
   );
 }

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

···
 import {
   useDeleteChatMessage,
   useLivestreamStore,
+  usePinChatMessage,
 } from "../../livestream-store";
 import { useStreamplaceStore } from "../../streamplace-store";
 import { formatHandle, formatHandleWithAt } from "../../utils/format-handle";
···
   DropdownMenu,
   DropdownMenuGroup,
   DropdownMenuItem,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
   DropdownMenuTrigger,
   layout,
   ResponsiveDropdownMenuContent,
···
   let [messageRemoved, setMessageRemoved] = useState(false);
   let { createBlock, isLoading: isBlockLoading } = useCreateBlockRecord();
   let { createHideChat, isLoading: isHideLoading } = useCreateHideChatRecord();
+  const pinChatMessage = usePinChatMessage();
 
   const setReportModalOpen = usePlayerStore((x) => x.setReportModalOpen);
   const setReportSubject = usePlayerStore((x) => x.setReportSubject);
···
     message &&
     agent?.did &&
     ((modPermissions.canHide && message.author.did !== streamerDID) ||
-      (modPermissions.canBan &&
-        message.author.did !== agent.did &&
-        message.author.did !== streamerDID))
+      (modPermissions.canPin && message.author.did !== streamerDID) ||
+      modPermissions.canBan)
   );
 
   return (
···
               setMessageRemoved={setMessageRemoved}
               createHideChat={createHideChat}
               createBlock={createBlock}
+              pinChatMessage={pinChatMessage}
               toast={toast}
               setReportModalOpen={setReportModalOpen}
               setReportSubject={setReportSubject}
···
   setMessageRemoved: (removed: boolean) => void;
   createHideChat: (uri: string, streamerDID?: string) => Promise<any>;
   createBlock: (did: string, streamerDID?: string) => Promise<any>;
+  pinChatMessage: (
+    messageUri: string,
+    streamerDID: string,
+    expiresAt?: string,
+  ) => Promise<any>;
   toast: ReturnType<typeof useToast>;
   setReportModalOpen: (open: boolean) => void;
   setReportSubject: (subject: any) => void;
···
   setMessageRemoved,
   createHideChat,
   createBlock,
+  pinChatMessage,
   toast,
   setReportModalOpen,
   setReportSubject,
···
                     : "Hide this message"}
               </Text>
             </DropdownMenuItem>
+          )}
+          {modPermissions.canPin && (
+            <DropdownMenuGroup key="pin-actions">
+              <DropdownMenuSub>
+                <DropdownMenuSubTrigger
+                  subMenuTitle="Pin message"
+                  style={{ padding: 0, margin: 0 }}
+                >
+                  <Text color="primary">Pin this message</Text>
+                </DropdownMenuSubTrigger>
+                <DropdownMenuSubContent>
+                  <DropdownMenuGroup title="Pin duration">
+                    <DropdownMenuItem
+                      onPress={() => {
+                        if (!streamerDID) return;
+                        pinChatMessage(message.uri, streamerDID)
+                          .then(() => {
+                            toast.show("Comment pinned", "", { duration: 3 });
+                            onOpenChange?.(false);
+                          })
+                          .catch((e) => {
+                            toast.show(
+                              "Error pinning comment",
+                              e instanceof Error ? e.message : "Failed to pin",
+                              { duration: 5 },
+                            );
+                          });
+                      }}
+                    >
+                      <Text color="primary">Until stream end</Text>
+                    </DropdownMenuItem>
+                    {[5, 10, 15, 30, 60].map((minutes) => (
+                      <DropdownMenuItem
+                        key={minutes}
+                        onPress={() => {
+                          if (!streamerDID) return;
+                          const expiresAt = new Date(
+                            Date.now() + minutes * 60 * 1000,
+                          );
+                          pinChatMessage(
+                            message.uri,
+                            streamerDID,
+                            expiresAt.toISOString(),
+                          )
+                            .then(() => {
+                              toast.show("Comment pinned", "", { duration: 3 });
+                              onOpenChange?.(false);
+                            })
+                            .catch((e) => {
+                              toast.show(
+                                "Error pinning comment",
+                                e instanceof Error
+                                  ? e.message
+                                  : "Failed to pin",
+                                { duration: 5 },
+                              );
+                            });
+                        }}
+                      >
+                        <Text color="primary">
+                          {minutes < 60 ? `${minutes} min` : "1 hour"}
+                        </Text>
+                      </DropdownMenuItem>
+                    ))}
+                  </DropdownMenuGroup>
+                </DropdownMenuSubContent>
+              </DropdownMenuSub>
+            </DropdownMenuGroup>
           )}
           {modPermissions.canBan &&
             agent?.did &&

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

···
     ban: false,
     hide: false,
     "livestream.manage": false,
+    "message.pin": false,
   });
   const [error, setError] = useState<string | null>(null);
   const toast = useToast();
···
   useEffect(() => {
     if (!visible) {
       setModeratorDID("");
-      setPermissions({ ban: false, hide: false, "livestream.manage": false });
+      setPermissions({
+        ban: false,
+        hide: false,
+        "livestream.manage": false,
+        "message.pin": false,
+      });
       setError(null);
     }
   }, [visible]);
···
 
     const selectedPermissions = Object.entries(permissions)
       .filter(([_, enabled]) => enabled)
-      .map(([perm]) => perm) as ("ban" | "hide" | "livestream.manage")[];
+      .map(([perm]) => perm) as (
+      | "ban"
+      | "hide"
+      | "livestream.manage"
+      | "message.pin"
+    )[];
 
     if (selectedPermissions.length === 0) {
       setError("Please select at least one permission");

js/components/src/components/stream-notification/pin-notification.tsx

···
+import { EyeOff, Pin, X } from "lucide-react-native";
+import { useEffect, useState } from "react";
+import { Linking, Pressable, View } from "react-native";
+import { PinnedRecordViewHydrated, PlaceStreamChatProfile } from "streamplace";
+import {
+  Text,
+  useCanModerate,
+  useLivestreamStore,
+  useTheme,
+  zero,
+} from "../../";
+import { RichtextSegment, segmentize } from "../../lib/facet";
+import { formatHandleWithAt } from "../../utils/format-handle";
+
+const getRgbColor = (color?: PlaceStreamChatProfile.Color) =>
+  color ? `rgb(${color.red}, ${color.green}, ${color.blue})` : undefined;
+
+function renderSegment(segment: RichtextSegment, index: number) {
+  if (segment.features && segment.features.length > 0) {
+    const ftr = segment.features[0];
+    if (ftr.$type === "app.bsky.richtext.facet#link") {
+      return (
+        <Text
+          key={index}
+          style={[{ color: "#007AFF" }]}
+          onPress={() => Linking.openURL((ftr as any).uri || "")}
+        >
+          {segment.text}
+        </Text>
+      );
+    }
+    if (ftr.$type === "app.bsky.richtext.facet#mention") {
+      return (
+        <Text key={index} style={[{ color: "#007AFF" }]}>
+          {segment.text}
+        </Text>
+      );
+    }
+  }
+  return <Text key={index}>{segment.text}</Text>;
+}
+
+export function PinnedCommentNotification({
+  pinnedComment,
+  onDismiss,
+  onUnpin,
+}: {
+  pinnedComment: PinnedRecordViewHydrated;
+  onDismiss: () => void;
+  onUnpin: () => void;
+}) {
+  const z = useTheme();
+  const message = pinnedComment.message;
+  const pinnedByColor = (pinnedComment.pinnedBy as any)?.color || "#bebebe";
+  const record = pinnedComment.record;
+
+  const currentStreamer = useLivestreamStore((state) => state.profile?.did);
+
+  console.log("checking if we can mod", currentStreamer);
+
+  const canActuallyPin = useCanModerate(currentStreamer)?.canPin;
+
+  const messageRecord = message?.record as any;
+
+  const [expiresAt] = useState<Date | null>(
+    record.expiresAt ? new Date(record.expiresAt) : null,
+  );
+
+  useEffect(() => {
+    if (!expiresAt) return;
+    const remaining = expiresAt.getTime() - Date.now();
+    if (remaining <= 0) {
+      onDismiss();
+      return;
+    }
+    const timeout = setTimeout(onDismiss, remaining);
+    return () => clearTimeout(timeout);
+  }, [expiresAt, onDismiss]);
+
+  const authorName = message ? formatHandleWithAt(message.author) : "unknown";
+  const authorColor = getRgbColor((message as any)?.chatProfile?.color);
+
+  const segments = messageRecord
+    ? segmentize(messageRecord.text, messageRecord.facets)
+    : [];
+
+  return (
+    <View style={[zero.bg.neutral[900], zero.r.lg, { overflow: "hidden" }]}>
+      <View
+        style={[
+          zero.layout.flex.row,
+          zero.layout.flex.alignCenter,
+          zero.px[3],
+          zero.py[2],
+          { gap: 8 },
+        ]}
+      >
+        <View style={{ transform: [{ rotate: "-25deg" }] }}>
+          <Pin
+            size={24}
+            color={authorColor || z.theme.colors.primary}
+            fill={authorColor || z.theme.colors.primary}
+          />
+        </View>
+        <View
+          style={[zero.layout.flex.column, zero.flex.values[1], { gap: 4 }]}
+        >
+          <View style={[zero.layout.flex.row, { gap: 4, flexWrap: "wrap" }]}>
+            <Text
+              style={[
+                {
+                  fontWeight: "600",
+                  color: authorColor || zero.colors.gray[200],
+                },
+              ]}
+            >
+              {authorName}
+            </Text>
+            {segments.map((seg, i) => renderSegment(seg, i))}
+          </View>
+        </View>
+        <View style={[zero.layout.flex.row, { gap: 4 }]}>
+          {canActuallyPin && (
+            <Pressable onPress={onUnpin} style={{ padding: 4 }}>
+              <X size={16} color={zero.colors.gray[400]} />
+            </Pressable>
+          )}
+          <Pressable onPress={onDismiss} style={{ padding: 4 }}>
+            <EyeOff size={16} color={zero.colors.gray[400]} />
+          </Pressable>
+        </View>
+      </View>
+    </View>
+  );
+}

js/components/src/components/ui/dropdown.tsx

···
     inset?: boolean;
     children?: React.ReactNode;
   }
->(({ inset, children, subMenuTitle, ...props }, ref) => {
+>(({ inset, children, subMenuTitle, style, ...props }, ref) => {
   const { icons } = useTheme();
   const { open } = DropdownMenuPrimitive.useSubContext();
   const Icon =
···
             layout.flex.alignCenter,
             p[2],
             pr[8],
+            style,
           ]}
         >
           {children}
···
   const { theme } = useTheme();
   const { inset, title, children, ...rest } = props;
   return (
-    <View style={[pt[2], inset && gap[2]]} ref={ref} {...rest}>
+    <View style={[inset && gap[2]]} ref={ref} {...rest}>
       {title && (
         <Text style={[{ color: theme.colors.textMuted }, pb[1], pl[2]]}>
           {title}

js/components/src/components/ui/resizeable.tsx

···
 const { height: SCREEN_HEIGHT } = Dimensions.get("window");
 
 const TIMING_CONFIG = {
-  duration: 300,
-  easing: Easing.inOut(Easing.quad),
+  duration: 400,
+  easing: Easing.out(Easing.quad),
 };
 
 type ResizableChatSheetProps = {

js/components/src/lib/stream-notifications.ts

···
 import React from "react";
+import { PinnedRecordViewHydrated } from "streamplace";
 import { streamNotification } from "../components/stream-notification";
+import { PinnedCommentNotification } from "../components/stream-notification/pin-notification";
 import { TeleportNotification } from "../components/stream-notification/teleport-notification";
 
 export const StreamNotifications = {
+  pinnedComment: (params: {
+    pinnedComment: PinnedRecordViewHydrated;
+    onDismiss?: (reason?: "user" | "auto") => void;
+    onUnpin?: () => void;
+  }) => {
+    streamNotification.show({
+      id: "pinned-comment",
+      render: (isExiting, onDismiss) => {
+        return React.createElement(PinnedCommentNotification, {
+          pinnedComment: params.pinnedComment,
+          onDismiss: () => onDismiss("user"),
+          onUnpin: () => {
+            params.onUnpin?.();
+            onDismiss("user");
+          },
+        });
+      },
+      duration: 0, // manually dismissed or auto-dismissed by TTL
+      onDismiss: params.onDismiss,
+    });
+  },
+
+  pinnedCommentDismiss: () => {
+    streamNotification.hide("pinned-comment");
+  },
+
   teleport: (params: {
     targetHandle: string;
     targetDID: string;

js/components/src/livestream-provider/index.tsx

···
 import { StreamNotifications } from "../lib/stream-notifications";
 import {
   LivestreamContext,
+  getStoreFromContext,
   makeLivestreamStore,
   useLivestreamStore,
+  usePinnedComment,
+  useUnpinChatMessage,
 } from "../livestream-store";
 import { useDID, usePDSAgent } from "../streamplace-store";
 import { useLivestreamWebsocket } from "./websocket";
···
   return <></>;
 }
 
+export function PinnedCommentWatcher() {
+  const pinnedComment = usePinnedComment();
+  const streamerDID = useLivestreamStore((state) => state.profile?.did);
+  const unpinChatMessage = useUnpinChatMessage();
+  const store = getStoreFromContext();
+  const prevPinnedRef = useRef<string | null>(null);
+
+  // Show/hide notification when pinned comment changes
+  useEffect(() => {
+    const currentUri = pinnedComment?.uri ?? null;
+    if (currentUri === prevPinnedRef.current) return;
+    prevPinnedRef.current = currentUri;
+
+    if (pinnedComment) {
+      StreamNotifications.pinnedComment({
+        pinnedComment,
+        onDismiss: () => {
+          store.setState({ pinnedComment: null });
+        },
+        onUnpin: () => {
+          if (!streamerDID) return;
+          unpinChatMessage(pinnedComment.uri, streamerDID).catch((e) => {
+            console.error("Failed to unpin:", e);
+          });
+        },
+      });
+    } else {
+      StreamNotifications.pinnedCommentDismiss();
+    }
+  }, [pinnedComment, streamerDID, unpinChatMessage]);
+
+  return <></>;
+}
+
 export function LivestreamPoller({
   children,
   src,
···
   src: string;
   onTeleport?: (targetHandle: string, targetDID: string) => void;
 }) {
-  // Websocket watcher is a sibling instead of a parent to avoid
-  // re-rendering when the websocket does stuff
   return (
     <>
       <WebsocketWatcher src={src} />
       <TeleportWatcher onTeleport={onTeleport} />
+      <PinnedCommentWatcher />
       {children}
     </>
   );

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

···
 };
 
 export const reduceChat = reduceChatIncremental;
+
+export const usePinChatMessage = () => {
+  const agent = usePDSAgent();
+  const store = getStoreFromContext();
+
+  return async (
+    messageUri: string,
+    streamerDID: string,
+    expiresAt?: string,
+  ) => {
+    if (!agent || !agent.did) {
+      throw new Error("No PDS agent or user DID found");
+    }
+
+    // If streamer, create directly
+    if (agent.did === streamerDID) {
+      // First delete any existing pinned records
+      const listResult = await agent.com.atproto.repo.listRecords({
+        repo: streamerDID,
+        collection: "place.stream.chat.pinnedRecord",
+      });
+      for (const rec of listResult.data.records) {
+        const rkey = rec.uri.split("/").pop();
+        if (rkey) {
+          await agent.com.atproto.repo.deleteRecord({
+            repo: streamerDID,
+            collection: "place.stream.chat.pinnedRecord",
+            rkey,
+          });
+        }
+      }
+
+      const record = {
+        $type: "place.stream.chat.pinnedRecord",
+        pinnedMessage: messageUri,
+        createdAt: new Date().toISOString(),
+        ...(expiresAt ? { expiresAt } : {}),
+      };
+
+      const result = await agent.com.atproto.repo.createRecord({
+        repo: streamerDID,
+        collection: "place.stream.chat.pinnedRecord",
+        record,
+      });
+      return result;
+    }
+
+    // Otherwise, use delegated moderation endpoint
+    const result = await agent.place.stream.moderation.createPin({
+      streamer: streamerDID,
+      messageUri,
+      ...(expiresAt ? { expiresAt } : {}),
+    });
+    return result;
+  };
+};
+
+export const useUnpinChatMessage = () => {
+  const agent = usePDSAgent();
+  const store = getStoreFromContext();
+
+  return async (pinUri: string, streamerDID: string) => {
+    if (!agent || !agent.did) {
+      throw new Error("No PDS agent or user DID found");
+    }
+
+    // If streamer, delete directly
+    if (agent.did === streamerDID) {
+      const rkey = pinUri.split("/").pop();
+      if (!rkey) {
+        throw new Error("Invalid pin URI");
+      }
+
+      await agent.com.atproto.repo.deleteRecord({
+        repo: streamerDID,
+        collection: "place.stream.chat.pinnedRecord",
+        rkey,
+      });
+      // Optimistically clear the pinned comment
+      store.setState({ pinnedComment: null });
+      return;
+    }
+
+    // Otherwise, use delegated moderation endpoint
+    await agent.place.stream.moderation.deletePin({
+      streamer: streamerDID,
+      pinUri,
+    });
+    // Optimistically clear the pinned comment
+    store.setState({ pinnedComment: null });
+  };
+};

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

···
 import {
   ChatMessageViewHydrated,
   LivestreamViewHydrated,
+  PinnedRecordViewHydrated,
   PlaceStreamDefs,
   PlaceStreamLiveTeleport,
   PlaceStreamModerationPermission,
···
   setActiveTeleportUri: (uri: string | null) => void;
   websocketConnected: boolean;
   hasReceivedSegment: boolean;
+  pinnedComment: PinnedRecordViewHydrated | null;
   moderationPermissions: PlaceStreamModerationPermission.Record[];
   setModerationPermissions: (
     permissions: PlaceStreamModerationPermission.Record[],

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

···
     setActiveTeleportUri: (uri) => set({ activeTeleportUri: uri }),
     websocketConnected: false,
     hasReceivedSegment: false,
+    pinnedComment: null,
     moderationPermissions: [],
     setModerationPermissions: (perms) => set({ moderationPermissions: perms }),
     localLivestreamURI: null,
···
 };
 
 export const useChat = () => useLivestreamStore((x) => x.chat);
+
+export const usePinnedComment = () =>
+  useLivestreamStore((x) => x.pinnedComment);
 
 export const useProfile = () => useLivestreamStore((x) => x.profile);
 

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

···
 import {
   ChatMessageViewHydrated,
   LivestreamViewHydrated,
+  PinnedRecordViewHydrated,
   PlaceStreamChatDefs,
   PlaceStreamChatGate,
   PlaceStreamChatMessage,
···
           pendingHides: newPendingHides,
         };
         state = reduceChat(state, [], [], [hiddenMessageUri]);
+      } else if (PlaceStreamChatDefs.isPinnedRecordView(message)) {
+        const pinnedView = message as PinnedRecordViewHydrated;
+        state = {
+          ...state,
+          pinnedComment: pinnedView,
+        };
+      } else if (
+        (message as any).$type === "place.stream.chat.pinnedRecord" &&
+        (message as any).deleted === true
+      ) {
+        state = {
+          ...state,
+          pinnedComment: null,
+        };
       } else if (PlaceStreamLiveTeleport.isRecord(message)) {
         const teleportRecord = message as PlaceStreamLiveTeleport.Record;
         state = {

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

···
 export interface ModerationPermissions {
   canBan: boolean;
   canHide: boolean;
+  canPin: boolean;
   canManageLivestream: boolean;
   isOwner: boolean;
   isLoading: boolean;
···
   return {
     canBan: isOwner || permissions.includes("ban"),
     canHide: isOwner || permissions.includes("hide"),
+    canPin: isOwner || permissions.includes("message.pin"),
     canManageLivestream: isOwner || permissions.includes("livestream.manage"),
     isOwner,
     isLoading,

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

···
 
 interface AddModeratorParams {
   moderatorDID: string;
-  permissions: ("ban" | "hide" | "livestream.manage")[];
+  permissions: ("ban" | "hide" | "livestream.manage" | "message.pin")[];
   expirationTime?: string; // ISO 8601 datetime string
 }
 

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

···
 
 ---
 
+<a name="pinnedrecordview"></a>
+
+### `pinnedRecordView`
+
+**Type:** `object`
+
+View of a pinned chat record with hydrated message data.
+
+**Properties:**
+
+| Name        | Type                                                                              | Req'd | Description | Constraints        |
+| ----------- | --------------------------------------------------------------------------------- | ----- | ----------- | ------------------ |
+| `uri`       | `string`                                                                          | ✅    |             | Format: `at-uri`   |
+| `cid`       | `string`                                                                          | ✅    |             | Format: `cid`      |
+| `record`    | [`place.stream.chat.pinnedRecord`](/lex-reference/place-stream-chat-pinnedrecord) | ✅    |             |                    |
+| `indexedAt` | `string`                                                                          | ✅    |             | Format: `datetime` |
+| `pinnedBy`  | [`place.stream.chat.profile`](/lex-reference/place-stream-chat-profile)           | ❌    |             |                    |
+| `message`   | [`#messageView`](#messageview)                                                    | ❌    |             |                    |
+
+---
+
 ## Lexicon Source
 
 ```json
···
             "type": "ref",
             "ref": "place.stream.badge.defs#badgeView"
           }
+        }
+      }
+    },
+    "pinnedRecordView": {
+      "type": "object",
+      "description": "View of a pinned chat record with hydrated message data.",
+      "required": ["uri", "cid", "record", "indexedAt"],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "record": {
+          "type": "ref",
+          "ref": "place.stream.chat.pinnedRecord"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "pinnedBy": {
+          "type": "ref",
+          "ref": "place.stream.chat.profile"
+        },
+        "message": {
+          "type": "ref",
+          "ref": "#messageView"
         }
       }
     }

js/docs/src/content/docs/lex-reference/chat/place-stream-chat-pinnedrecord.md

···
+---
+title: place.stream.chat.pinnedRecord
+description: Reference for the place.stream.chat.pinnedRecord lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `record`
+
+Record pinning a chat message for prominent display.
+
+**Record Key:** `tid`
+
+**Record Properties:**
+
+| Name            | Type     | Req'd | Description                                                                       | Constraints        |
+| --------------- | -------- | ----- | --------------------------------------------------------------------------------- | ------------------ |
+| `pinnedMessage` | `string` | ✅    | AT-URI of the pinned chat message.                                                | Format: `at-uri`   |
+| `pinnedBy`      | `string` | ❌    | DID of the user who pinned the message.                                           | Format: `did`      |
+| `createdAt`     | `string` | ✅    | When this pin was created.                                                        | Format: `datetime` |
+| `expiresAt`     | `string` | ❌    | Optional expiration time. If set, the pin is considered inactive after this time. | Format: `datetime` |
+
+---
+
+## Lexicon Source
+
+```json
+{
+  "lexicon": 1,
+  "id": "place.stream.chat.pinnedRecord",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "description": "Record pinning a chat message for prominent display.",
+      "record": {
+        "type": "object",
+        "required": ["pinnedMessage", "createdAt"],
+        "properties": {
+          "pinnedMessage": {
+            "type": "string",
+            "format": "at-uri",
+            "description": "AT-URI of the pinned chat message."
+          },
+          "pinnedBy": {
+            "type": "string",
+            "format": "did",
+            "description": "DID of the user who pinned the message."
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "When this pin was created."
+          },
+          "expiresAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Optional expiration time. If set, the pin is considered inactive after this time."
+          }
+        }
+      }
+    }
+  }
+}
+```

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

···
+---
+title: place.stream.moderation.createPin
+description: Reference for the place.stream.moderation.createPin lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `procedure`
+
+Pin a chat message on behalf of a streamer. Requires 'message.pin' permission. Creates a place.stream.chat.pinnedRecord in the streamer's repo, replacing any existing pin.
+
+**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 pin. | Format: `at-uri`   |
+| `expiresAt`  | `string` | ❌    | Optional expiration time for this pin. | Format: `datetime` |
+
+**Output:**
+
+- **Encoding:** `application/json`
+- **Schema:**
+
+**Schema Type:** `object`
+
+| Name  | Type     | Req'd | Description                              | Constraints      |
+| ----- | -------- | ----- | ---------------------------------------- | ---------------- |
+| `uri` | `string` | ✅    | The AT-URI of the created pinned record. | Format: `at-uri` |
+| `cid` | `string` | ✅    | The CID of the created pinned record.    | Format: `cid`    |
+
+**Possible Errors:**
+
+- `Unauthorized`: The request lacks valid authentication credentials.
+- `Forbidden`: The caller does not have permission to pin 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.createPin",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Pin a chat message on behalf of a streamer. Requires 'message.pin' permission. Creates a place.stream.chat.pinnedRecord in the streamer's repo, replacing any existing pin.",
+      "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 pin."
+            },
+            "expiresAt": {
+              "type": "string",
+              "format": "datetime",
+              "description": "Optional expiration time for this pin."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the created pinned record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the created pinned record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to pin 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-deletepin.md

···
+---
+title: place.stream.moderation.deletePin
+description: Reference for the place.stream.moderation.deletePin lexicon
+---
+
+**Lexicon Version:** 1
+
+## Definitions
+
+<a name="main"></a>
+
+### `main`
+
+**Type:** `procedure`
+
+Unpin a pinned chat message on behalf of a streamer. Requires 'message.pin' permission. Deletes the place.stream.chat.pinnedRecord from the streamer's repo.
+
+**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`    |
+| `pinUri`   | `string` | ✅    | The AT-URI of the pinned 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 unpin 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.deletePin",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Unpin a pinned chat message on behalf of a streamer. Requires 'message.pin' permission. Deletes the place.stream.chat.pinnedRecord from the streamer's repo.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "pinUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "pinUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the pinned 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 unpin 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

···
             "type": "array",
             "items": {
               "type": "string",
-              "enum": ["ban", "hide", "livestream.manage"]
+              "enum": ["ban", "hide", "livestream.manage", "message.pin"]
             },
             "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."
           },

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

···
         }
       }
     },
+    "/xrpc/place.stream.moderation.createPin": {
+      "post": {
+        "summary": "Pin a chat message on behalf of a streamer. Requires 'message.pin' permission. Creates a place.stream.chat.pinnedRecord in the streamer's repo, replacing any existing pin.",
+        "operationId": "place.stream.moderation.createPin",
+        "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 pinned record.",
+                      "format": "uri"
+                    },
+                    "cid": {
+                      "type": "string",
+                      "description": "The CID of the created pinned 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 pin.",
+                    "format": "uri"
+                  },
+                  "expiresAt": {
+                    "type": "string",
+                    "description": "Optional expiration time for this pin.",
+                    "format": "date-time"
+                  }
+                },
+                "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.",
···
                   }
                 },
                 "required": ["streamer", "gateUri"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "/xrpc/place.stream.moderation.deletePin": {
+      "post": {
+        "summary": "Unpin a pinned chat message on behalf of a streamer. Requires 'message.pin' permission. Deletes the place.stream.chat.pinnedRecord from the streamer's repo.",
+        "operationId": "place.stream.moderation.deletePin",
+        "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"
+                  },
+                  "pinUri": {
+                    "type": "string",
+                    "description": "The AT-URI of the pinned record to delete.",
+                    "format": "uri"
+                  }
+                },
+                "required": ["streamer", "pinUri"]
               }
             }
           }

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

···
 
 **Properties:**
 
-| Name         | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Req'd | Description | Constraints |
-| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- | ----------- | ----------- |
-| `livestream` | Union of:<br/>&nbsp;&nbsp;[`#livestreamView`](#livestreamview)<br/>&nbsp;&nbsp;[`#viewerCount`](#viewercount)<br/>&nbsp;&nbsp;[`#teleportArrival`](#teleportarrival)<br/>&nbsp;&nbsp;[`#teleportCanceled`](#teleportcanceled)<br/>&nbsp;&nbsp;[`place.stream.defs#blockView`](/lex-reference/place-stream-defs#blockview)<br/>&nbsp;&nbsp;[`place.stream.defs#renditions`](/lex-reference/place-stream-defs#renditions)<br/>&nbsp;&nbsp;[`place.stream.defs#rendition`](/lex-reference/place-stream-defs#rendition)<br/>&nbsp;&nbsp;[`place.stream.chat.defs#messageView`](/lex-reference/place-stream-chat-defs#messageview) | ✅    |             |             |
+| Name         | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Req'd | Description | Constraints |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- | ----------- | ----------- |
+| `livestream` | Union of:<br/>&nbsp;&nbsp;[`#livestreamView`](#livestreamview)<br/>&nbsp;&nbsp;[`#viewerCount`](#viewercount)<br/>&nbsp;&nbsp;[`#teleportArrival`](#teleportarrival)<br/>&nbsp;&nbsp;[`#teleportCanceled`](#teleportcanceled)<br/>&nbsp;&nbsp;[`place.stream.defs#blockView`](/lex-reference/place-stream-defs#blockview)<br/>&nbsp;&nbsp;[`place.stream.defs#renditions`](/lex-reference/place-stream-defs#renditions)<br/>&nbsp;&nbsp;[`place.stream.defs#rendition`](/lex-reference/place-stream-defs#rendition)<br/>&nbsp;&nbsp;[`place.stream.chat.defs#messageView`](/lex-reference/place-stream-chat-defs#messageview)<br/>&nbsp;&nbsp;[`place.stream.chat.defs#pinnedRecordView`](/lex-reference/place-stream-chat-defs#pinnedrecordview) | ✅    |             |             |
 
 ---
 
···
             "place.stream.defs#blockView",
             "place.stream.defs#renditions",
             "place.stream.defs#rendition",
-            "place.stream.chat.defs#messageView"
+            "place.stream.chat.defs#messageView",
+            "place.stream.chat.defs#pinnedRecordView"
           ]
         }
       }

js/streamplace/src/useful-types.ts

···
 import {
   PlaceStreamChatDefs,
   PlaceStreamChatMessage,
+  PlaceStreamChatPinnedRecord,
   PlaceStreamLivestream,
 } from "./lexicons";
 
···
   extends PlaceStreamChatDefs.MessageView {
   record: PlaceStreamChatMessage.Record;
 }
+
+export interface PinnedRecordViewHydrated
+  extends PlaceStreamChatDefs.PinnedRecordView {
+  record: PlaceStreamChatPinnedRecord.Record;
+}

lexicons/place/stream/chat/defs.json

···
           }
         }
       }
+    },
+    "pinnedRecordView": {
+      "type": "object",
+      "description": "View of a pinned chat record with hydrated message data.",
+      "required": ["uri", "cid", "record", "indexedAt"],
+      "properties": {
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" },
+        "record": { "type": "ref", "ref": "place.stream.chat.pinnedRecord" },
+        "indexedAt": { "type": "string", "format": "datetime" },
+        "pinnedBy": {
+          "type": "ref",
+          "ref": "place.stream.chat.profile"
+        },
+        "message": {
+          "type": "ref",
+          "ref": "#messageView"
+        }
+      }
     }
   }
 }

lexicons/place/stream/chat/pinnedRecord.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.chat.pinnedRecord",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "description": "Record pinning a chat message for prominent display.",
+      "record": {
+        "type": "object",
+        "required": ["pinnedMessage", "createdAt"],
+        "properties": {
+          "pinnedMessage": {
+            "type": "string",
+            "format": "at-uri",
+            "description": "AT-URI of the pinned chat message."
+          },
+          "pinnedBy": {
+            "type": "string",
+            "format": "did",
+            "description": "DID of the user who pinned the message."
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "When this pin was created."
+          },
+          "expiresAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Optional expiration time. If set, the pin is considered inactive after this time."
+          }
+        }
+      }
+    }
+  }
+}

lexicons/place/stream/livestream.json

···
             "place.stream.defs#blockView",
             "place.stream.defs#renditions",
             "place.stream.defs#rendition",
-            "place.stream.chat.defs#messageView"
+            "place.stream.chat.defs#messageView",
+            "place.stream.chat.defs#pinnedRecordView"
           ]
         }
       }

lexicons/place/stream/moderation/createPin.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.createPin",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Pin a chat message on behalf of a streamer. Requires 'message.pin' permission. Creates a place.stream.chat.pinnedRecord in the streamer's repo, replacing any existing pin.",
+      "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 pin."
+            },
+            "expiresAt": {
+              "type": "string",
+              "format": "datetime",
+              "description": "Optional expiration time for this pin."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri", "cid"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the created pinned record."
+            },
+            "cid": {
+              "type": "string",
+              "format": "cid",
+              "description": "The CID of the created pinned record."
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "name": "Unauthorized",
+          "description": "The request lacks valid authentication credentials."
+        },
+        {
+          "name": "Forbidden",
+          "description": "The caller does not have permission to pin messages for this streamer."
+        },
+        {
+          "name": "SessionNotFound",
+          "description": "The streamer's OAuth session could not be found or is invalid."
+        }
+      ]
+    }
+  }
+}

lexicons/place/stream/moderation/deletePin.json

···
+{
+  "lexicon": 1,
+  "id": "place.stream.moderation.deletePin",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Unpin a pinned chat message on behalf of a streamer. Requires 'message.pin' permission. Deletes the place.stream.chat.pinnedRecord from the streamer's repo.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["streamer", "pinUri"],
+          "properties": {
+            "streamer": {
+              "type": "string",
+              "format": "did",
+              "description": "The DID of the streamer."
+            },
+            "pinUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the pinned 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 unpin 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

···
             "type": "array",
             "items": {
               "type": "string",
-              "enum": ["ban", "hide", "livestream.manage"]
+              "enum": ["ban", "hide", "livestream.manage", "message.pin"]
             },
             "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."
           },

pkg/api/websocket.go

···
 			}
 		}()
 
+		// get the latest active pinned message for the repo
+		go func() {
+			pin, err := a.Model.GetActivePinnedRecord(ctx, repoDID)
+			if err != nil {
+				log.Error(ctx, "could not get pinned record", "error", err)
+				return
+			}
+			if pin != nil {
+				prv, err := pin.ToStreamplacePinnedRecordView()
+				if err != nil {
+					log.Error(ctx, "could not convert pinned record to streamplace view", "error", err)
+					return
+				}
+				// look up the original message, pinner
+				msg, err := a.Model.GetChatMessage(prv.Record.PinnedMessage)
+				if err != nil {
+					log.Error(ctx, "failed to get pinned message", err)
+					return
+				}
+				// if the message was deleted, treat as no pinned message
+				if msg != nil && msg.DeletedAt != nil {
+					log.Log(ctx, "pinned message was deleted, skipping", "uri", msg.URI)
+					return
+				}
+				// if no pinned by, use the repo owner as the pinner
+				if prv.Record.PinnedBy == nil {
+					prv.Record.PinnedBy = &repoDID
+				}
+				profile, err := a.Model.GetChatProfile(ctx, *prv.Record.PinnedBy)
+				if err != nil {
+					log.Error(ctx, "failed to get chat profile", err)
+					return
+				}
+				if msg != nil {
+					msgView, err := msg.ToStreamplaceMessageView()
+					if err != nil {
+						log.Error(ctx, "failed to convert chat message: %w", err)
+						return
+					}
+					prv.Message = msgView
+				}
+				if profile != nil {
+					profileView, err := profile.ToStreamplaceChatProfile()
+					if err != nil {
+						log.Error(ctx, "failed to convert chat profile: %w", err)
+						return
+					}
+					prv.PinnedBy = profileView
+				}
+				initialBurst <- prv
+			}
+		}()
+
 		go func() {
 			teleports, err := a.Model.GetActiveTeleportsToRepo(repoDID)
 			if err != nil {

pkg/atproto/firehose.go

···
 				}
 			}
 
+			if collection.String() == constants.PLACE_STREAM_CHAT_PINNED_RECORD {
+				log.Debug(ctx, "deleting pinned record", "userDID", evt.Repo, "rkey", rkey.String())
+				err := atsync.Model.DeletePinnedRecord(ctx, rkey.String())
+				if err != nil {
+					log.Error(ctx, "failed to delete pinned record", "err", err)
+				}
+				deletedPin := map[string]any{
+					"$type":   constants.PLACE_STREAM_CHAT_PINNED_RECORD,
+					"rkey":    rkey.String(),
+					"deleted": true,
+				}
+				go atsync.Bus.Publish(evt.Repo, deletedPin)
+			}
+
 		default:
 			log.Error(ctx, "unexpected record op kind")
 		}

pkg/atproto/labeler_firehose.go

···
 							log.Error(ctx, "failed to get chat message for label", "err", err)
 							continue
 						}
+						if msg == nil {
+							log.Debug(ctx, "chat message not found for label, skipping", "uri", l.URI)
+							continue
+						}
 						chatView, err := msg.ToStreamplaceMessageView()
 						if err != nil {
 							log.Error(ctx, "failed to convert chat message to streamplace message view", "err", err)

pkg/atproto/sync.go

···
 		}
 		go atsync.Bus.Publish(userDID, streamplaceGate)
 
+	case *streamplace.ChatPinnedRecord:
+		repo, err := atsync.SyncBlueskyRepoCached(ctx, userDID)
+		if err != nil {
+			return fmt.Errorf("failed to sync bluesky repo: %w", err)
+		}
+		if r == nil {
+			return nil
+		}
+		log.Debug(ctx, "creating pinned record", "userDID", userDID, "pinnedMessage", rec.PinnedMessage)
+		// err = atsync.Model.DeleteAllPinnedRecords(ctx, userDID)
+		// if err != nil {
+		// 	log.Error(ctx, "failed to delete existing pinned records", "err", err)
+		// }
+		// Parse optional expiresAt
+		var expiresAt *time.Time
+		if rec.ExpiresAt != nil {
+			t, err := time.Parse(time.RFC3339, *rec.ExpiresAt)
+			if err == nil {
+				expiresAt = &t
+			}
+		}
+		// serialise createdAt
+		createdAt, err := time.Parse(time.RFC3339, rec.CreatedAt)
+		if err != nil {
+			return fmt.Errorf("failed to parse createdAt: %w", err)
+		}
+
+		var pinnedBy string
+		if rec.PinnedBy == nil {
+			pinnedBy = userDID
+		} else {
+			pinnedBy = *rec.PinnedBy
+		}
+
+		pin := &model.PinnedRecord{
+			Uri:           aturi.String(),
+			RepoDID:       userDID,
+			PinnedMessage: rec.PinnedMessage,
+			PinnedBy:      pinnedBy,
+			IndexedAt:     &now,
+			CID:           cid,
+			CreatedAt:     createdAt,
+			Repo:          repo,
+			ExpiresAt:     expiresAt,
+		}
+		err = atsync.Model.CreatePinnedRecord(ctx, pin)
+		if err != nil {
+			return fmt.Errorf("failed to create pinned record: %w", err)
+		}
+		pin, err = atsync.Model.GetPinnedRecord(ctx, pin.Uri)
+		if err != nil {
+			return fmt.Errorf("failed to get pinned record after we just saved it: %w", err)
+		}
+		pinnedView, err := pin.ToStreamplacePinnedRecordView()
+		if err != nil {
+			return fmt.Errorf("failed to convert pinned record: %w", err)
+		}
+		// look up the original message, pinner
+		msg, err := atsync.Model.GetChatMessage(pinnedView.Record.PinnedMessage)
+		if err != nil {
+			return fmt.Errorf("failed to get chat message: %w", err)
+		}
+		profile, err := atsync.Model.GetChatProfile(ctx, pinnedBy)
+		if err != nil {
+			return fmt.Errorf("failed to get chat profile: %w", err)
+		}
+		if msg != nil {
+			msgView, err := msg.ToStreamplaceMessageView()
+			if err != nil {
+				return fmt.Errorf("failed to convert chat message: %w", err)
+			}
+			pinnedView.Message = msgView
+		}
+		if profile != nil {
+			profileView, err := profile.ToStreamplaceChatProfile()
+			if err != nil {
+				return fmt.Errorf("failed to convert chat profile: %w", err)
+			}
+			pinnedView.PinnedBy = profileView
+		}
+		go atsync.Bus.Publish(userDID, pinnedView)
+
 	case *streamplace.ChatProfile:
 		repo, err := atsync.SyncBlueskyRepoCached(ctx, userDID)
 		if err != nil {

pkg/constants/constants.go

···
 var APP_BSKY_GRAPH_BLOCK = "app.bsky.graph.block"                             //nolint:all
 var APP_BSKY_ACTOR_PROFILE = "app.bsky.actor.profile"                         //nolint:all
 var PLACE_STREAM_CHAT_GATE = "place.stream.chat.gate"                         //nolint:all
+var PLACE_STREAM_CHAT_PINNED_RECORD = "place.stream.chat.pinnedRecord"        //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_LIVE_VIEWERCOUNT = "place.stream.live.viewerCount"           //nolint:all

pkg/gen/gen.go

···
 		streamplace.ChatMessage_ReplyRef{},
 		streamplace.ServerSettings{},
 		streamplace.ChatGate{},
+		streamplace.ChatPinnedRecord{},
 		streamplace.MultistreamTarget{},
 		streamplace.BroadcastOrigin{},
 		streamplace.BroadcastSyndication{},

pkg/model/model.go

···
 	GetGate(ctx context.Context, rkey string) (*Gate, error)
 	GetUserGates(ctx context.Context, userDID string) ([]*Gate, error)
 
+	CreatePinnedRecord(ctx context.Context, pin *PinnedRecord) error
+	DeletePinnedRecord(ctx context.Context, uri string) error
+	DeleteAllPinnedRecords(ctx context.Context, streamerDID string) error
+	GetPinnedRecord(ctx context.Context, uri string) (*PinnedRecord, error)
+	GetActivePinnedRecord(ctx context.Context, streamerDID string) (*PinnedRecord, error)
+
 	CreateChatProfile(ctx context.Context, profile *ChatProfile) error
 	GetChatProfile(ctx context.Context, repoDID string) (*ChatProfile, error)
 
···
 		ChatMessage{},
 		ChatProfile{},
 		Gate{},
+		PinnedRecord{},
 		ServerSettings{},
 		Labeler{},
 		Label{},

pkg/model/pinned_record.go

···
+package model
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/bluesky-social/indigo/util"
+	"gorm.io/gorm"
+	"stream.place/streamplace/pkg/streamplace"
+)
+
+type PinnedRecord struct {
+	Uri           string     `gorm:"primaryKey;column:uri"`
+	CID           string     `gorm:"column:cid"`
+	RepoDID       string     `json:"repoDID"              gorm:"column:repo_did"`
+	Repo          *Repo      `json:"repo,omitempty"       gorm:"foreignKey:DID;references:RepoDID"`
+	PinnedMessage string     `gorm:"column:pinned_message" json:"pinnedMessage"`
+	PinnedBy      string     `gorm:"column:pinned_by"      json:"pinnedBy"`
+	IndexedAt     *time.Time `gorm:"column:indexed_at"    json:"indexedAt"`
+	ExpiresAt     *time.Time `gorm:"column:expires_at"    json:"expiresAt"`
+	CreatedAt     time.Time  `gorm:"column:created_at"    json:"createdAt"`
+}
+
+func (p *PinnedRecord) ToStreamplacePinnedRecord() (*streamplace.ChatPinnedRecord, error) {
+	rec := &streamplace.ChatPinnedRecord{
+		LexiconTypeID: "place.stream.chat.pinnedRecord",
+		PinnedMessage: p.PinnedMessage,
+		CreatedAt:     p.CreatedAt.UTC().Format(util.ISO8601),
+	}
+	if p.ExpiresAt != nil {
+		s := p.ExpiresAt.UTC().Format(util.ISO8601)
+		rec.ExpiresAt = &s
+	}
+	return rec, nil
+}
+
+func (p *PinnedRecord) ToStreamplacePinnedRecordView() (*streamplace.ChatDefs_PinnedRecordView, error) {
+	pr := &streamplace.ChatPinnedRecord{
+		LexiconTypeID: "place.stream.chat.pinnedRecord",
+		PinnedMessage: p.PinnedMessage,
+		CreatedAt:     p.CreatedAt.UTC().Format(util.ISO8601),
+	}
+	if p.ExpiresAt != nil {
+		s := p.ExpiresAt.UTC().Format(util.ISO8601)
+		pr.ExpiresAt = &s
+	}
+	rec := &streamplace.ChatDefs_PinnedRecordView{
+		LexiconTypeID: "place.stream.chat.defs#pinnedRecordView",
+		Record:        pr,
+		Cid:           p.CID,
+		IndexedAt:     p.CreatedAt.UTC().Format(time.RFC3339Nano),
+		// message, pinnedby not included, will fill in later
+		Uri: p.Uri,
+	}
+	return rec, nil
+}
+func (m *DBModel) CreatePinnedRecord(ctx context.Context, pin *PinnedRecord) error {
+	return m.DB.Create(pin).Error
+}
+
+func (m *DBModel) GetPinnedRecord(ctx context.Context, uri string) (*PinnedRecord, error) {
+	var pin PinnedRecord
+	err := m.DB.Preload("Repo").Where("uri = ?", uri).First(&pin).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &pin, nil
+}
+
+func (m *DBModel) DeletePinnedRecord(ctx context.Context, uri string) error {
+	return m.DB.Where("uri = ?", uri).Delete(&PinnedRecord{}).Error
+}
+
+func (m *DBModel) DeleteAllPinnedRecords(ctx context.Context, streamerDID string) error {
+	return m.DB.Where("repo_did = ?", streamerDID).Delete(&PinnedRecord{}).Error
+}
+
+func (m *DBModel) GetActivePinnedRecord(ctx context.Context, streamerDID string) (*PinnedRecord, error) {
+	var pin PinnedRecord
+	now := time.Now()
+	err := m.DB.Preload("Repo").
+		Where("repo_did = ? AND (expires_at IS NULL OR expires_at > ?)", streamerDID, now).
+		Order("created_at DESC").
+		First(&pin).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &pin, nil
+}

pkg/moderation/permissions.go

···
 	PermissionBan              = "ban"
 	PermissionHide             = "hide"
 	PermissionLivestreamManage = "livestream.manage"
+	PermissionMessagePin       = "message.pin"
 )
 
 // ActionPermissions maps moderation actions to required permissions
···
 	"createGate":       PermissionHide,
 	"deleteGate":       PermissionHide,
 	"updateLivestream": PermissionLivestreamManage,
+	"createPin":        PermissionMessagePin,
+	"deletePin":        PermissionMessagePin,
 }
 
 // PermissionChecker validates moderation permissions

pkg/spxrpc/place_stream_moderation.go

···
 
 	return s.statefulDB.CreateAuditLog(ctx, auditLog)
 }
+
+func (s *Server) handlePlaceStreamModerationCreatePin(ctx context.Context, input *streamplace.ModerationCreatePin_Input) (*streamplace.ModerationCreatePin_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 messageUri: %v", err))
+	}
+
+	// Get delegated moderation context (validates OAuth, permission, and returns client)
+	modCtx, err := s.GetDelegatedModerationContext(ctx, input.Streamer, "createPin")
+	if err != nil {
+		return nil, err
+	}
+
+	// Check that the streamer has an active livestream
+	ls, err := s.model.GetLatestLivestreamForRepo(input.Streamer)
+	if err != nil {
+		log.Error(ctx, "failed to get livestream for streamer", "err", err)
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to check livestream status")
+	}
+	if ls == nil || ls.Livestream == nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, "no active livestream for this streamer")
+	}
+	lsRec, err := lexutil.CborDecodeValue(*ls.Livestream)
+	if err != nil {
+		log.Error(ctx, "failed to decode livestream record", "err", err)
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to check livestream status")
+	}
+	lsTyped, ok := lsRec.(*streamplace.Livestream)
+	if ok && lsTyped.EndedAt != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, "livestream has ended, cannot pin comments")
+	}
+
+	// Delete existing pinned records for this streamer (single-pin semantics)
+	var listOutput comatproto.RepoListRecords_Output
+	err = modCtx.StreamerClient.Do(ctx, xrpc.Query, "application/json", "com.atproto.repo.listRecords",
+		map[string]any{
+			"repo":       input.Streamer,
+			"collection": constants.PLACE_STREAM_CHAT_PINNED_RECORD,
+		}, nil, &listOutput)
+	if err != nil {
+		log.Error(ctx, "failed to list existing pinned records", "err", err)
+	} else {
+		for _, rec := range listOutput.Records {
+			rkey, delErr := extractRKey(rec.Uri)
+			if delErr != nil {
+				continue
+			}
+			deleteInput := comatproto.RepoDeleteRecord_Input{
+				Collection: constants.PLACE_STREAM_CHAT_PINNED_RECORD,
+				Rkey:       rkey,
+				Repo:       input.Streamer,
+			}
+			deleteOutput := comatproto.RepoDeleteRecord_Output{}
+			if err := modCtx.StreamerClient.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.deleteRecord", map[string]any{}, deleteInput, &deleteOutput); err != nil {
+				log.Error(ctx, "failed to delete existing pinned record", "rkey", rkey, "err", err)
+			}
+		}
+	}
+
+	// Create the pinned record
+	pinnedRecord := &streamplace.ChatPinnedRecord{
+		LexiconTypeID: "place.stream.chat.pinnedRecord",
+		PinnedMessage: input.MessageUri,
+		CreatedAt:     time.Now().UTC().Format(time.RFC3339),
+		ExpiresAt:     input.ExpiresAt,
+	}
+
+	createInput := comatproto.RepoCreateRecord_Input{
+		Collection: constants.PLACE_STREAM_CHAT_PINNED_RECORD,
+		Record:     &lexutil.LexiconTypeDecoder{Val: pinnedRecord},
+		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 pinned record", "err", err)
+		if auditErr := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "createPin", 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 pinned record: %v", err))
+	}
+
+	// Log successful audit entry
+	if err := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "createPin", input.MessageUri, "", createOutput.Uri, true, ""); err != nil {
+		log.Error(ctx, "failed to create audit log", "error", err)
+	}
+
+	return &streamplace.ModerationCreatePin_Output{
+		Uri: createOutput.Uri,
+		Cid: createOutput.Cid,
+	}, nil
+}
+
+func (s *Server) handlePlaceStreamModerationDeletePin(ctx context.Context, input *streamplace.ModerationDeletePin_Input) (*streamplace.ModerationDeletePin_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.PinUri); err != nil {
+		return nil, echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("invalid pinUri: %v", err))
+	}
+
+	// Get delegated moderation context (validates OAuth, permission, and returns client)
+	modCtx, err := s.GetDelegatedModerationContext(ctx, input.Streamer, "deletePin")
+	if err != nil {
+		return nil, err
+	}
+
+	// Parse pinUri to extract rkey
+	rkey, err := extractRKey(input.PinUri)
+	if err != nil {
+		log.Error(ctx, "failed to extract rkey from pinUri", "uri", input.PinUri, "err", err)
+		return nil, echo.NewHTTPError(http.StatusBadRequest, "invalid pinUri format")
+	}
+
+	// Delete pinned record from streamer's repo
+	deleteInput := comatproto.RepoDeleteRecord_Input{
+		Collection: constants.PLACE_STREAM_CHAT_PINNED_RECORD,
+		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 pinned record", "err", err)
+		if auditErr := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "deletePin", input.PinUri, "", "", 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 pinned record: %v", err))
+	}
+
+	// Log successful audit entry
+	if err := s.logAudit(ctx, input.Streamer, modCtx.ModeratorDID, "deletePin", input.PinUri, "", "", true, ""); err != nil {
+		log.Error(ctx, "failed to create audit log", "error", err)
+	}
+
+	return &streamplace.ModerationDeletePin_Output{}, nil
+}

pkg/spxrpc/stubs.go

···
 	e.POST("/xrpc/place.stream.live.stopLivestream", s.HandlePlaceStreamLiveStopLivestream)
 	e.POST("/xrpc/place.stream.moderation.createBlock", s.HandlePlaceStreamModerationCreateBlock)
 	e.POST("/xrpc/place.stream.moderation.createGate", s.HandlePlaceStreamModerationCreateGate)
+	e.POST("/xrpc/place.stream.moderation.createPin", s.HandlePlaceStreamModerationCreatePin)
 	e.POST("/xrpc/place.stream.moderation.deleteBlock", s.HandlePlaceStreamModerationDeleteBlock)
 	e.POST("/xrpc/place.stream.moderation.deleteGate", s.HandlePlaceStreamModerationDeleteGate)
+	e.POST("/xrpc/place.stream.moderation.deletePin", s.HandlePlaceStreamModerationDeletePin)
 	e.POST("/xrpc/place.stream.moderation.updateLivestream", s.HandlePlaceStreamModerationUpdateLivestream)
 	e.POST("/xrpc/place.stream.multistream.createTarget", s.HandlePlaceStreamMultistreamCreateTarget)
 	e.POST("/xrpc/place.stream.multistream.deleteTarget", s.HandlePlaceStreamMultistreamDeleteTarget)
···
 	return c.JSON(200, out)
 }
 
+func (s *Server) HandlePlaceStreamModerationCreatePin(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandlePlaceStreamModerationCreatePin")
+	defer span.End()
+
+	var body placestream.ModerationCreatePin_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
+	var out *placestream.ModerationCreatePin_Output
+	var handleErr error
+	// func (s *Server) handlePlaceStreamModerationCreatePin(ctx context.Context,body *placestream.ModerationCreatePin_Input) (*placestream.ModerationCreatePin_Output, error)
+	out, handleErr = s.handlePlaceStreamModerationCreatePin(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 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) HandlePlaceStreamModerationDeletePin(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandlePlaceStreamModerationDeletePin")
+	defer span.End()
+
+	var body placestream.ModerationDeletePin_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
+	var out *placestream.ModerationDeletePin_Output
+	var handleErr error
+	// func (s *Server) handlePlaceStreamModerationDeletePin(ctx context.Context,body *placestream.ModerationDeletePin_Input) (*placestream.ModerationDeletePin_Output, error)
+	out, handleErr = s.handlePlaceStreamModerationDeletePin(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}

pkg/streamplace/cbor_gen.go

···
 
 	return nil
 }
+func (t *ChatPinnedRecord) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 5
+
+	if t.ExpiresAt == nil {
+		fieldCount--
+	}
+
+	if t.PinnedBy == 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.chat.pinnedRecord"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("place.stream.chat.pinnedRecord")); err != nil {
+		return err
+	}
+
+	// t.PinnedBy (string) (string)
+	if t.PinnedBy != nil {
+
+		if len("pinnedBy") > 1000000 {
+			return xerrors.Errorf("Value in field \"pinnedBy\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedBy"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("pinnedBy")); err != nil {
+			return err
+		}
+
+		if t.PinnedBy == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.PinnedBy) > 1000000 {
+				return xerrors.Errorf("Value in field t.PinnedBy was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.PinnedBy))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.PinnedBy)); 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.ExpiresAt (string) (string)
+	if t.ExpiresAt != nil {
+
+		if len("expiresAt") > 1000000 {
+			return xerrors.Errorf("Value in field \"expiresAt\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("expiresAt"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("expiresAt")); err != nil {
+			return err
+		}
+
+		if t.ExpiresAt == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.ExpiresAt) > 1000000 {
+				return xerrors.Errorf("Value in field t.ExpiresAt was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ExpiresAt))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.ExpiresAt)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.PinnedMessage (string) (string)
+	if len("pinnedMessage") > 1000000 {
+		return xerrors.Errorf("Value in field \"pinnedMessage\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedMessage"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("pinnedMessage")); err != nil {
+		return err
+	}
+
+	if len(t.PinnedMessage) > 1000000 {
+		return xerrors.Errorf("Value in field t.PinnedMessage was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.PinnedMessage))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.PinnedMessage)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *ChatPinnedRecord) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = ChatPinnedRecord{}
+
+	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("ChatPinnedRecord: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 13)
+	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.PinnedBy (string) (string)
+		case "pinnedBy":
+
+			{
+				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.PinnedBy = (*string)(&sval)
+				}
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.CreatedAt = string(sval)
+			}
+			// t.ExpiresAt (string) (string)
+		case "expiresAt":
+
+			{
+				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.ExpiresAt = (*string)(&sval)
+				}
+			}
+			// t.PinnedMessage (string) (string)
+		case "pinnedMessage":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.PinnedMessage = 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 *MultistreamTarget) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)

pkg/streamplace/chatdefs.go

···
 		return nil
 	}
 }
+
+// ChatDefs_PinnedRecordView is a "pinnedRecordView" in the place.stream.chat.defs schema.
+//
+// View of a pinned chat record with hydrated message data.
+type ChatDefs_PinnedRecordView struct {
+	LexiconTypeID string                `json:"$type" cborgen:"$type,const=place.stream.chat.defs#pinnedRecordView"`
+	Cid           string                `json:"cid" cborgen:"cid"`
+	IndexedAt     string                `json:"indexedAt" cborgen:"indexedAt"`
+	Message       *ChatDefs_MessageView `json:"message,omitempty" cborgen:"message,omitempty"`
+	PinnedBy      *ChatProfile          `json:"pinnedBy,omitempty" cborgen:"pinnedBy,omitempty"`
+	Record        *ChatPinnedRecord     `json:"record" cborgen:"record"`
+	Uri           string                `json:"uri" cborgen:"uri"`
+}

pkg/streamplace/chatpinnedRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: place.stream.chat.pinnedRecord
+
+package streamplace
+
+import (
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+func init() {
+	lexutil.RegisterType("place.stream.chat.pinnedRecord", &ChatPinnedRecord{})
+}
+
+type ChatPinnedRecord struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=place.stream.chat.pinnedRecord"`
+	// createdAt: When this pin was created.
+	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
+	// expiresAt: Optional expiration time. If set, the pin is considered inactive after this time.
+	ExpiresAt *string `json:"expiresAt,omitempty" cborgen:"expiresAt,omitempty"`
+	// pinnedBy: DID of the user who pinned the message.
+	PinnedBy *string `json:"pinnedBy,omitempty" cborgen:"pinnedBy,omitempty"`
+	// pinnedMessage: AT-URI of the pinned chat message.
+	PinnedMessage string `json:"pinnedMessage" cborgen:"pinnedMessage"`
+}

pkg/streamplace/moderationcreatePin.go

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

pkg/streamplace/moderationdeletePin.go

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

pkg/streamplace/streamlivestream.go

···
 	Defs_Renditions             *Defs_Renditions
 	Defs_Rendition              *Defs_Rendition
 	ChatDefs_MessageView        *ChatDefs_MessageView
+	ChatDefs_PinnedRecordView   *ChatDefs_PinnedRecordView
 }
 
 func (t *Livestream_StreamplaceAnything_Livestream) MarshalJSON() ([]byte, error) {
···
 		t.ChatDefs_MessageView.LexiconTypeID = "place.stream.chat.defs#messageView"
 		return json.Marshal(t.ChatDefs_MessageView)
 	}
+	if t.ChatDefs_PinnedRecordView != nil {
+		t.ChatDefs_PinnedRecordView.LexiconTypeID = "place.stream.chat.defs#pinnedRecordView"
+		return json.Marshal(t.ChatDefs_PinnedRecordView)
+	}
 	return nil, fmt.Errorf("can not marshal empty union as JSON")
 }
 
···
 	case "place.stream.chat.defs#messageView":
 		t.ChatDefs_MessageView = new(ChatDefs_MessageView)
 		return json.Unmarshal(b, t.ChatDefs_MessageView)
+	case "place.stream.chat.defs#pinnedRecordView":
+		t.ChatDefs_PinnedRecordView = new(ChatDefs_PinnedRecordView)
+		return json.Unmarshal(b, t.ChatDefs_PinnedRecordView)
 	default:
 		return nil
 	}