@openmarket/rooms-client 0.1.0

package/dist/social-client.js

@@ -0,0 +1,686 @@
+import { resolveRoomsWsUrl } from "./client.js";
+import { envString, ROOM_CHAT_API_URL } from "./endpoints.js";
+export const ROOM_ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024;
+export class RoomSocialError extends Error {
+    name = "RoomSocialError";
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        if (details !== undefined)
+            this.details = details;
+    }
+}
+export function resolveRoomChatApiUrl() {
+    const explicit = envString("OM_ROOM_CHAT_API_URL")?.trim() || envString("OM_CHAT_API_URL")?.trim();
+    if (explicit)
+        return trimTrailingSlash(explicit);
+    return deriveRoomChatApiUrlFromRoomsUrl(resolveRoomsWsUrl()) ?? ROOM_CHAT_API_URL;
+}
+export function deriveRoomChatApiUrlFromRoomsUrl(wsUrl) {
+    try {
+        const url = new URL(wsUrl);
+        url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+        url.pathname = "/chat";
+        url.search = "";
+        url.hash = "";
+        return trimTrailingSlash(url.toString());
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function listRoomFriends(config) {
+    const result = await socialRequest(config, "/friends");
+    return result.friends ?? [];
+}
+export async function sendRoomFriendRequest(config, username) {
+    return socialRequest(config, "/friends/request", {
+        method: "POST",
+        body: { addresseeUsername: cleanUsername(username) },
+    });
+}
+export async function listRoomFriendRequests(config) {
+    const result = await socialRequest(config, "/friends/requests");
+    return { sent: result.sent ?? [], received: result.received ?? [] };
+}
+export async function acceptRoomFriendRequest(config, friendshipId) {
+    return socialRequest(config, `/friends/accept/${encodeURIComponent(friendshipId)}`, {
+        method: "POST",
+    });
+}
+export async function rejectRoomFriendRequest(config, friendshipId) {
+    return socialRequest(config, `/friends/reject/${encodeURIComponent(friendshipId)}`, {
+        method: "POST",
+    });
+}
+export async function removeRoomFriend(config, friendshipId) {
+    return socialRequest(config, `/friends/${encodeURIComponent(friendshipId)}`, {
+        method: "DELETE",
+    });
+}
+export async function listRoomFollowing(config) {
+    const result = await socialRequest(config, "/follows/following");
+    return result.following ?? [];
+}
+export async function followRoomUser(config, username) {
+    return socialRequest(config, `/follows/${encodeURIComponent(cleanUsername(username))}`, {
+        method: "POST",
+    });
+}
+export async function unfollowRoomUser(config, username) {
+    return socialRequest(config, `/follows/${encodeURIComponent(cleanUsername(username))}`, {
+        method: "DELETE",
+    });
+}
+export async function listRoomDmInbox(config, options = {}) {
+    const params = new URLSearchParams();
+    if (options.unreadOnly !== undefined)
+        params.set("unreadOnly", String(options.unreadOnly));
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const result = await socialRequest(config, `/dms${params.size ? `?${params.toString()}` : ""}`);
+    return result.conversations ?? [];
+}
+export async function listUnreadRoomDms(config, options = {}) {
+    const params = new URLSearchParams();
+    if (options.username)
+        params.set("username", cleanUsername(options.username));
+    if (options.limitPerConversation !== undefined) {
+        params.set("limitPerConversation", String(options.limitPerConversation));
+    }
+    if (options.markRead !== undefined)
+        params.set("markRead", String(options.markRead));
+    const init = {};
+    if (options.signal)
+        init.signal = options.signal;
+    const result = await socialRequest(config, `/dms/unread${params.size ? `?${params.toString()}` : ""}`, init);
+    return result.conversations ?? [];
+}
+export async function getRoomDmHistory(config, username, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    if (options.before !== undefined)
+        params.set("before", String(options.before));
+    if (options.markRead !== undefined)
+        params.set("markRead", String(options.markRead));
+    return socialRequest(config, `/dms/${encodeURIComponent(cleanUsername(username))}/history${params.size ? `?${params.toString()}` : ""}`);
+}
+export async function sendRoomDm(config, username, content) {
+    return socialRequest(config, `/dms/${encodeURIComponent(cleanUsername(username))}/messages`, {
+        method: "POST",
+        body: { content },
+    });
+}
+/** Send a sealed DM: the opaque envelope rides in place of content (the door
+ *  accepts exactly one of the two). Callers seal first; nothing here can. */
+export async function sendRoomDmSecret(config, username, secret) {
+    return socialRequest(config, `/dms/${encodeURIComponent(cleanUsername(username))}/messages`, {
+        method: "POST",
+        body: { secret },
+    });
+}
+/**
+ * CAS write conflict: the doc's head moved past the caller's baseRev. Carries
+ * the current head (fetched on demand when the transport dropped it) so the
+ * caller can rebase — typically an agent merge — and retry.
+ */
+export class RoomDocConflictError extends RoomSocialError {
+    head;
+    constructor(message, head) {
+        super(message, 409);
+        this.head = head;
+    }
+}
+function isDocConflict(error) {
+    if (!(error instanceof RoomSocialError) || error.status !== 409)
+        return false;
+    const details = error.details;
+    return details?.tag === "DOC_CONFLICT";
+}
+function conflictHeadFromDetails(details) {
+    const head = details?.head;
+    return head && typeof head.rev === "number" ? head : null;
+}
+/** Wrap a doc write so CAS conflicts surface as RoomDocConflictError with the
+ *  head attached (re-fetched when the relay passthrough stripped it). */
+async function withDocConflict(config, docId, call) {
+    try {
+        return await call();
+    }
+    catch (error) {
+        if (!isDocConflict(error))
+            throw error;
+        let head = conflictHeadFromDetails(error.details);
+        if (!head) {
+            const doc = await getRoomDoc(config, docId).catch(() => null);
+            if (doc && doc.content !== undefined) {
+                head = {
+                    rev: doc.headRev,
+                    sha: doc.headSha,
+                    content: doc.content,
+                    note: doc.headNote,
+                    authorHandle: doc.headAuthorHandle,
+                    isAgent: doc.headIsAgent,
+                    at: doc.headAt,
+                };
+            }
+        }
+        throw new RoomDocConflictError(error.message, head);
+    }
+}
+export async function listRoomDocs(config, options) {
+    const params = new URLSearchParams({ spaceId: options.spaceId });
+    if (options.prefix)
+        params.set("prefix", options.prefix);
+    if (options.includeArchived)
+        params.set("includeArchived", "true");
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const result = await socialRequest(config, `/docs?${params.toString()}`);
+    return result.docs ?? [];
+}
+export async function getRoomDocChanges(config, options) {
+    const params = new URLSearchParams({ spaceId: options.spaceId });
+    if (options.since !== undefined)
+        params.set("since", String(options.since));
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const init = {};
+    if (options.signal)
+        init.signal = options.signal;
+    const result = await socialRequest(config, `/docs/changes?${params.toString()}`, init);
+    return {
+        changes: result.changes ?? [],
+        cursor: result.cursor ?? options.since ?? 0,
+        latestSeq: result.latestSeq ?? result.cursor ?? 0,
+    };
+}
+export async function searchRoomDocs(config, options) {
+    const params = new URLSearchParams({ spaceId: options.spaceId, q: options.q });
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const result = await socialRequest(config, `/docs/search?${params.toString()}`);
+    return result.docs ?? [];
+}
+export async function resolveRoomDoc(config, spaceId, path) {
+    const params = new URLSearchParams({ spaceId, path });
+    const result = await socialRequest(config, `/docs/resolve?${params.toString()}`);
+    return result.doc;
+}
+export async function getRoomDoc(config, docId) {
+    const result = await socialRequest(config, `/docs/${encodeURIComponent(docId)}`);
+    return result.doc;
+}
+export async function createRoomDoc(config, input) {
+    const result = await socialRequest(config, "/docs", {
+        method: "POST",
+        body: input,
+    });
+    return result.doc;
+}
+export async function updateRoomDoc(config, docId, input) {
+    return withDocConflict(config, docId, () => socialRequest(config, `/docs/${encodeURIComponent(docId)}`, {
+        method: "PATCH",
+        body: input,
+    }));
+}
+export async function updateRoomDocMeta(config, docId, input) {
+    const result = await withDocConflict(config, docId, () => socialRequest(config, `/docs/${encodeURIComponent(docId)}/meta`, {
+        method: "PATCH",
+        body: input,
+    }));
+    return result.doc;
+}
+export async function listRoomDocRevisions(config, docId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.beforeRev !== undefined)
+        params.set("beforeRev", String(options.beforeRev));
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const result = await socialRequest(config, `/docs/${encodeURIComponent(docId)}/revisions${params.size ? `?${params.toString()}` : ""}`);
+    return result.revisions ?? [];
+}
+export async function getRoomDocRevision(config, docId, rev) {
+    const result = await socialRequest(config, `/docs/${encodeURIComponent(docId)}/revisions/${rev}`);
+    return result.revision;
+}
+export async function revertRoomDoc(config, docId, input) {
+    return withDocConflict(config, docId, () => socialRequest(config, `/docs/${encodeURIComponent(docId)}/revert`, {
+        method: "POST",
+        body: input,
+    }));
+}
+/**
+ * Selective run revert: undo every revision one agent run produced, as ONE
+ * new attributed revision computed server-side (inverse three-way merge
+ * against the current head; later edits survive). A diverging merge comes
+ * back as {status:"conflict"} OUTCOME data carrying the three contents and
+ * regions for the reconcile surface; nothing was written. A mid-commit CAS
+ * race still throws RoomDocConflictError like every other doc write.
+ */
+export async function revertRoomDocRun(config, docId, input) {
+    return withDocConflict(config, docId, () => socialRequest(config, `/docs/${encodeURIComponent(docId)}/revert-run`, {
+        method: "POST",
+        body: input,
+    }));
+}
+export async function createSpaceRestorePlan(config, input) {
+    const result = await socialRequest(config, "/docs/restore-plans", { method: "POST", body: input });
+    return result.plan;
+}
+export async function getSpaceRestorePlan(config, planId) {
+    const result = await socialRequest(config, `/docs/restore-plans/${encodeURIComponent(planId)}`);
+    return result.plan;
+}
+export async function applySpaceRestorePlan(config, planId, confirmSpaceId) {
+    const result = await socialRequest(config, `/docs/restore-plans/${encodeURIComponent(planId)}/apply`, {
+        method: "POST",
+        body: { confirmSpaceId },
+    });
+    if (result.receipt)
+        return result.receipt;
+    if (!result.plan) {
+        throw new RoomSocialError("Restore start returned no plan or receipt", 502, result);
+    }
+    let plan = result.plan;
+    const deadline = Date.now() + 6 * 60_000;
+    while (Date.now() < deadline) {
+        const receipt = spaceRestoreReceiptFromPlan(plan);
+        if (receipt)
+            return receipt;
+        if (plan.status === "failed" || plan.status === "stale") {
+            throw new RoomSocialError(plan.error ??
+                `Restore is ${plan.status} after ${plan.appliedCount}/${plan.summary.totalActions} actions`, 409, { plan });
+        }
+        if (plan.status !== "applying") {
+            throw new RoomSocialError(`Restore start returned plan status ${plan.status}`, 409, {
+                plan,
+            });
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        plan = await getSpaceRestorePlan(config, planId);
+    }
+    throw new RoomSocialError("Restore is still applying; recheck the durable plan", 202, { plan });
+}
+/** Recover the durable receipt shape from an authoritative applied plan.
+ * Useful when the apply response was lost after the server committed. */
+export function spaceRestoreReceiptFromPlan(plan) {
+    if (plan.status !== "applied" || plan.appliedAt === null || plan.resultingCursor === null) {
+        return null;
+    }
+    return {
+        planId: plan.planId,
+        spaceId: plan.spaceId,
+        restoreAt: plan.restoreAt,
+        reason: plan.reason,
+        status: "applied",
+        appliedActions: plan.appliedCount,
+        resultingCursor: plan.resultingCursor,
+        appliedAt: plan.appliedAt,
+        summary: plan.summary,
+    };
+}
+export async function archiveRoomDoc(config, docId, input = {}) {
+    const result = await socialRequest(config, `/docs/${encodeURIComponent(docId)}/archive`, { method: "POST", body: input });
+    return result.doc;
+}
+/** Renew (or create) the caller's "editing" lease on a doc: I hold a dirty
+ *  working copy. Heartbeat well inside the server TTL; content never rides. */
+export async function heartbeatDocEditing(config, docId, options = {}) {
+    const result = await socialRequest(config, `/docs/${encodeURIComponent(docId)}/editing`, { method: "PUT", body: options });
+    return result.lease ?? null;
+}
+/** Drop the caller's own editing lease (publish or discard). */
+export async function clearDocEditing(config, docId) {
+    const result = await socialRequest(config, `/docs/${encodeURIComponent(docId)}/editing`, { method: "DELETE" });
+    return { cleared: result.cleared === true };
+}
+/** Active editing leases across a space (rides the existing library poll). */
+export async function listDocEditing(config, spaceId) {
+    const params = new URLSearchParams({ spaceId });
+    const result = await socialRequest(config, `/docs/editing?${params.toString()}`);
+    return result.editing ?? [];
+}
+export async function listRoomSpacesViaChat(config) {
+    const result = await socialRequest(config, "/spaces");
+    return result.spaces ?? [];
+}
+export async function getUserPrefs(config) {
+    const result = await socialRequest(config, "/users/prefs");
+    return result.prefs ?? {};
+}
+/** Whole-blob replace (16KB cap server-side; last writer wins). */
+export async function setUserPrefs(config, prefs) {
+    await socialRequest(config, "/users/prefs", { method: "PUT", body: { prefs } });
+}
+export async function listSpaceRoles(config, spaceId) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/roles`);
+    return result.roles ?? [];
+}
+export async function createSpaceRole(config, spaceId, input) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/roles`, { method: "POST", body: input });
+    if (!result.role)
+        throw new Error("Role create returned no role");
+    return result.role;
+}
+export async function updateSpaceRole(config, spaceId, roleId, patch) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/roles/${encodeURIComponent(roleId)}`, { method: "PATCH", body: patch });
+    if (!result.role)
+        throw new Error("Role update returned no role");
+    return result.role;
+}
+export async function deleteSpaceRole(config, spaceId, roleId) {
+    await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/roles/${encodeURIComponent(roleId)}`, { method: "DELETE" });
+}
+export async function setSpaceMemberRoles(config, spaceId, targetUserId, roleIds) {
+    return socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(targetUserId)}/roles`, { method: "PUT", body: { roleIds } });
+}
+export async function listSpaceMembers(config, spaceId) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members`);
+    return result.members ?? [];
+}
+export async function addSpaceMember(config, spaceId, input) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members`, { method: "POST", body: input });
+    return result.member;
+}
+/** Create (or refresh) a pending invitation. Membership needs their accept. */
+export async function createSpaceInvite(config, spaceId, input) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/invites`, { method: "POST", body: input });
+    return result.invite;
+}
+/** The caller's own pending invitations. */
+export async function listMySpaceInvites(config) {
+    const result = await socialRequest(config, "/spaces/invites");
+    return result.invites ?? [];
+}
+/** Pending invitations for a space (managers only). */
+export async function listSpaceInvites(config, spaceId) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/invites`);
+    return result.invites ?? [];
+}
+export async function acceptSpaceInvite(config, inviteId) {
+    const result = await socialRequest(config, `/spaces/invites/${encodeURIComponent(inviteId)}/accept`, { method: "POST" });
+    return result.space;
+}
+export async function declineSpaceInvite(config, inviteId) {
+    return socialRequest(config, `/spaces/invites/${encodeURIComponent(inviteId)}/decline`, {
+        method: "POST",
+    });
+}
+/** Mint (or rotate) the shareable join code; plaintext comes back once. */
+export async function setSpaceJoinCode(config, spaceId) {
+    return socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/join-code`, {
+        method: "PUT",
+    });
+}
+export async function clearSpaceJoinCode(config, spaceId) {
+    return socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/join-code`, {
+        method: "DELETE",
+    });
+}
+/** Redeem a shareable `<spaceId>:<code>` invite. */
+export async function joinSpaceByCode(config, spaceId, code) {
+    const result = await socialRequest(config, "/spaces/join", { method: "POST", body: { spaceId, code } });
+    return result.space;
+}
+/**
+ * Bulk identity read (avatar/status/custom text) for tapes and rosters: ONE
+ * request, cap 100 ids. Identity lives on the platform user record
+ * (user_settings.profileUrl / presenceStatus / statusText) — the wire names
+ * map onto the chat-facing shape here. Status WRITES ride the ws STATUS
+ * frame (the relay persists them), avatar writes go through uploadAvatar.
+ */
+export async function getBulkProfiles(config, userIds) {
+    if (userIds.length === 0)
+        return [];
+    const result = await socialRequest(config, "/rooms/profiles/bulk", {
+        method: "POST",
+        body: { userIds },
+    });
+    return userIds.map((userId) => {
+        const wire = result.profiles?.[userId];
+        const status = wire?.presenceStatus;
+        return {
+            userId,
+            status: status === "online" || status === "idle" || status === "dnd" ? status : null,
+            statusText: wire?.statusText ?? null,
+            avatarUrl: wire?.profileUrl ?? null,
+        };
+    });
+}
+/** Rename / re-describe / re-order a channel (owner/admin). */
+export async function updateRoomChannel(config, room, input) {
+    const result = await socialRequest(config, `/rooms/${encodeURIComponent(cleanRoomId(room))}`, { method: "PATCH", body: input });
+    return result.room;
+}
+/** Authoritative single-room meta: the store's resolve route through the
+ *  relay BFF (existence-hiding 404 preserved). The task engine's policy
+ *  read rides this, never the ranked room search, because a fresh
+ *  zero-heat room can be crowded out of a search page and an enforcement
+ *  read must be deterministic. */
+export async function resolveRoomChannel(config, room) {
+    const result = await socialRequest(config, `/rooms/${encodeURIComponent(cleanRoomId(room))}/resolve`, { method: "GET" });
+    return result.room;
+}
+/** Archive a channel (owner/admin): drops from listings, refuses posts. */
+export async function archiveRoomChannel(config, room) {
+    return socialRequest(config, `/rooms/${encodeURIComponent(cleanRoomId(room))}`, {
+        method: "DELETE",
+    });
+}
+/** Rename / re-access / re-icon a server (managers). */
+export async function updateRoomSpace(config, spaceId, input) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}`, { method: "PATCH", body: input });
+    return result.space;
+}
+/** Archive a server (owner only). */
+export async function archiveRoomSpace(config, spaceId) {
+    return socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}`, { method: "DELETE" });
+}
+/** Full channel roster (paged): role + lastSeen for every membership row. */
+export async function listRoomChannelMembers(config, roomId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.offset !== undefined)
+        params.set("offset", String(options.offset));
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const result = await socialRequest(config, `/rooms/${encodeURIComponent(roomId)}/members${params.size ? `?${params}` : ""}`);
+    return {
+        total: result.total ?? result.members?.length ?? 0,
+        offset: result.offset ?? 0,
+        members: result.members ?? [],
+    };
+}
+export async function removeSpaceMember(config, spaceId, targetUserId) {
+    return socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(targetUserId)}`, { method: "DELETE" });
+}
+export async function changeSpaceMemberRole(config, spaceId, targetUserId, role) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(targetUserId)}/role`, { method: "PATCH", body: { role } });
+    return result.member;
+}
+export async function createRoomSpace(config, input) {
+    const result = await socialRequest(config, "/spaces", {
+        method: "POST",
+        body: input,
+    });
+    return result.space ?? {};
+}
+export async function restoreRoomDoc(config, docId, input = {}) {
+    const result = await socialRequest(config, `/docs/${encodeURIComponent(docId)}/restore`, { method: "POST", body: input });
+    return result.doc;
+}
+export async function getRoomAttachmentUrl(config, room, key) {
+    const params = new URLSearchParams({ key });
+    const result = await socialRequest(config, `/rooms/${encodeURIComponent(cleanRoomId(room))}/attachment-url?${params.toString()}`, { method: "GET" });
+    if (!result.url) {
+        throw new RoomSocialError("Attachment sign failed", 502, result);
+    }
+    return { url: result.url, expiresAt: result.expiresAt ?? null };
+}
+export async function getRoomPublicProfile(config, userId, hints = {}) {
+    const params = new URLSearchParams();
+    if (hints.handle)
+        params.set("handle", hints.handle);
+    if (hints.username)
+        params.set("username", hints.username);
+    if (hints.displayName)
+        params.set("displayName", hints.displayName);
+    const suffix = params.size ? `?${params.toString()}` : "";
+    const result = await socialRequest(config, `/rooms/profiles/${encodeURIComponent(userId)}${suffix}`);
+    return result.profile ?? { userId };
+}
+export async function listRoomReplies(config, options = {}) {
+    const params = new URLSearchParams();
+    if (options.unreadOnly !== undefined)
+        params.set("unreadOnly", String(options.unreadOnly));
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const init = {};
+    if (options.signal)
+        init.signal = options.signal;
+    const result = await socialRequest(config, `/rooms/replies${params.size ? `?${params.toString()}` : ""}`, init);
+    return {
+        replies: result.replies ?? [],
+        unreadCount: result.unreadCount ?? 0,
+    };
+}
+export async function markRoomRepliesRead(config, options = {}) {
+    const body = {};
+    if (options.room)
+        body.roomId = cleanRoomId(options.room);
+    if (options.before instanceof Date) {
+        body.before = options.before.toISOString();
+    }
+    else if (options.before) {
+        body.before = options.before;
+    }
+    const result = await socialRequest(config, "/rooms/replies/read", {
+        method: "POST",
+        body,
+    });
+    return { markedRead: result.markedRead ?? 0 };
+}
+export async function suggestRooms(config, request, options = {}) {
+    const init = {
+        method: "POST",
+        body: request,
+    };
+    if (options.signal)
+        init.signal = options.signal;
+    const result = await socialRequest(config, "/rooms/suggestions", init);
+    return result.suggestions ?? [];
+}
+export async function socialRequest(config, path, init = {}) {
+    const url = `${trimTrailingSlash(config.apiUrl)}${path}`;
+    const hasJsonBody = init.body !== undefined;
+    const res = await fetch(url, {
+        method: init.method ?? "GET",
+        headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            Accept: "application/json",
+            ...(hasJsonBody ? { "Content-Type": "application/json" } : {}),
+        },
+        ...(hasJsonBody
+            ? { body: JSON.stringify(init.body) }
+            : init.formData
+                ? { body: init.formData }
+                : {}),
+        ...(init.signal !== undefined ? { signal: init.signal } : {}),
+    });
+    let body;
+    const text = await res.text();
+    if (text) {
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            body = { message: nonJsonErrorMessage(text, res.status, url) };
+        }
+    }
+    if (!res.ok) {
+        let message = errorMessageFromBody(body) || `chat service returned ${res.status}`;
+        // Express's bare route-miss ("Cannot POST /chat/spaces") reaches us as
+        // JSON on some deployments and says nothing useful. Translate it the
+        // same way as the HTML variant: the server is older than this CLI.
+        if (res.status === 404 && /^Cannot (GET|POST|PUT|PATCH|DELETE)\b/i.test(message)) {
+            message = `chat service route not found: ${requestPath(url)} — the server is running an older build than this CLI (check OM_ROOM_CHAT_API_URL / OM_ROOMS_WS_URL)`;
+        }
+        throw new RoomSocialError(message, res.status, body);
+    }
+    return (body ?? {});
+}
+export function cleanUsername(username) {
+    return username.trim().replace(/^@/, "");
+}
+export function cleanRoomId(room) {
+    return room.trim().replace(/^#/, "");
+}
+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 nonJsonErrorMessage(text, status, url) {
+    const rendered = text
+        .replace(/<[^>]*>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const path = requestPath(url);
+    if (status === 404 && /^Cannot (GET|POST|PUT|PATCH|DELETE)\b/i.test(rendered)) {
+        return `chat service route not found: ${path}. Check OM_ROOM_CHAT_API_URL and that chat-service is running the OM Rooms social routes.`;
+    }
+    if (!rendered)
+        return `chat service returned ${status}`;
+    return rendered.length > 240 ? `${rendered.slice(0, 237)}...` : rendered;
+}
+function requestPath(url) {
+    try {
+        const parsed = new URL(url);
+        return `${parsed.pathname}${parsed.search}`;
+    }
+    catch {
+        return url;
+    }
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+export function mimeFromFilename(filename) {
+    const lower = filename.toLowerCase();
+    if (lower.endsWith(".png"))
+        return "image/png";
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+        return "image/jpeg";
+    if (lower.endsWith(".webp"))
+        return "image/webp";
+    if (lower.endsWith(".gif"))
+        return "image/gif";
+    if (lower.endsWith(".pdf"))
+        return "application/pdf";
+    if (lower.endsWith(".txt"))
+        return "text/plain";
+    if (lower.endsWith(".md") || lower.endsWith(".markdown"))
+        return "text/markdown";
+    if (lower.endsWith(".csv"))
+        return "text/csv";
+    if (lower.endsWith(".json"))
+        return "application/json";
+    if (lower.endsWith(".docx")) {
+        return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    }
+    if (lower.endsWith(".xlsx")) {
+        return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    }
+    if (lower.endsWith(".pptx")) {
+        return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    }
+    return "application/octet-stream";
+}