@streamplace/components 0.6.37 → 0.7.0

package/dist/livestream-provider/index.js

@@ -1,4 +1,4 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useContext, useRef } from "react";
 import { LivestreamContext, makeLivestreamStore } from "../livestream-store";
 import { useLivestreamWebsocket } from "./websocket";
@@ -14,7 +14,12 @@ export function LivestreamProvider({ children, src, }) {
     window.livestreamStore = store;
     return (_jsx(LivestreamContext.Provider, { value: { store: store }, children: _jsx(LivestreamPoller, { src: src, children: children }) }));
 }
-export function LivestreamPoller({ children, src, }) {
+export function WebsocketWatcher({ src }) {
     useLivestreamWebsocket(src);
-    return _jsx(_Fragment, { children: children });
+    return _jsx(_Fragment, {});
+}
+export function LivestreamPoller({ children, src, }) {
+    // Websocket watcher is a sibling instead of a parent to avoid
+    // re-rendering when the websocket does stuff
+    return (_jsxs(_Fragment, { children: [_jsx(WebsocketWatcher, { src: src }), children] }));
 }

package/dist/livestream-store/chat.js

@@ -1,14 +1,14 @@
 import { RichText } from "@atproto/api";
-import { isLink, isMention, } from "@atproto/api/dist/client/types/app/bsky/richtext/facet";
+import { useCallback } from "react";
 import { useChatProfile, useDID, useHandle } from "../streamplace-store";
 import { usePDSAgent } from "../streamplace-store/xrpc";
 import { getStoreFromContext, useLivestreamStore } from "./livestream-store";
 export const useReplyToMessage = () => useLivestreamStore((state) => state.replyToMessage);
 export const useSetReplyToMessage = () => {
     const store = getStoreFromContext();
-    return (message) => {
+    return useCallback((message) => {
         store.setState({ replyToMessage: message });
-    };
+    }, [store]);
 };
 export const useCreateChatMessage = () => {
     const pdsAgent = usePDSAgent();
@@ -26,11 +26,12 @@ export const useCreateChatMessage = () => {
             throw new Error("Profile not found");
         }
         const rt = new RichText({ text: msg.text });
-        rt.detectFacetsWithoutResolution();
+        await rt.detectFacets(pdsAgent);
         const record = {
             text: msg.text,
             createdAt: new Date().toISOString(),
             streamer: streamerProfile.did,
+            facets: rt.facets,
             ...(msg.reply
                 ? {
                     reply: {
@@ -45,33 +46,6 @@ export const useCreateChatMessage = () => {
                     },
                 }
                 : {}),
-            ...(rt.facets && rt.facets.length > 0
-                ? {
-                    facets: rt.facets.map((facet) => ({
-                        index: facet.index,
-                        features: facet.features
-                            .filter((feature) => feature.$type === "app.bsky.richtext.facet#link" ||
-                            feature.$type === "app.bsky.richtext.facet#mention")
-                            .map((feature) => {
-                            if (isLink(feature)) {
-                                return {
-                                    $type: "app.bsky.richtext.facet#link",
-                                    uri: feature.uri,
-                                };
-                            }
-                            else if (isMention(feature)) {
-                                return {
-                                    $type: "app.bsky.richtext.facet#mention",
-                                    did: feature.did,
-                                };
-                            }
-                            else {
-                                throw new Error("invalid code path");
-                            }
-                        }),
-                    })),
-                }
-                : {}),
         };
         const localChat = {
             uri: `local-${Date.now()}`,
@@ -93,39 +67,90 @@ export const useCreateChatMessage = () => {
         });
     };
 };
-const CHAT_LIMIT = 20;
-export const reduceChat = (state, messages, blocks) => {
-    state = { ...state };
-    let newChat = {
-        ...state.chatIndex,
-    };
-    // Add new messages
-    for (let message of messages) {
+const buildSortedChatList = (chatIndex, existingChatList, newMessages, removedKeys) => {
+    const sortedKeys = Object.keys(chatIndex).sort((a, b) => {
+        const aTime = parseInt(a.split("-")[0], 10);
+        const bTime = parseInt(b.split("-")[0], 10);
+        return bTime - aTime;
+    });
+    return sortedKeys.map((key) => chatIndex[key]);
+};
+const profileIsDifferent = (newProfile, oldProfile) => {
+    if (!oldProfile) {
+        return true;
+    }
+    if (!newProfile) {
+        return false;
+    }
+    if (!oldProfile.color) {
+        return true;
+    }
+    if (!newProfile.color) {
+        // idk. shouldn't happen.
+        return false;
+    }
+    const { red: newRed, green: newGreen, blue: newBlue } = newProfile.color;
+    const { red: oldRed, green: oldGreen, blue: oldBlue } = oldProfile.color;
+    return newRed !== oldRed || newGreen !== oldGreen || newBlue !== oldBlue;
+};
+export const reduceChatIncremental = (state, newMessages, blocks) => {
+    if (newMessages.length === 0 && blocks.length === 0) {
+        return state;
+    }
+    const newChatIndex = { ...state.chatIndex };
+    const newAuthors = { ...state.authors };
+    let hasChanges = false;
+    const removedKeys = new Set();
+    // handle blocks
+    if (blocks.length > 0) {
+        const blockedDIDs = new Set(blocks.map((block) => block.record.subject));
+        for (const [key, message] of Object.entries(newChatIndex)) {
+            if (blockedDIDs.has(message.author.did)) {
+                delete newChatIndex[key];
+                removedKeys.add(key);
+                hasChanges = true;
+            }
+        }
+    }
+    const messagesToAdd = [];
+    for (const message of newMessages) {
         const date = new Date(message.record.createdAt);
         const key = `${date.getTime()}-${message.uri}`;
-        // Remove existing local message matching the server one
+        // only change the ref if the profile is different to avoid re-renders elsewhere
+        if (profileIsDifferent(message.chatProfile, newAuthors[message.author.handle])) {
+            newAuthors[message.author.handle] = message.chatProfile;
+        }
+        // skip messages we already have
+        if (newChatIndex[key] && newChatIndex[key].uri === message.uri) {
+            continue;
+        }
+        // if we have a local message, replace it with the new one
         if (!message.uri.startsWith("local-")) {
-            const existingLocalMessageKey = Object.keys(newChat).find((k) => {
-                const msg = newChat[k];
+            const existingLocalKey = Object.keys(newChatIndex).find((k) => {
+                const msg = newChatIndex[k];
                 return (msg.uri.startsWith("local-") &&
                     msg.record.text === message.record.text &&
-                    msg.author.did === message.author.did);
+                    msg.author.did === message.author.did &&
+                    Math.abs(new Date(msg.record.createdAt).getTime() - date.getTime()) <
+                        10000 // Within 10 seconds
+                );
             });
-            if (existingLocalMessageKey) {
-                delete newChat[existingLocalMessageKey];
+            if (existingLocalKey) {
+                delete newChatIndex[existingLocalKey];
+                removedKeys.add(existingLocalKey);
+                hasChanges = true;
             }
         }
-        // Handle reply information for local-first messages
+        // add reply info
+        let processedMessage = message;
         if (message.record.reply) {
             const reply = message.record.reply;
             const parentUri = reply?.parent?.uri || reply?.root?.uri;
             if (parentUri) {
-                // First try to find the parent message in our chat
-                const parentMsgKey = Object.keys(newChat).find((k) => newChat[k].uri === parentUri);
+                const parentMsgKey = Object.keys(newChatIndex).find((k) => newChatIndex[k].uri === parentUri);
                 if (parentMsgKey) {
-                    // Found the parent message, add its info to our message
-                    const parentMsg = newChat[parentMsgKey];
-                    message = {
+                    const parentMsg = newChatIndex[parentMsgKey];
+                    processedMessage = {
                         ...message,
                         replyTo: {
                             cid: parentMsg.cid,
@@ -139,24 +164,23 @@ export const reduceChat = (state, messages, blocks) => {
                 }
             }
         }
-        newChat[key] = message;
+        messagesToAdd.push({ key, message: processedMessage });
+        hasChanges = true;
     }
-    for (const block of blocks) {
-        for (const [k, v] of Object.entries(newChat)) {
-            if (v.author.did === block.record.subject) {
-                delete newChat[k];
-            }
-        }
+    // Add new messages to index
+    for (const { key, message } of messagesToAdd) {
+        newChatIndex[key] = message;
+    }
+    // only rebuild if we have changes
+    if (!hasChanges) {
+        return state;
     }
-    let newChatList = Object.values(newChat).sort((a, b) => new Date(a.record.createdAt) > new Date(b.record.createdAt) ? 1 : -1);
-    newChatList = newChatList.slice(-CHAT_LIMIT);
-    newChat = newChatList.reduce((acc, msg) => {
-        acc[msg.uri] = msg;
-        return acc;
-    }, {});
+    // Build the new sorted chat list efficiently
+    const newChatList = buildSortedChatList(newChatIndex, state.chat, messagesToAdd, removedKeys);
     return {
         ...state,
-        chatIndex: newChat,
+        chatIndex: newChatIndex,
         chat: newChatList,
     };
 };
+export const reduceChat = reduceChatIncremental;

package/dist/livestream-store/index.js

@@ -1,3 +1,4 @@
 export * from "./chat";
 export * from "./context";
 export * from "./livestream-store";
+export * from "./stream-key";

package/dist/livestream-store/livestream-store.js

@@ -12,6 +12,9 @@ export const makeLivestreamStore = () => {
         segment: null,
         renditions: [],
         replyToMessage: null,
+        streamKey: null,
+        setStreamKey: (sk) => set({ streamKey: sk }),
+        authors: {},
     }));
 };
 export function getStoreFromContext() {

package/dist/livestream-store/stream-key.js

@@ -0,0 +1,115 @@
+import { bytesToMultibase, Secp256k1Keypair } from "@atproto/crypto";
+import { useEffect, useState } from "react";
+import { Platform } from "react-native";
+import { privateKeyToAccount } from "viem/accounts";
+import { usePDSAgent } from "../streamplace-store/xrpc";
+import { useLivestreamStore } from "./livestream-store";
+function getBrowserName(userAgent) {
+    // The order matters here, and this may report false positives for unlisted browsers.
+    if (userAgent.includes("Firefox")) {
+        // "Mozilla/5.0 (X11; Linux i686; rv:104.0) Gecko/20100101 Firefox/104.0"
+        return "Mozilla Firefox";
+    }
+    else if (userAgent.includes("SamsungBrowser")) {
+        // "Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G955F Build/PPR1.180610.011) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.4 Chrome/67.0.3396.87 Mobile Safari/537.36"
+        return "Samsung Internet";
+    }
+    else if (userAgent.includes("Opera") || userAgent.includes("OPR")) {
+        // "Mozilla/5.0 (Macintosh; Intel Mac OS X 12_5_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36 OPR/90.0.4480.54"
+        return "Opera";
+    }
+    else if (userAgent.includes("Edge")) {
+        // "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299"
+        return "Microsoft Edge (Legacy)";
+    }
+    else if (userAgent.includes("Edg")) {
+        // "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36 Edg/104.0.1293.70"
+        return "Microsoft Edge (Chromium)";
+    }
+    else if (userAgent.includes("Chrome")) {
+        // "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36"
+        return "Google Chrome or Chromium";
+    }
+    else if (userAgent.includes("Safari")) {
+        // "Mozilla/5.0 (iPhone; CPU iPhone OS 15_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6 Mobile/15E148 Safari/604.1"
+        return "Apple Safari";
+    }
+    return "unknown";
+}
+export const useStreamKey = () => {
+    const pdsAgent = usePDSAgent();
+    const streamKey = useLivestreamStore((state) => state.streamKey);
+    const setStreamKey = useLivestreamStore((state) => state.setStreamKey);
+    const [key, setKey] = useState(streamKey ? JSON.parse(streamKey) : null);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (key)
+            return; // already have key
+        const generateKey = async () => {
+            if (!pdsAgent) {
+                setError("PDS Agent is not available");
+                return;
+            }
+            let did = pdsAgent.did;
+            if (!did) {
+                setError("PDS Agent did is not available (not logged in?)");
+                return;
+            }
+            const keypair = await Secp256k1Keypair.create({ exportable: true });
+            const exportedKey = await keypair.export();
+            const didBytes = new TextEncoder().encode(did);
+            const combinedKey = new Uint8Array([...exportedKey, ...didBytes]);
+            const multibaseKey = bytesToMultibase(combinedKey, "base58btc");
+            const hexKey = Array.from(exportedKey)
+                .map((b) => b.toString(16).padStart(2, "0"))
+                .join("");
+            const account = privateKeyToAccount(`0x${hexKey}`);
+            const newKey = {
+                privateKey: multibaseKey,
+                did: keypair.did(),
+                address: account.address.toLowerCase(),
+            };
+            let platform = Platform.OS;
+            if (Platform.OS === "web" &&
+                typeof window !== "undefined" &&
+                window.navigator) {
+                if (window.navigator.userAgent.includes("streamplace-desktop")) {
+                    platform = "Desktop";
+                }
+                else {
+                    platform = getBrowserName(window.navigator.userAgent);
+                    if (platform !== "unknown") {
+                        platform = platform;
+                    }
+                }
+            }
+            else if (platform === "android") {
+                platform = "Android";
+            }
+            else if (platform === "ios") {
+                platform = "iOS";
+            }
+            else if (platform === "macos") {
+                platform = "macOS";
+            }
+            else if (platform === "windows") {
+                platform = "Windows";
+            }
+            const record = {
+                signingKey: keypair.did(),
+                createdAt: new Date().toISOString(),
+                createdBy: "Streamplace on " + platform,
+            };
+            await pdsAgent.com.atproto.repo.createRecord({
+                repo: did,
+                collection: "place.stream.key",
+                record,
+            });
+            setStreamKey(JSON.stringify(newKey));
+            setKey(newKey);
+        };
+        generateKey();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [key, setStreamKey]);
+    return { streamKey: key, error };
+};

package/dist/player-store/player-provider.js

@@ -16,7 +16,6 @@ export const PlayerProvider = ({ children, initialPlayers = [], defaultId = Math
         return initialPlayerStores;
     });
     const createPlayer = useCallback((id) => {
-        console.log("Creating new player");
         const playerId = id || Math.random().toString(36).slice(8);
         const playerStore = makePlayerStore(playerId);
         setPlayers((prev) => ({

package/dist/player-store/player-store.js

@@ -15,6 +15,8 @@ export const makePlayerStore = (id) => {
         setIngestStarting: (ingestStarting) => set(() => ({ ingestStarting })),
         ingestMediaSource: undefined,
         setIngestMediaSource: (ingestMediaSource) => set(() => ({ ingestMediaSource })),
+        ingestCamera: "user",
+        setIngestCamera: (ingestCamera) => set(() => ({ ingestCamera })),
         ingestConnectionState: null,
         setIngestConnectionState: (ingestConnectionState) => set(() => ({ ingestConnectionState })),
         ingestAutoStart: false,
@@ -37,6 +39,11 @@ export const makePlayerStore = (id) => {
         setVideoRef: (videoRef) => set(() => ({ videoRef })),
         pipMode: false,
         setPipMode: (pipMode) => set(() => ({ pipMode })),
+        // Player element width/height setters for global sync
+        playerWidth: undefined,
+        setPlayerWidth: (playerWidth) => set(() => ({ playerWidth })),
+        playerHeight: undefined,
+        setPlayerHeight: (playerHeight) => set(() => ({ playerHeight })),
         // * Whether mute was forced by the browser or not for autoplay
         // * Will get set to 'false' if the user has interacted with the volume
         muteWasForced: false,
@@ -48,6 +55,8 @@ export const makePlayerStore = (id) => {
         setShowControls: (showControls) => set({ showControls, controlsTimeout: undefined }),
         telemetry: true,
         setTelemetry: (telemetry) => set(() => ({ telemetry })),
+        ingestLive: false,
+        setIngestLive: (ingestLive) => set(() => ({ ingestLive })),
         playerEvent: async (url, time, eventType, meta) => set((x) => {
             const data = {
                 time: time,
@@ -85,6 +94,10 @@ export const makePlayerStore = (id) => {
             let controlsTimeout = setTimeout(() => p.setShowControls(false), 1000);
             return { showControls: true, controlsTimeout };
         }),
+        showDebugInfo: false,
+        setShowDebugInfo: (showDebugInfo) => set(() => ({ showDebugInfo })),
+        modMessage: null,
+        setModMessage: (modMessage) => set(() => ({ modMessage })),
     }));
 };
 export function usePlayerContext() {

package/dist/streamplace-store/block.js

@@ -0,0 +1,23 @@
+import { usePDSAgent } from "./xrpc";
+export function useCreateBlockRecord() {
+    let agent = usePDSAgent();
+    return async (subjectDID) => {
+        if (!agent) {
+            throw new Error("No PDS agent found");
+        }
+        if (!agent.did) {
+            throw new Error("No user DID found, assuming not logged in");
+        }
+        const record = {
+            $type: "app.bsky.graph.block",
+            subject: subjectDID,
+            createdAt: new Date().toISOString(),
+        };
+        return await agent.com.atproto.repo.createRecord({
+            repo: agent.did,
+            collection: "app.bsky.graph.block",
+            record,
+        });
+        return record;
+    };
+}

package/dist/streamplace-store/index.js

@@ -1,2 +1,3 @@
+export * from "./stream";
 export * from "./streamplace-store";
 export * from "./user";

package/dist/streamplace-store/stream.js

@@ -0,0 +1,193 @@
+import { RichText } from "@atproto/api";
+import { useUrl } from "./streamplace-store";
+import { usePDSAgent } from "./xrpc";
+const uploadThumbnail = async (pdsAgent, customThumbnail) => {
+    if (customThumbnail) {
+        let tries = 0;
+        try {
+            let thumbnail = await pdsAgent.uploadBlob(customThumbnail);
+            while (thumbnail.data.blob.size === 0 &&
+                customThumbnail.size !== 0 &&
+                tries < 3) {
+                console.warn("Reuploading blob as blob sizes don't match! Blob size recieved is", thumbnail.data.blob.size, "and sent blob size is", customThumbnail.size);
+                thumbnail = await pdsAgent.uploadBlob(customThumbnail);
+            }
+            if (tries === 3) {
+                throw new Error("Could not successfully upload blob (tried thrice)");
+            }
+            if (thumbnail.success) {
+                console.log("Successfully uploaded thumbnail");
+                return thumbnail.data.blob;
+            }
+        }
+        catch (e) {
+            throw new Error("Error uploading thumbnail: " + e);
+        }
+    }
+};
+async function createNewPost(agent, record) {
+    try {
+        const post = await agent.post(record);
+        return { uri: post.uri, cid: post.cid };
+    }
+    catch (error) {
+        console.error("Error creating new post:", error);
+        throw error;
+    }
+}
+function buildGoLivePost(text, url, profile, params, thumbnail) {
+    const now = new Date();
+    const linkUrl = `${url.protocol}//${url.host}/${profile.handle}?${params.toString()}`;
+    const prefix = `🔴 LIVE `;
+    const textUrl = `${url.protocol}//${url.host}/${profile.handle}`;
+    const suffix = ` ${text}`;
+    const content = prefix + textUrl + suffix;
+    const rt = new RichText({ text: content });
+    rt.detectFacetsWithoutResolution();
+    const record = {
+        $type: "app.bsky.feed.post",
+        text: content,
+        "place.stream.livestream": {
+            url: linkUrl,
+            title: text,
+        },
+        facets: rt.facets,
+        createdAt: now.toISOString(),
+    };
+    record.embed = {
+        $type: "app.bsky.embed.external",
+        external: {
+            description: text,
+            thumb: thumbnail,
+            title: `@${profile.handle} is 🔴LIVE on ${url.host}!`,
+            uri: linkUrl,
+        },
+    };
+    return record;
+}
+export function useCreateStreamRecord() {
+    let agent = usePDSAgent();
+    let url = useUrl();
+    return async (title, customThumbnail, submitPost = true) => {
+        if (!agent) {
+            throw new Error("No PDS agent found");
+        }
+        if (!agent.did) {
+            throw new Error("No user DID found, assuming not logged in");
+        }
+        let thumbnail = undefined;
+        const u = new URL(url);
+        if (customThumbnail) {
+            try {
+                thumbnail = await uploadThumbnail(agent, customThumbnail);
+            }
+            catch (e) {
+                throw new Error(`Custom thumbnail upload failed ${e}`);
+            }
+        }
+        else {
+            // No custom thumbnail: fetch the server-side image and upload it
+            // try thrice lel
+            let tries = 0;
+            try {
+                for (; tries < 3; tries++) {
+                    try {
+                        console.log(`Fetching thumbnail from ${u.protocol}//${u.host}/api/playback/${agent.did}/stream.png`);
+                        const thumbnailRes = await fetch(`${u.protocol}//${u.host}/api/playback/${agent.did}/stream.png`);
+                        if (!thumbnailRes.ok) {
+                            throw new Error(`Failed to fetch thumbnail: ${thumbnailRes.status})`);
+                        }
+                        const thumbnailBlob = await thumbnailRes.blob();
+                        console.log(thumbnailBlob);
+                        thumbnail = await uploadThumbnail(agent, thumbnailBlob);
+                    }
+                    catch (e) {
+                        console.warn(`Failed to fetch thumbnail, retrying (${tries + 1}/3): ${e}`);
+                        // Wait 1 second before retrying
+                        await new Promise((resolve) => setTimeout(resolve, 2000));
+                        if (tries === 2) {
+                            throw new Error(`Failed to fetch thumbnail after 3 tries: ${e}`);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                throw new Error(`Thumbnail upload failed ${e}`);
+            }
+        }
+        let newPost = undefined;
+        if (submitPost) {
+            const did = agent.did;
+            const profile = await agent.getProfile({ actor: did });
+            if (!profile) {
+                throw new Error("No profile found for the user DID");
+            }
+            const params = new URLSearchParams({
+                did: did,
+                time: new Date().toISOString(),
+            });
+            let post = buildGoLivePost(title, u, profile.data, params, thumbnail);
+            newPost = await createNewPost(agent, post);
+            if (!newPost.uri || !newPost.cid) {
+                throw new Error("Cannot read properties of undefined (reading 'uri' or 'cid')");
+            }
+        }
+        const record = {
+            title: title,
+            url: url,
+            createdAt: new Date().toISOString(),
+            post: newPost,
+            thumb: thumbnail,
+        };
+        await agent.com.atproto.repo.createRecord({
+            repo: agent.did,
+            collection: "place.stream.livestream",
+            record,
+        });
+        return record;
+    };
+}
+export function useUpdateStreamRecord() {
+    let agent = usePDSAgent();
+    let url = useUrl();
+    return async (title, livestream, customThumbnail) => {
+        if (!agent) {
+            throw new Error("No PDS agent found");
+        }
+        if (!agent.did) {
+            throw new Error("No user DID found, assuming not logged in");
+        }
+        if (!livestream) {
+            throw new Error("No latest record");
+        }
+        let rkey = livestream.uri.split("/").pop();
+        let oldRecordValue = livestream.record;
+        if (!rkey) {
+            throw new Error("No rkey?");
+        }
+        let thumbnail = oldRecordValue.thumb;
+        // update thumbnail if a new one is provided
+        if (customThumbnail) {
+            try {
+                thumbnail = await uploadThumbnail(agent, customThumbnail);
+            }
+            catch (e) {
+                throw new Error(`Custom thumbnail upload failed ${e}`);
+            }
+        }
+        const record = {
+            title: title,
+            url: url,
+            createdAt: new Date().toISOString(),
+            post: oldRecordValue.post,
+            thumb: thumbnail,
+        };
+        await agent.com.atproto.repo.putRecord({
+            repo: agent.did,
+            collection: "place.stream.livestream",
+            rkey,
+            record,
+        });
+        return record;
+    };
+}