@openmarket/rooms-client 0.1.0

package/dist/client.js

@@ -0,0 +1,1428 @@
+// Browser + Bun + Node 18: the global crypto implements randomUUID, so the
+// shared client stays importable by the web GUI (no node: specifiers).
+const randomUUID = () => globalThis.crypto.randomUUID();
+import { envString, ROOM_CHAT_API_URL, ROOMS_WS_URL } from "./endpoints.js";
+import { authFromApiKey } from "./jwt.js";
+import { consumeRoomSuggestionAttribution } from "./suggestion-attribution.js";
+import { RoomClientMessageType, RoomLedgerEntryType, RoomServerMessageType, } from "./types.js";
+import { RoomWsClient } from "./ws-client.js";
+function toRoomAttachmentPayloads(attachments) {
+    return attachments.map(({ key, name, size, mime }) => ({ key, name, size, mime }));
+}
+export function resolveRoomsWsUrl() {
+    const env = envString("OM_ROOMS_WS_URL")?.trim();
+    return env && env.length > 0 ? env : ROOMS_WS_URL;
+}
+export { workspaceRoomName } from "./names.js";
+export async function listRooms(config, request = {}) {
+    if (!config.webSocketCtor) {
+        try {
+            return await listRoomsViaHttp(config, request);
+        }
+        catch (error) {
+            if (!shouldFallbackToRoomsWebSocket(error))
+                throw error;
+        }
+    }
+    return listRoomsViaWebSocket(config, request);
+}
+async function listRoomsViaWebSocket(config, request = {}) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.SEARCH,
+            payload: {
+                requestId,
+                ...(request.query ? { query: request.query } : {}),
+                ...(request.scope ? { scope: request.scope } : {}),
+                ...(request.category?.length ? { category: request.category } : {}),
+                ...(request.tag?.length ? { tag: request.tag } : {}),
+                ...(request.kind?.length ? { kind: request.kind } : {}),
+                ...(request.entity?.length ? { entity: request.entity } : {}),
+                ...(request.symbol?.length ? { symbol: request.symbol } : {}),
+                ...(request.spaceId?.length ? { spaceId: request.spaceId } : {}),
+                ...(request.hot ? { hot: true } : {}),
+                ...(request.createdByMe ? { createdByMe: true } : {}),
+                ...(request.includeArchived ? { includeArchived: true } : {}),
+                ...(request.limit !== undefined ? { limit: request.limit } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const rooms = await client.waitFor(RoomServerMessageType.ROOMS, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, rooms: rooms.payload.rooms };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function createRoom(config, request) {
+    if (!config.webSocketCtor) {
+        try {
+            return await createRoomViaHttp(config, request);
+        }
+        catch (error) {
+            if (!shouldFallbackToRoomsWebSocket(error))
+                throw error;
+        }
+    }
+    return createRoomViaWebSocket(config, request);
+}
+async function createRoomViaWebSocket(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.CREATE_ROOM,
+            payload: {
+                requestId,
+                name: request.name,
+                ...(request.title ? { title: request.title } : {}),
+                ...(request.description ? { description: request.description } : {}),
+                ...(request.access ? { access: request.access } : {}),
+                ...(request.maxMembers !== undefined ? { maxMembers: request.maxMembers } : {}),
+                ...(request.category ? { category: request.category } : {}),
+                ...(request.sortOrder !== undefined ? { sortOrder: request.sortOrder } : {}),
+                ...(request.spaceId ? { spaceId: request.spaceId } : {}),
+                ...(request.postingRoles?.length ? { postingRoles: request.postingRoles } : {}),
+                ...(request.tags?.length ? { tags: request.tags } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const created = await client.waitFor(RoomServerMessageType.ROOM_CREATED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, room: created.payload.room, joinCode: created.payload.joinCode };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function inviteRoom(config, request) {
+    // `@user` and `user` are the same person: strip the typing syntax once,
+    // before either transport (the relay resolves the bare name).
+    const normalized = request.username
+        ? { ...request, username: request.username.trim().replace(/^@+/, "") }
+        : request;
+    if (!config.webSocketCtor) {
+        try {
+            return await inviteRoomViaHttp(config, normalized);
+        }
+        catch (error) {
+            if (!shouldFallbackToRoomsWebSocket(error))
+                throw error;
+        }
+    }
+    return inviteRoomViaWebSocket(config, normalized);
+}
+async function inviteRoomViaWebSocket(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.INVITE,
+            payload: {
+                requestId,
+                room: request.room,
+                ...(request.username ? { username: request.username } : {}),
+                ...(request.userId ? { userId: request.userId } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const invited = await client.waitFor(RoomServerMessageType.ROOM_INVITED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, invite: invited.payload };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function removeRoomMember(config, request) {
+    if (!config.webSocketCtor) {
+        try {
+            return await removeRoomMemberViaHttp(config, request);
+        }
+        catch (error) {
+            if (!shouldFallbackToRoomsWebSocket(error))
+                throw error;
+        }
+    }
+    return removeRoomMemberViaWebSocket(config, request);
+}
+async function removeRoomMemberViaWebSocket(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.REMOVE_MEMBER,
+            payload: {
+                requestId,
+                room: request.room,
+                ...(request.username ? { username: request.username } : {}),
+                ...(request.userId ? { userId: request.userId } : {}),
+                ...(request.reason ? { reason: request.reason } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const removal = await client.waitFor(RoomServerMessageType.ROOM_MEMBER_REMOVED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, removal: removal.payload };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function reportRoomTarget(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.REPORT,
+            payload: {
+                requestId,
+                room: request.room,
+                ...(request.seq !== undefined ? { seq: request.seq } : {}),
+                ...(request.targetUserId ? { targetUserId: request.targetUserId } : {}),
+                reason: request.reason,
+            },
+            timestamp: Date.now(),
+        });
+        const report = await client.waitFor(RoomServerMessageType.ROOM_REPORTED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, report: report.payload };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function muteRoomMember(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.MUTE,
+            payload: {
+                requestId,
+                room: request.room,
+                until: request.until,
+                ...(request.username ? { username: request.username } : {}),
+                ...(request.userId ? { userId: request.userId } : {}),
+                ...(request.reason ? { reason: request.reason } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const mute = await client.waitFor(RoomServerMessageType.ROOM_MUTED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, mute: mute.payload };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function kickRoomMember(config, request) {
+    return moderateMember(config, RoomClientMessageType.KICK, RoomServerMessageType.ROOM_MEMBER_REMOVED, request);
+}
+export async function banRoomMember(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.BAN,
+            payload: {
+                requestId,
+                room: request.room,
+                ...(request.username ? { username: request.username } : {}),
+                ...(request.userId ? { userId: request.userId } : {}),
+                ...(request.reason ? { reason: request.reason } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const ban = await client.waitFor(RoomServerMessageType.ROOM_BANNED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, ban: ban.payload };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function changeRoomMemberRole(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.ROLE_CHANGE,
+            payload: {
+                requestId,
+                room: request.room,
+                role: request.role,
+                ...(request.username ? { username: request.username } : {}),
+                ...(request.userId ? { userId: request.userId } : {}),
+                ...(request.reason ? { reason: request.reason } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const roleChange = await client.waitFor(RoomServerMessageType.ROOM_MEMBER_ROLE_CHANGED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, roleChange: roleChange.payload };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function setRoomReadOnly(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.SET_READ_ONLY,
+            payload: {
+                requestId,
+                room: request.room,
+                postingRoles: request.postingRoles,
+                ...(request.reason ? { reason: request.reason } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const updated = await client.waitFor(RoomServerMessageType.ROOM_READ_ONLY_SET, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return {
+            auth,
+            room: updated.payload.room,
+            postingRoles: updated.payload.postingRoles,
+        };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function requestRoomAuditLog(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.AUDIT_LOG,
+            payload: {
+                requestId,
+                room: request.room,
+                ...(request.limit !== undefined ? { limit: request.limit } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const audit = await client.waitFor(RoomServerMessageType.ROOM_AUDIT_LOG, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, audit: audit.payload };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function listRoomSpaces(config) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.SPACES,
+            payload: { requestId },
+            timestamp: Date.now(),
+        });
+        const spaces = await client.waitFor(RoomServerMessageType.SPACES, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, spaces: spaces.payload.spaces };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function joinRoomSpace(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.JOIN_SPACE,
+            payload: { requestId, spaceId: request.spaceId },
+            timestamp: Date.now(),
+        });
+        const joined = await client.waitFor(RoomServerMessageType.SPACE_JOINED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, space: joined.payload.space };
+    }
+    finally {
+        client.close();
+    }
+}
+async function moderateMember(config, clientType, serverType, request) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: clientType,
+            payload: {
+                requestId,
+                room: request.room,
+                ...(request.username ? { username: request.username } : {}),
+                ...(request.userId ? { userId: request.userId } : {}),
+                ...(request.reason ? { reason: request.reason } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const removal = await client.waitFor(serverType, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, removal: removal.payload };
+    }
+    finally {
+        client.close();
+    }
+}
+/** Paged WHO on an already-connected room client (member panel). */
+export async function requestRoomWho(client, room, offset = 0, limit = 100) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.WHO,
+        payload: { room: normalizeRoomName(room), requestId, offset, limit },
+        timestamp: Date.now(),
+    });
+    const response = await client.waitFor(RoomServerMessageType.WHO, (msg) => msg.payload.room === normalizeRoomName(room) && msg.payload.requestId === requestId, undefined, requestId);
+    return response.payload;
+}
+export async function whoRoom(config, room) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.WHO,
+            payload: { room, requestId, offset: 0, limit: 50 },
+            timestamp: Date.now(),
+        });
+        const response = await client.waitForAny([RoomServerMessageType.WHO, RoomServerMessageType.PRESENCE], (msg) => msg.payload.room === normalizeRoomName(room) &&
+            ("requestId" in msg.payload ? msg.payload.requestId === requestId : true), undefined, requestId);
+        if (response.type === RoomServerMessageType.PRESENCE)
+            return normalizePresence(response.payload);
+        return presenceFromWho(response.payload);
+    }
+    finally {
+        client.close();
+    }
+}
+/** The signed-in user's own room identity (userId / handle / username), learned
+ *  by opening and immediately closing a room connection. Used to attribute "my"
+ *  past messages when inferring a writing persona. */
+export async function whoamiRoom(config) {
+    const client = new RoomWsClient(config);
+    try {
+        return await client.connect();
+    }
+    finally {
+        client.close();
+    }
+}
+const FRIENDS_FETCH_TIMEOUT_MS = 2000;
+export async function requestRoomFriends(client) {
+    client.send({ type: RoomClientMessageType.FRIENDS, payload: {}, timestamp: Date.now() });
+    const msg = await client.waitFor(RoomServerMessageType.FRIENDS, () => true, FRIENDS_FETCH_TIMEOUT_MS);
+    return msg.payload.friends;
+}
+export async function openRoomDmOnClient(client, request, timeoutMs) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.DM_OPEN,
+        payload: {
+            requestId,
+            username: request.username,
+            ...(request.limit !== undefined ? { limit: request.limit } : {}),
+            ...(request.markRead !== undefined ? { markRead: request.markRead } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const opened = await client.waitFor(RoomServerMessageType.DM_OPENED, (msg) => msg.payload.requestId === requestId, timeoutMs, requestId);
+    return opened.payload;
+}
+export async function requestRoomDmHistoryOnClient(client, request, timeoutMs) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.DM_HISTORY,
+        payload: {
+            requestId,
+            ...(request.username ? { username: request.username } : {}),
+            ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+            ...(request.before !== undefined ? { before: request.before } : {}),
+            ...(request.limit !== undefined ? { limit: request.limit } : {}),
+            ...(request.markRead !== undefined ? { markRead: request.markRead } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const history = await client.waitFor(RoomServerMessageType.DM_HISTORY, (msg) => msg.payload.requestId === requestId, timeoutMs, requestId);
+    return history.payload;
+}
+export async function sendRoomDmOnClient(client, request, timeoutMs) {
+    const requestId = randomUUID();
+    const clientMsgId = request.clientMsgId ?? randomUUID();
+    client.send({
+        type: RoomClientMessageType.DM_SEND,
+        payload: {
+            requestId,
+            content: request.content,
+            clientMsgId,
+            ...(request.username ? { username: request.username } : {}),
+            ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const sent = await client.waitFor(RoomServerMessageType.DM_MESSAGE, (msg) => msg.payload.requestId === requestId ||
+        msg.payload.clientMsgId === clientMsgId ||
+        msg.payload.message.clientMsgId === clientMsgId, timeoutMs, requestId);
+    return sent.payload;
+}
+export async function peekRoom(config, options) {
+    if (!config.webSocketCtor) {
+        try {
+            return await peekRoomViaHttp(config, options);
+        }
+        catch (error) {
+            if (!shouldFallbackToRoomsWebSocket(error))
+                throw error;
+        }
+    }
+    return peekRoomViaWebSocket(config, options);
+}
+async function peekRoomViaWebSocket(config, options) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.PEEK,
+            payload: {
+                requestId,
+                room: options.room,
+                ...(options.beforeSeq !== undefined ? { beforeSeq: options.beforeSeq } : {}),
+                ...(options.sinceSeq !== undefined ? { sinceSeq: options.sinceSeq } : {}),
+                ...(options.atMs !== undefined ? { atMs: options.atMs } : {}),
+                ...(options.limit !== undefined ? { limit: options.limit } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const result = await client.waitFor(RoomServerMessageType.PEEK_RESULT, (msg) => msg.payload.room === normalizeRoomName(options.room), undefined, requestId);
+        return result.payload;
+    }
+    finally {
+        client.close();
+    }
+}
+export async function sayRoom(config, options) {
+    const clientMsgId = options.clientMsgId ?? randomUUID();
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        await joinRoomOnClient(client, options);
+        client.send({
+            type: RoomClientMessageType.POST,
+            payload: {
+                room: options.room,
+                ...(options.text ? { text: options.text } : {}),
+                ...(options.attachments?.length
+                    ? { attachments: toRoomAttachmentPayloads(options.attachments) }
+                    : {}),
+                clientMsgId,
+                ...(options.inReplyTo !== undefined ? { inReplyTo: options.inReplyTo } : {}),
+                ...(options.topicId ? { topicId: options.topicId } : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const echo = await client.waitFor(RoomServerMessageType.MESSAGE, (msg) => {
+            const entry = msg.payload.entry;
+            if (entry.clientMsgId)
+                return entry.clientMsgId === clientMsgId;
+            return (msg.payload.room === normalizeRoomName(options.room) &&
+                entry.userId === auth.userId &&
+                entry.type === RoomLedgerEntryType.POST &&
+                (options.attachments?.length
+                    ? Boolean(entry.attachments?.some((attachment) => options.attachments?.some((expected) => expected.key === attachment.key)))
+                    : entry.text === options.text));
+        });
+        ackRoom(client, options.room, echo.payload.seq);
+        return { auth, entry: echo.payload.entry, clientMsgId };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function joinRoom(config, options) {
+    // The live session is long-lived and interactive — enable transport-level
+    // reconnection so a dropped socket recovers instead of silently going dead.
+    // The session re-joins and resyncs from its last seq on the "reconnected"
+    // event (see live-session onConnectionChange).
+    const client = new RoomWsClient({ ...config, reconnect: true });
+    const auth = await client.connect();
+    const backfill = await joinRoomOnClient(client, options);
+    if (options.ackOnJoin !== false && backfill.upToSeq > 0) {
+        ackRoom(client, options.room, backfill.upToSeq);
+    }
+    return { auth, backfill, client };
+}
+/** Re-join a room on an already-connected client (used after a reconnect). */
+export async function rejoinRoomOnClient(client, options) {
+    return joinRoomOnClient(client, { ...options, isRejoin: true });
+}
+export function attachRejoinOnReconnect(client, options, latestSeq, onRejoined, onError) {
+    return client.onConnectionChange((state) => {
+        if (state !== "reconnected")
+            return;
+        const sinceSeq = latestSeq();
+        void rejoinRoomOnClient(client, {
+            ...options,
+            ...(sinceSeq !== undefined ? { sinceSeq } : {}),
+        })
+            .then((backfill) => onRejoined?.(backfill))
+            .catch((err) => onError?.(err));
+    });
+}
+export function postRoomMessage(client, room, text, inReplyTo, attachments, topicId) {
+    const clientMsgId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.POST,
+        payload: {
+            room,
+            ...(text ? { text } : {}),
+            ...(attachments?.length ? { attachments: toRoomAttachmentPayloads(attachments) } : {}),
+            clientMsgId,
+            ...(inReplyTo !== undefined ? { inReplyTo } : {}),
+            ...(topicId ? { topicId } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    return clientMsgId;
+}
+export function sendRoomTyping(client, room, state) {
+    if (client.isGuest())
+        return;
+    client.send({
+        type: RoomClientMessageType.TYPING,
+        payload: { room, state },
+        timestamp: Date.now(),
+    });
+}
+export function sendRoomStatus(client, status, statusText) {
+    client.send({
+        type: RoomClientMessageType.STATUS,
+        payload: { status, ...(statusText !== undefined ? { statusText } : {}) },
+        timestamp: Date.now(),
+    });
+}
+/**
+ * Fetch a joined room's meta (title, access, postingRoles, viewerRole) over
+ * the live socket via a scoped SEARCH. Returns null on timeout/no match so
+ * callers can degrade to role hints from presence.
+ */
+export async function requestRoomMeta(client, room, timeoutMs = 1500) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.SEARCH,
+        payload: { requestId, query: room, limit: 20 },
+        timestamp: Date.now(),
+    });
+    try {
+        const result = await client.waitFor(RoomServerMessageType.ROOMS, (msg) => msg.payload.requestId === requestId, timeoutMs, requestId);
+        return (result.payload.rooms.find((candidate) => normalizeRoomName(candidate.name) === normalizeRoomName(room)) ?? null);
+    }
+    catch {
+        return null;
+    }
+}
+export function reactRoomEntry(client, room, seq, emoji, op) {
+    client.send({
+        type: RoomClientMessageType.REACT,
+        payload: { room, seq, emoji, op },
+        timestamp: Date.now(),
+    });
+}
+export function editRoomEntry(client, room, seq, text) {
+    client.send({
+        type: RoomClientMessageType.EDIT,
+        payload: { room, seq, text },
+        timestamp: Date.now(),
+    });
+}
+export async function deleteRoomEntry(client, room, seq) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.DELETE,
+        payload: { requestId, room, seq },
+        timestamp: Date.now(),
+    });
+    return waitForEntryUpdate(client, room, seq, requestId);
+}
+export async function requestRoomThread(client, request) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.THREAD,
+        payload: {
+            requestId,
+            room: request.room,
+            rootSeq: request.rootSeq,
+            ...(request.beforeSeq !== undefined ? { beforeSeq: request.beforeSeq } : {}),
+            ...(request.sinceSeq !== undefined ? { sinceSeq: request.sinceSeq } : {}),
+            ...(request.limit !== undefined ? { limit: request.limit } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const result = await client.waitFor(RoomServerMessageType.THREAD, (msg) => msg.payload.requestId === requestId &&
+        msg.payload.room === normalizeRoomName(request.room) &&
+        msg.payload.rootSeq === request.rootSeq, undefined, requestId);
+    return result.payload;
+}
+export async function requestRoomPins(client, room, limit = 50) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.PINS,
+        payload: { requestId, room, limit },
+        timestamp: Date.now(),
+    });
+    const result = await client.waitFor(RoomServerMessageType.PINS, (msg) => msg.payload.requestId === requestId && msg.payload.room === normalizeRoomName(room), undefined, requestId);
+    return result.payload;
+}
+export async function pinRoomEntry(client, room, seq) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.PIN,
+        payload: { requestId, room, seq },
+        timestamp: Date.now(),
+    });
+    return waitForEntryUpdate(client, room, seq, requestId);
+}
+export async function unpinRoomEntry(client, room, seq) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.UNPIN,
+        payload: { requestId, room, seq },
+        timestamp: Date.now(),
+    });
+    return waitForEntryUpdate(client, room, seq, requestId);
+}
+async function waitForEntryUpdate(client, room, seq, requestId) {
+    const result = await client.waitFor(RoomServerMessageType.ENTRY_UPDATED, (msg) => msg.payload.requestId === requestId &&
+        msg.payload.room === normalizeRoomName(room) &&
+        msg.payload.seq === seq, undefined, requestId);
+    return result.payload.entry;
+}
+/** Who reacted (live socket): lazy read for reaction-chip tooltips. */
+export async function requestRoomReactors(client, request) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.REACTORS,
+        payload: {
+            requestId,
+            room: request.room,
+            seq: request.seq,
+            ...(request.emoji ? { emoji: request.emoji } : {}),
+            ...(request.limit !== undefined ? { limit: request.limit } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const result = await client.waitFor(RoomServerMessageType.REACTORS, (msg) => msg.payload.requestId === requestId &&
+        msg.payload.room === normalizeRoomName(request.room) &&
+        msg.payload.seq === request.seq, undefined, requestId);
+    return result.payload;
+}
+/** Set my presence status (one-shot, agent-verb transport). The relay
+ *  persists it durably; a one-shot socket has no joined rooms, so live
+ *  rosters pick the change up from the store (the TUI/GUI send STATUS on
+ *  their live connection instead, which also broadcasts PRESENCE_DELTA). */
+export async function setRoomStatusOnce(config, status, statusText) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        sendRoomStatus(client, status, statusText);
+        // STATUS has no ack frame: give the socket a beat to flush before close.
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    finally {
+        client.close();
+    }
+}
+/** One-shot session helper for the config-based mutation verbs below (the
+ *  agent tools' transport: connect, join, act, wait for the echo, close). */
+async function withRoomEcho(config, room, seq, send) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        await joinRoomOnClient(client, { room, limit: 1 });
+        send(client);
+        const updated = await client.waitFor(RoomServerMessageType.ENTRY_UPDATED, (msg) => msg.payload.room === normalizeRoomName(room) && msg.payload.seq === seq);
+        return updated.payload.entry;
+    }
+    finally {
+        client.close();
+    }
+}
+/** Add/remove one reaction (one-shot). Returns the updated entry. */
+export async function reactRoom(config, options) {
+    return withRoomEcho(config, options.room, options.seq, (client) => reactRoomEntry(client, options.room, options.seq, options.emoji, options.op));
+}
+/** Edit own message (one-shot). Returns the updated entry. */
+export async function editRoomMessage(config, options) {
+    return withRoomEcho(config, options.room, options.seq, (client) => editRoomEntry(client, options.room, options.seq, options.text));
+}
+/** Delete a message (own, or moderator delete-any; one-shot). */
+export async function deleteRoomMessage(config, options) {
+    return withRoomEcho(config, options.room, options.seq, (client) => deleteRoomEntry(client, options.room, options.seq));
+}
+/** Pin or unpin a message (one-shot). Returns the updated entry. */
+export async function pinRoomMessage(config, options) {
+    return withRoomEcho(config, options.room, options.seq, (client) => options.op === "pin"
+        ? pinRoomEntry(client, options.room, options.seq)
+        : unpinRoomEntry(client, options.room, options.seq));
+}
+/** List pinned messages (one-shot). */
+export async function listRoomPinsOnce(config, options) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        return await requestRoomPins(client, options.room, options.limit ?? 50);
+    }
+    finally {
+        client.close();
+    }
+}
+/** Fetch one reply thread (one-shot). */
+export async function getRoomThreadOnce(config, options) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        return await requestRoomThread(client, {
+            room: options.room,
+            rootSeq: options.rootSeq,
+            ...(options.limit !== undefined ? { limit: options.limit } : {}),
+        });
+    }
+    finally {
+        client.close();
+    }
+}
+/** Who reacted (one-shot). */
+export async function getRoomReactorsOnce(config, options) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        return await requestRoomReactors(client, options);
+    }
+    finally {
+        client.close();
+    }
+}
+/** Fetch one entry by seq (one-shot; HISTORY page of one). */
+export async function getRoomMessageOnce(config, options) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        const backfill = await joinRoomOnClient(client, {
+            room: options.room,
+            limit: 1,
+        });
+        if (backfill.entries.some((entry) => entry.seq === options.seq)) {
+            return backfill.entries.find((entry) => entry.seq === options.seq) ?? null;
+        }
+        const page = await requestRoomHistoryPage(client, options.room, {
+            beforeSeq: options.seq + 1,
+            limit: 1,
+        });
+        return page.entries.find((entry) => entry.seq === options.seq) ?? null;
+    }
+    finally {
+        client.close();
+    }
+}
+export async function requestRoomReadState(client, rooms, timeoutMs) {
+    if (client.isGuest())
+        return { readState: {} };
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.READ_STATE,
+        payload: { requestId, rooms },
+        timestamp: Date.now(),
+    });
+    const result = await client.waitFor(RoomServerMessageType.READ_STATE, (msg) => msg.payload.requestId === requestId, timeoutMs, requestId);
+    return result.payload;
+}
+export async function searchRoomEntries(client, request) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.SEARCH_ENTRIES,
+        payload: {
+            requestId,
+            room: request.room,
+            query: request.query,
+            ...(request.beforeSeq !== undefined ? { beforeSeq: request.beforeSeq } : {}),
+            ...(request.sinceSeq !== undefined ? { sinceSeq: request.sinceSeq } : {}),
+            ...(request.fromMs !== undefined ? { fromMs: request.fromMs } : {}),
+            ...(request.toMs !== undefined ? { toMs: request.toMs } : {}),
+            ...(request.limit !== undefined ? { limit: request.limit } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const result = await client.waitFor(RoomServerMessageType.SEARCH_RESULTS, (msg) => msg.payload.requestId === requestId && msg.payload.room === normalizeRoomName(request.room), undefined, requestId);
+    return result.payload;
+}
+/** One-shot variant for headless surfaces (actions): connect, join, search,
+ *  close. The relay gates SEARCH_ENTRIES on per-socket room participation
+ *  (isInRoom checks this very WebSocket), so a minimal JOIN is required
+ *  first; the brief presence blip matches getRoomMessageOnce. */
+export async function searchRoomEntriesOnce(config, request) {
+    const client = new RoomWsClient(config);
+    try {
+        await client.connect();
+        await joinRoomOnClient(client, { room: request.room, limit: 1 });
+        return await searchRoomEntries(client, request);
+    }
+    finally {
+        client.close();
+    }
+}
+export async function requestRoomHistory(client, room, beforeSeq, limit) {
+    return requestRoomHistoryPage(client, room, { beforeSeq, limit });
+}
+export async function requestRoomHistoryPage(client, room, request) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.HISTORY,
+        payload: {
+            requestId,
+            room,
+            ...(request.beforeSeq !== undefined ? { beforeSeq: request.beforeSeq } : {}),
+            ...(request.sinceSeq !== undefined ? { sinceSeq: request.sinceSeq } : {}),
+            ...(request.atMs !== undefined ? { atMs: request.atMs } : {}),
+            limit: request.limit,
+        },
+        timestamp: Date.now(),
+    });
+    const history = await client.waitFor(RoomServerMessageType.HISTORY, (msg) => msg.payload.requestId === requestId && msg.payload.room === normalizeRoomName(room), undefined, requestId);
+    return history.payload;
+}
+/** `topicId` acks a per-topic cursor; the room-wide cursor is separate. */
+export function ackRoom(client, room, seq, topicId) {
+    client.send({
+        type: RoomClientMessageType.ACK,
+        payload: { room, seq, ...(topicId ? { topicId } : {}) },
+        timestamp: Date.now(),
+    });
+}
+export class RoomAckDebouncer {
+    client;
+    delayMs;
+    pending = new Map();
+    timer;
+    constructor(client, delayMs = 1_000) {
+        this.client = client;
+        this.delayMs = delayMs;
+    }
+    /** `topicId` batches a per-topic view-time cursor; omit for the room-wide one. */
+    schedule(room, seq, topicId) {
+        if (!Number.isFinite(seq) || seq <= 0)
+            return;
+        const normalizedRoom = normalizeRoomName(room);
+        const key = ackDebounceKey(normalizedRoom, topicId);
+        const previous = this.pending.get(key);
+        if (previous && seq <= previous.seq)
+            return;
+        this.pending.set(key, { room: normalizedRoom, topicId, seq });
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.flush();
+        }, this.delayMs);
+        this.timer.unref?.();
+    }
+    flush() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        const pending = [...this.pending.entries()];
+        this.pending.clear();
+        for (const [key, entry] of pending) {
+            // ACKs are fire-and-forget and seq is monotonic, so a send that fails
+            // because the socket just dropped is harmless — the next ACK (or the
+            // post-reconnect resync) supersedes it. Never let a debounced flush that
+            // fires inside a timer throw an uncaught error and take down the process.
+            try {
+                ackRoom(this.client, entry.room, entry.seq, entry.topicId);
+            }
+            catch {
+                // Re-queue the highest seq so a later flush (post-reconnect) retries it.
+                const current = this.pending.get(key);
+                if (!current || entry.seq > current.seq)
+                    this.pending.set(key, entry);
+            }
+        }
+    }
+    close() {
+        this.flush();
+    }
+}
+function ackDebounceKey(room, topicId) {
+    return `${encodeURIComponent(room)}:${encodeURIComponent(topicId ?? "")}`;
+}
+export async function createRoomTopic(config, request) {
+    // Always the relay websocket, never the store REST write: the relay's
+    // handleTopicCreate is what fans TOPIC_UPDATED out to room members (plus
+    // the cross-pod bus), while a direct store POST broadcasts nothing, so
+    // topics created that way stay invisible to open GUIs until their next
+    // hydrate. Every other topic mutation (topicResultViaWebSocket below)
+    // already rides the socket; create is no different.
+    //
+    // Room-scoped (unlike the topicId-only verbs sharing
+    // topicResultViaWebSocket below): the relay's handleTopicCreate checks
+    // the caller's connection is in the room, the same NOT_IN_ROOM gate
+    // sayRoom satisfies via joinRoomOnClient.
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        await joinRoomOnClient(client, { room: request.room });
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.TOPIC_CREATE,
+            payload: { requestId, room: request.room, name: request.name },
+            timestamp: Date.now(),
+        });
+        const result = await client.waitFor(RoomServerMessageType.TOPIC, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, topic: result.payload.topic };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function listRoomTopics(config, request) {
+    if (!config.webSocketCtor) {
+        try {
+            return await listRoomTopicsViaHttp(config, request);
+        }
+        catch (error) {
+            if (!shouldFallbackToRoomsWebSocket(error))
+                throw error;
+        }
+    }
+    // Room-scoped: the relay's handleTopicList uses the same read-target
+    // room-membership check as other room reads (assertRoomReadTarget), so
+    // the caller must join first, same as createRoomTopic above.
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        await joinRoomOnClient(client, { room: request.room });
+        const requestId = randomUUID();
+        client.send({
+            type: RoomClientMessageType.TOPIC_LIST,
+            payload: {
+                requestId,
+                room: request.room,
+                ...(request.includeResolved !== undefined
+                    ? { includeResolved: request.includeResolved }
+                    : {}),
+            },
+            timestamp: Date.now(),
+        });
+        const result = await client.waitFor(RoomServerMessageType.TOPICS, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, topics: result.payload.topics };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function renameRoomTopic(config, request) {
+    return topicResultViaWebSocket(config, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_RENAME,
+        payload: { requestId, topicId: request.topicId, name: request.name },
+        timestamp: Date.now(),
+    }));
+}
+export async function moveRoomTopicMessages(config, request) {
+    return topicResultViaWebSocket(config, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_MOVE,
+        payload: {
+            requestId,
+            topicId: request.topicId,
+            seqs: request.seqs,
+            toTopicId: request.toTopicId,
+        },
+        timestamp: Date.now(),
+    }));
+}
+export async function mergeRoomTopics(config, request) {
+    return topicResultViaWebSocket(config, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_MERGE,
+        payload: { requestId, topicId: request.topicId, intoTopicId: request.intoTopicId },
+        timestamp: Date.now(),
+    }));
+}
+export async function resolveRoomTopic(config, request) {
+    return topicResultViaWebSocket(config, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_RESOLVE,
+        payload: {
+            requestId,
+            topicId: request.topicId,
+            ...(request.resolved !== undefined ? { resolved: request.resolved } : {}),
+        },
+        timestamp: Date.now(),
+    }));
+}
+export async function setRoomTopicAttention(config, request) {
+    return topicResultViaWebSocket(config, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_SET_ATTENTION,
+        payload: { requestId, topicId: request.topicId, attention: request.attention },
+        timestamp: Date.now(),
+    }));
+}
+/** Send one topic verb frame and resolve on the TOPIC result that echoes
+ *  the requestId (every mutation verb replies TOPIC; only list replies
+ *  TOPICS). The requestId is also passed to waitFor so a coded ERROR frame
+ *  for this request rejects instead of timing out. */
+async function topicResultViaWebSocket(config, frame) {
+    const client = new RoomWsClient(config);
+    try {
+        const auth = await client.connect();
+        const requestId = randomUUID();
+        client.send(frame(requestId));
+        const result = await client.waitFor(RoomServerMessageType.TOPIC, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+        return { auth, topic: result.payload.topic };
+    }
+    finally {
+        client.close();
+    }
+}
+async function listRoomTopicsViaHttp(config, request) {
+    const room = normalizeRoomName(request.room);
+    const params = new URLSearchParams();
+    if (request.includeResolved)
+        params.set("includeResolved", "true");
+    const result = await roomHttpRequest(config, `/rooms/${encodeURIComponent(room)}/topics${params.size ? `?${params.toString()}` : ""}`);
+    return {
+        auth: authFromApiKey(config.apiKey),
+        topics: Array.isArray(result.topics) ? result.topics : [],
+    };
+}
+export async function requestRoomTopicsOnClient(client, request) {
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.TOPIC_LIST,
+        payload: {
+            requestId,
+            room: normalizeRoomName(request.room),
+            ...(request.includeResolved !== undefined
+                ? { includeResolved: request.includeResolved }
+                : {}),
+            ...(request.withState ? { withState: true } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const result = await client.waitFor(RoomServerMessageType.TOPICS, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+    return result.payload;
+}
+export async function createRoomTopicOnClient(client, request) {
+    return topicResultOnClient(client, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_CREATE,
+        payload: {
+            requestId,
+            room: normalizeRoomName(request.room),
+            name: request.name,
+        },
+        timestamp: Date.now(),
+    }));
+}
+export async function renameRoomTopicOnClient(client, request) {
+    return topicResultOnClient(client, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_RENAME,
+        payload: {
+            requestId,
+            topicId: request.topicId,
+            name: request.name,
+        },
+        timestamp: Date.now(),
+    }));
+}
+export async function setRoomTopicAttentionOnClient(client, request) {
+    return topicResultOnClient(client, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_SET_ATTENTION,
+        payload: {
+            requestId,
+            topicId: request.topicId,
+            attention: request.attention,
+        },
+        timestamp: Date.now(),
+    }));
+}
+export async function resolveRoomTopicOnClient(client, request) {
+    return topicResultOnClient(client, (requestId) => ({
+        type: RoomClientMessageType.TOPIC_RESOLVE,
+        payload: {
+            requestId,
+            topicId: request.topicId,
+            ...(request.resolved !== undefined ? { resolved: request.resolved } : {}),
+        },
+        timestamp: Date.now(),
+    }));
+}
+async function topicResultOnClient(client, frame) {
+    const requestId = randomUUID();
+    client.send(frame(requestId));
+    const result = await client.waitFor(RoomServerMessageType.TOPIC, (msg) => msg.payload.requestId === requestId, undefined, requestId);
+    return result.payload;
+}
+async function joinRoomOnClient(client, options) {
+    const requestId = randomUUID();
+    const renderedSuggestionAttribution = options.sinceSeq === undefined && !options.isRejoin && !options.hook && !options.suggestionId
+        ? consumeRoomSuggestionAttribution(options.room)
+        : undefined;
+    const hook = options.hook ?? renderedSuggestionAttribution?.hook;
+    const suggestionId = options.suggestionId ?? renderedSuggestionAttribution?.suggestionId;
+    client.send({
+        type: RoomClientMessageType.JOIN,
+        payload: {
+            requestId,
+            room: options.room,
+            ...(options.workspaceId ? { workspaceId: options.workspaceId } : {}),
+            ...(options.code ? { code: options.code } : {}),
+            ...(options.sinceSeq !== undefined ? { sinceSeq: options.sinceSeq } : {}),
+            ...(options.limit !== undefined ? { limit: options.limit } : {}),
+            ...(options.reason ? { reason: options.reason } : {}),
+            ...(options.source ? { source: options.source } : {}),
+            ...(hook ? { hook } : {}),
+            ...(suggestionId ? { suggestionId } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const backfill = await client.waitFor(RoomServerMessageType.BACKFILL, (msg) => msg.payload.requestId === requestId ||
+        (!msg.payload.requestId && msg.payload.room === normalizeRoomName(options.room)), undefined, requestId);
+    return backfill.payload;
+}
+function normalizeRoomName(room) {
+    return room.trim().replace(/^#/, "").toLowerCase();
+}
+async function listRoomsViaHttp(config, request) {
+    const params = new URLSearchParams();
+    if (request.query)
+        params.set("query", request.query);
+    if (request.scope)
+        params.set("scope", request.scope);
+    appendAll(params, "category", request.category);
+    appendAll(params, "tag", request.tag);
+    appendAll(params, "kind", request.kind);
+    appendAll(params, "entity", request.entity);
+    appendAll(params, "symbol", request.symbol);
+    appendAll(params, "spaceId", request.spaceId);
+    if (request.hot)
+        params.set("hot", "true");
+    if (request.includeHeat)
+        params.set("includeHeat", "true");
+    if (request.createdByMe)
+        params.set("createdByMe", "true");
+    if (request.includeArchived)
+        params.set("includeArchived", "true");
+    if (request.limit !== undefined)
+        params.set("limit", String(request.limit));
+    const result = await roomHttpRequest(config, `/rooms${params.size ? `?${params.toString()}` : ""}`);
+    return {
+        auth: authFromApiKey(config.apiKey),
+        rooms: Array.isArray(result.rooms) ? result.rooms : [],
+    };
+}
+async function peekRoomViaHttp(config, options) {
+    const params = new URLSearchParams();
+    if (options.beforeSeq !== undefined)
+        params.set("beforeSeq", String(options.beforeSeq));
+    if (options.sinceSeq !== undefined)
+        params.set("sinceSeq", String(options.sinceSeq));
+    if (options.atMs !== undefined)
+        params.set("atMs", String(options.atMs));
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const result = await roomHttpRequest(config, `/rooms/${encodeURIComponent(normalizeRoomName(options.room))}/events${params.size ? `?${params.toString()}` : ""}`);
+    return {
+        room: result.room || normalizeRoomName(options.room),
+        entries: Array.isArray(result.entries) ? result.entries : [],
+        upToSeq: typeof result.upToSeq === "number" ? result.upToSeq : options.sinceSeq || 0,
+        hasMore: Boolean(result.hasMore),
+        ...(result.readOnly !== undefined ? { readOnly: result.readOnly } : {}),
+        ...(result.beforeSeq !== undefined ? { beforeSeq: result.beforeSeq } : {}),
+        ...(result.sinceSeq !== undefined ? { sinceSeq: result.sinceSeq } : {}),
+        ...(result.atMs !== undefined ? { atMs: result.atMs } : {}),
+    };
+}
+async function createRoomViaHttp(config, request) {
+    const result = await roomHttpRequest(config, "/rooms", {
+        method: "POST",
+        body: request,
+    });
+    if (!result.room)
+        throw new RoomHttpError("chat service returned no room", 502);
+    return {
+        auth: authFromApiKey(config.apiKey),
+        room: result.room,
+        ...(result.joinCode ? { joinCode: result.joinCode } : {}),
+    };
+}
+async function inviteRoomViaHttp(config, request) {
+    const room = normalizeRoomName(request.room);
+    const result = await roomHttpRequest(config, `/rooms/${encodeURIComponent(room)}/invites`, {
+        method: "POST",
+        body: {
+            ...(request.username ? { username: request.username } : {}),
+            ...(request.userId ? { userId: request.userId } : {}),
+        },
+    });
+    const invitedUserId = result.invitedUserId;
+    const invitedHandle = result.invitedHandle;
+    if (!invitedUserId || !invitedHandle) {
+        throw new RoomHttpError("chat service returned no invited member", 502);
+    }
+    return {
+        auth: authFromApiKey(config.apiKey),
+        invite: {
+            room: result.room || room,
+            invitedUserId,
+            invitedHandle,
+        },
+    };
+}
+async function removeRoomMemberViaHttp(config, request) {
+    const room = normalizeRoomName(request.room);
+    const result = await roomHttpRequest(config, `/rooms/${encodeURIComponent(room)}/members/remove`, {
+        method: "POST",
+        body: {
+            ...(request.username ? { username: request.username } : {}),
+            ...(request.userId ? { userId: request.userId } : {}),
+        },
+    });
+    const removedUserId = result.removedUserId;
+    const removedHandle = result.removedHandle;
+    if (!removedUserId || !removedHandle) {
+        throw new RoomHttpError("chat service returned no removed member", 502);
+    }
+    return {
+        auth: authFromApiKey(config.apiKey),
+        removal: {
+            room: result.room || room,
+            removedUserId,
+            removedHandle,
+        },
+    };
+}
+async function roomHttpRequest(config, path, init = {}) {
+    const url = `${resolveRoomChatApiUrl(config)}${path}`;
+    const signal = init.signal ?? roomHttpTimeoutSignal(config.timeoutMs);
+    let res;
+    try {
+        res = await fetch(url, {
+            method: init.method ?? "GET",
+            ...(signal ? { signal } : {}),
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+                Accept: "application/json",
+                ...(init.body !== undefined ? { "Content-Type": "application/json" } : {}),
+            },
+            ...(init.body !== undefined ? { body: JSON.stringify(init.body) } : {}),
+        });
+    }
+    catch (error) {
+        throw new RoomHttpError(error instanceof Error ? error.message : String(error), 0);
+    }
+    const text = await res.text();
+    let body = {};
+    if (text) {
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            body = {
+                message: text
+                    .replace(/<[^>]*>/g, " ")
+                    .replace(/\s+/g, " ")
+                    .trim(),
+            };
+        }
+    }
+    if (!res.ok) {
+        throw new RoomHttpError(errorMessageFromBody(body) || `chat service returned ${res.status}`, res.status);
+    }
+    return (body ?? {});
+}
+function roomHttpTimeoutSignal(timeoutMs) {
+    if (!timeoutMs || !Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        return undefined;
+    return AbortSignal.timeout(timeoutMs);
+}
+class RoomHttpError extends Error {
+    status;
+    name = "RoomHttpError";
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+function shouldFallbackToRoomsWebSocket(error) {
+    return error instanceof RoomHttpError && (error.status === 0 || error.status === 404);
+}
+export function resolveRoomChatApiUrl(config = {}) {
+    if (config.apiUrl?.trim())
+        return trimTrailingSlash(config.apiUrl.trim());
+    const explicit = envString("OM_ROOM_CHAT_API_URL")?.trim() || envString("OM_CHAT_API_URL")?.trim();
+    if (explicit)
+        return trimTrailingSlash(explicit);
+    try {
+        const url = new URL(config.url || resolveRoomsWsUrl());
+        url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+        url.pathname = "/chat";
+        url.search = "";
+        url.hash = "";
+        return trimTrailingSlash(url.toString());
+    }
+    catch {
+        return trimTrailingSlash(ROOM_CHAT_API_URL);
+    }
+}
+function appendAll(params, key, values) {
+    for (const value of values || []) {
+        if (value)
+            params.append(key, value);
+    }
+}
+function errorMessageFromBody(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const record = body;
+    return typeof record.message === "string"
+        ? record.message
+        : typeof record.error === "string"
+            ? record.error
+            : null;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+export function normalizePresence(payload) {
+    const sample = payload.sample ?? payload.members ?? [];
+    const total = payload.total ?? payload.humans + payload.agents;
+    return {
+        ...payload,
+        total,
+        sample,
+        members: payload.members ?? sample,
+    };
+}
+export function presenceFromWho(payload) {
+    const sampleAgents = payload.members.filter((member) => member.isAgent).length;
+    const agents = payload.agents ?? sampleAgents;
+    const humans = payload.humans ??
+        (payload.total > payload.members.length
+            ? Math.max(0, payload.total - agents)
+            : payload.members.filter((member) => !member.isAgent).length);
+    return {
+        room: payload.room,
+        members: payload.members,
+        sample: payload.members,
+        humans,
+        agents,
+        total: payload.total,
+        ...(payload.guestCount !== undefined ? { guestCount: payload.guestCount } : {}),
+        ...(payload.requestId ? { requestId: payload.requestId } : {}),
+    };
+}