@takosjp/yurucommu-api 2.0.0

package/dist/index.js

@@ -0,0 +1,1024 @@
+// src/lib/fetch-with-timeout.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 15000;
+var UPLOAD_REQUEST_TIMEOUT_MS = 60000;
+async function fetchWithTimeout(input, init = {}) {
+  const { timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, signal, ...rest } = init;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return fetch(input, { ...rest, signal });
+  }
+  const controller = new AbortController;
+  const abortFromSignal = () => controller.abort(signal?.reason);
+  if (signal?.aborted) {
+    controller.abort(signal.reason);
+  } else if (signal) {
+    signal.addEventListener("abort", abortFromSignal, { once: true });
+  }
+  const timeoutId = globalThis.setTimeout(() => {
+    controller.abort();
+  }, timeoutMs);
+  try {
+    return await fetch(input, {
+      ...rest,
+      signal: controller.signal
+    });
+  } finally {
+    globalThis.clearTimeout(timeoutId);
+    if (signal) {
+      signal.removeEventListener("abort", abortFromSignal);
+    }
+  }
+}
+
+// src/lib/transport.ts
+class DefaultSelfHostedTransport {
+  credentials = "include";
+  resolveUrl(path) {
+    return path;
+  }
+  getAuthHeaders(_path) {
+    return {};
+  }
+}
+var activeTransportResolver = () => new DefaultSelfHostedTransport;
+function setYurucommuApiTransportResolver(resolver) {
+  activeTransportResolver = resolver;
+}
+function setYurucommuApiTransport(transport) {
+  activeTransportResolver = () => transport;
+}
+function clearYurucommuApiTransport() {
+  activeTransportResolver = () => new DefaultSelfHostedTransport;
+}
+function getYurucommuApiTransport() {
+  return activeTransportResolver();
+}
+
+// src/lib/api/fetch.ts
+class ApiError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+}
+async function extractErrorMessage(res, fallback) {
+  try {
+    const data = await res.json();
+    const err = data.error;
+    const message = typeof err === "string" ? err : err?.message;
+    return message || fallback;
+  } catch {
+    return res.statusText || fallback;
+  }
+}
+async function assertOk(res, fallback) {
+  if (!res.ok) {
+    const message = await extractErrorMessage(res, fallback);
+    throw new ApiError(res.status, message);
+  }
+}
+function apiFetch(url, options = {}) {
+  const transport = getYurucommuApiTransport();
+  const apiUrl = transport.resolveUrl(url);
+  const headers = new Headers(options.headers);
+  const authHeaders = transport.getAuthHeaders(url);
+  for (const [key, value] of Object.entries(authHeaders)) {
+    if (!headers.has(key)) {
+      headers.set(key, value);
+    }
+  }
+  return fetchWithTimeout(apiUrl, {
+    ...options,
+    headers,
+    credentials: options.credentials ?? transport.credentials
+  });
+}
+function createApiMethod(method) {
+  return async (url, body, options = {}) => {
+    const headers = new Headers(options.headers);
+    if (body) {
+      headers.set("Content-Type", "application/json");
+    }
+    return await apiFetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+      ...options
+    });
+  };
+}
+var apiPost = createApiMethod("POST");
+var apiPut = createApiMethod("PUT");
+var apiPatch = createApiMethod("PATCH");
+var apiDelete = createApiMethod("DELETE");
+
+// src/lib/api/account.ts
+async function fetchAlsoKnownAs(identifier) {
+  const res = await apiFetch(`/api/actors/${encodeURIComponent(identifier)}`);
+  if (!res.ok)
+    return [];
+  const data = await res.json();
+  return Array.isArray(data.also_known_as) ? data.also_known_as.filter((a) => typeof a === "string") : [];
+}
+async function setAlsoKnownAs(aliases) {
+  const res = await apiPut("/api/actors/me", { also_known_as: aliases });
+  await assertOk(res, "Failed to update aliases");
+}
+async function moveAccount(target) {
+  const res = await apiPost("/api/actors/me/move", { target });
+  await assertOk(res, "Failed to move account");
+}
+
+// src/lib/api/auth.ts
+async function login(password) {
+  const res = await apiPost("/api/auth/login", { password });
+  return await res.json();
+}
+async function logout() {
+  await apiPost("/api/auth/logout");
+}
+async function fetchAccounts() {
+  const res = await apiFetch("/api/auth/accounts");
+  await assertOk(res, "Failed to fetch accounts");
+  return await res.json();
+}
+async function switchAccount(apId) {
+  const res = await apiPost("/api/auth/switch", { ap_id: apId });
+  await assertOk(res, "Failed to switch account");
+}
+async function createAccount(username, name) {
+  const res = await apiPost("/api/auth/accounts", { username, name });
+  await assertOk(res, "Failed to create account");
+  const data = await res.json();
+  return data.account;
+}
+
+// src/lib/api/normalize.ts
+function formatUsernameFromApId(apId, preferred) {
+  try {
+    const url = new URL(apId);
+    const match = apId.match(/\/(users|groups)\/([^/]+)$/);
+    if (match)
+      return `${match[2]}@${url.host}`;
+    if (preferred)
+      return `${preferred}@${url.host}`;
+  } catch {}
+  return null;
+}
+function normalizeActor(actor) {
+  if (!actor || !actor.ap_id)
+    return actor;
+  const rawUsername = actor.username?.trim();
+  const formatted = rawUsername || formatUsernameFromApId(actor.ap_id, actor.preferred_username) || actor.preferred_username || actor.username || actor.ap_id;
+  const preferred = actor.preferred_username?.trim() || (formatted.includes("@") ? formatted.split("@")[0] : formatted);
+  return {
+    ...actor,
+    username: formatted,
+    preferred_username: preferred
+  };
+}
+var normalizePost = (post) => ({
+  ...post,
+  author: normalizeActor(post.author)
+});
+var normalizeStory = (story) => ({
+  ...story,
+  author: normalizeActor(story.author)
+});
+var normalizeActorStories = (stories) => ({
+  ...stories,
+  actor: normalizeActor(stories.actor),
+  stories: (stories.stories || []).map(normalizeStory)
+});
+var normalizeNotification = (notification) => ({
+  ...notification,
+  actor: normalizeActor(notification.actor)
+});
+
+// src/lib/api/actors.ts
+async function fetchActor(identifier) {
+  const res = await apiFetch(`/api/actors/${encodeURIComponent(identifier)}`);
+  await assertOk(res, "Actor not found");
+  const data = await res.json();
+  return normalizeActor(data.actor);
+}
+async function updateProfile(data) {
+  const res = await apiPut("/api/actors/me", data);
+  await assertOk(res, "Failed to update profile");
+}
+async function fetchActorPosts(identifier, options) {
+  const params = new URLSearchParams;
+  if (options?.limit)
+    params.set("limit", String(options.limit));
+  if (options?.before)
+    params.set("before", options.before);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(`/api/actors/${encodeURIComponent(identifier)}/posts${query}`);
+  await assertOk(res, "Failed to fetch actor posts");
+  const data = await res.json();
+  return {
+    posts: (data.posts || []).map(normalizePost),
+    nextCursor: data.next_cursor ?? null,
+    hasMore: data.has_more ?? false
+  };
+}
+function followListQuery(options) {
+  const params = new URLSearchParams;
+  if (options?.limit)
+    params.set("limit", String(options.limit));
+  if (options?.offset)
+    params.set("offset", String(options.offset));
+  return params.toString() ? `?${params}` : "";
+}
+async function fetchFollowers(identifier, options) {
+  const res = await apiFetch(`/api/actors/${encodeURIComponent(identifier)}/followers${followListQuery(options)}`);
+  await assertOk(res, "Failed to fetch followers");
+  const data = await res.json();
+  return {
+    actors: (data.followers || []).map(normalizeActor),
+    hasMore: data.has_more ?? false,
+    total: data.total ?? 0
+  };
+}
+async function fetchFollowing(identifier, options) {
+  const res = await apiFetch(`/api/actors/${encodeURIComponent(identifier)}/following${followListQuery(options)}`);
+  await assertOk(res, "Failed to fetch following");
+  const data = await res.json();
+  return {
+    actors: (data.following || []).map(normalizeActor),
+    hasMore: data.has_more ?? false,
+    total: data.total ?? 0
+  };
+}
+async function fetchBlockedUsers() {
+  const res = await apiFetch("/api/actors/me/blocked");
+  await assertOk(res, "Failed to fetch blocked users");
+  const data = await res.json();
+  return (data.blocked || []).map(normalizeActor);
+}
+async function blockUser(apId) {
+  const res = await apiPost("/api/actors/me/blocked", { ap_id: apId });
+  await assertOk(res, "Failed to block user");
+}
+async function unblockUser(apId) {
+  const res = await apiDelete("/api/actors/me/blocked", { ap_id: apId });
+  await assertOk(res, "Failed to unblock user");
+}
+async function fetchMutedUsers() {
+  const res = await apiFetch("/api/actors/me/muted");
+  await assertOk(res, "Failed to fetch muted users");
+  const data = await res.json();
+  return (data.muted || []).map(normalizeActor);
+}
+async function muteUser(apId) {
+  const res = await apiPost("/api/actors/me/muted", { ap_id: apId });
+  await assertOk(res, "Failed to mute user");
+}
+async function unmuteUser(apId) {
+  const res = await apiDelete("/api/actors/me/muted", { ap_id: apId });
+  await assertOk(res, "Failed to unmute user");
+}
+async function deleteAccount() {
+  const res = await apiPost("/api/actors/me/delete");
+  await assertOk(res, "Failed to delete account");
+}
+
+// src/lib/api/follow.ts
+async function follow(targetApId) {
+  const res = await apiPost("/api/follow", { target_ap_id: targetApId });
+  await assertOk(res, "Failed to follow");
+  return await res.json();
+}
+async function unfollow(targetApId) {
+  const res = await apiDelete("/api/follow", { target_ap_id: targetApId });
+  await assertOk(res, "Failed to unfollow");
+}
+async function acceptFollowRequest(requesterApId) {
+  const res = await apiPost("/api/follow/accept", {
+    requester_ap_id: requesterApId
+  });
+  await assertOk(res, "Failed to accept");
+}
+async function rejectFollowRequest(requesterApId) {
+  const res = await apiPost("/api/follow/reject", {
+    requester_ap_id: requesterApId
+  });
+  await assertOk(res, "Failed to reject");
+}
+
+// src/lib/api/posts.ts
+async function fetchTimeline(options) {
+  const params = new URLSearchParams;
+  if (options?.limit)
+    params.set("limit", String(options.limit));
+  if (options?.before)
+    params.set("before", options.before);
+  if (options?.community)
+    params.set("community", options.community);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(`/api/timeline${query}`);
+  await assertOk(res, "Failed to load timeline");
+  const data = await res.json();
+  return {
+    posts: (data.posts || []).map(normalizePost),
+    nextCursor: data.next_cursor ?? null,
+    hasMore: data.has_more ?? false
+  };
+}
+async function fetchPost(apId) {
+  const res = await apiFetch(`/api/posts/${encodeURIComponent(apId)}`);
+  await assertOk(res, "Post not found");
+  const data = await res.json();
+  return normalizePost(data.post);
+}
+async function fetchReplies(postApId, options) {
+  const params = new URLSearchParams;
+  if (options?.before)
+    params.set("before", options.before);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(`/api/posts/${encodeURIComponent(postApId)}/replies${query}`);
+  const data = await res.json();
+  return {
+    replies: (data.replies || []).map(normalizePost),
+    nextCursor: data.next_cursor ?? null,
+    hasMore: data.has_more ?? false
+  };
+}
+async function createPost(data) {
+  const res = await apiPost("/api/posts", data);
+  await assertOk(res, "Failed to create post");
+  const result = await res.json();
+  return normalizePost(result.post);
+}
+async function editPost(apId, data) {
+  const res = await apiPatch(`/api/posts/${encodeURIComponent(apId)}`, data);
+  await assertOk(res, "Failed to edit post");
+  const result = await res.json();
+  return { content: result.post.content, summary: result.post.summary };
+}
+async function deletePost(apId) {
+  const res = await apiDelete(`/api/posts/${encodeURIComponent(apId)}`);
+  await assertOk(res, "Failed to delete post");
+}
+async function likePost(apId) {
+  const res = await apiPost(`/api/posts/${encodeURIComponent(apId)}/like`);
+  await assertOk(res, "Failed to like");
+}
+async function unlikePost(apId) {
+  const res = await apiDelete(`/api/posts/${encodeURIComponent(apId)}/like`);
+  await assertOk(res, "Failed to unlike");
+}
+async function repostPost(apId) {
+  const res = await apiPost(`/api/posts/${encodeURIComponent(apId)}/repost`);
+  await assertOk(res, "Failed to repost");
+}
+async function unrepostPost(apId) {
+  const res = await apiDelete(`/api/posts/${encodeURIComponent(apId)}/repost`);
+  await assertOk(res, "Failed to unrepost");
+}
+async function bookmarkPost(apId) {
+  const res = await apiPost(`/api/posts/${encodeURIComponent(apId)}/bookmark`);
+  await assertOk(res, "Failed to bookmark");
+}
+async function unbookmarkPost(apId) {
+  const res = await apiDelete(`/api/posts/${encodeURIComponent(apId)}/bookmark`);
+  await assertOk(res, "Failed to unbookmark");
+}
+async function fetchBookmarks(options) {
+  const params = new URLSearchParams;
+  if (options?.limit)
+    params.set("limit", String(options.limit));
+  if (options?.before)
+    params.set("before", options.before);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(`/api/bookmarks${query}`);
+  const data = await res.json();
+  return {
+    posts: (data.posts ?? []).map(normalizePost),
+    nextCursor: data.next_cursor ?? null,
+    hasMore: data.has_more ?? false
+  };
+}
+
+// src/lib/api/communities.ts
+var normalizeCommunityMessage = (message) => ({
+  ...message,
+  sender: normalizeActor(message.sender)
+});
+async function fetchCommunities() {
+  const res = await apiFetch("/api/communities");
+  const data = await res.json();
+  return data.communities || [];
+}
+async function fetchCommunity(identifier) {
+  const res = await apiFetch(`/api/communities/${encodeURIComponent(identifier)}`);
+  await assertOk(res, "Community not found");
+  const data = await res.json();
+  return data.community;
+}
+async function createCommunity(data) {
+  const res = await apiPost("/api/communities", data);
+  await assertOk(res, "Failed to create community");
+  const result = await res.json();
+  return result.community;
+}
+async function joinCommunity(identifier, options) {
+  const body = options?.inviteId ? { invite_id: options.inviteId } : undefined;
+  const res = await apiPost(`/api/communities/${encodeURIComponent(identifier)}/join`, body);
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new ApiError(res.status, data.error || "Failed to join community");
+  }
+  const status = data.status === "pending" || data.status === "invite_required" ? data.status : "joined";
+  return { status };
+}
+async function leaveCommunity(identifier) {
+  const res = await apiPost(`/api/communities/${encodeURIComponent(identifier)}/leave`);
+  await assertOk(res, "Failed to leave community");
+}
+async function fetchCommunityMessages(identifier, options) {
+  const params = new URLSearchParams;
+  if (options?.limit)
+    params.set("limit", String(options.limit));
+  if (options?.before)
+    params.set("before", options.before);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(`/api/communities/${encodeURIComponent(identifier)}/messages${query}`);
+  await assertOk(res, "Failed to fetch messages");
+  const data = await res.json();
+  return {
+    messages: (data.messages || []).map(normalizeCommunityMessage),
+    hasMore: data.has_more ?? false
+  };
+}
+async function sendCommunityMessage(identifier, content) {
+  const res = await apiPost(`/api/communities/${encodeURIComponent(identifier)}/messages`, { content });
+  await assertOk(res, "Failed to send message");
+  const data = await res.json();
+  return normalizeCommunityMessage(data.message);
+}
+async function fetchCommunityMembers(identifier) {
+  const res = await apiFetch(`/api/communities/${encodeURIComponent(identifier)}/members?limit=500`);
+  await assertOk(res, "Failed to fetch members");
+  const data = await res.json();
+  return (data.members || []).map(normalizeActor);
+}
+async function fetchCommunityJoinRequests(identifier) {
+  const res = await apiFetch(`/api/communities/${encodeURIComponent(identifier)}/requests`);
+  await assertOk(res, "Failed to fetch join requests");
+  const data = await res.json();
+  return (data.requests || []).map(normalizeActor);
+}
+async function acceptCommunityJoinRequest(identifier, actorApId) {
+  const res = await apiPost(`/api/communities/${encodeURIComponent(identifier)}/requests/accept`, { actor_ap_id: actorApId });
+  await assertOk(res, "Failed to accept join request");
+}
+async function rejectCommunityJoinRequest(identifier, actorApId) {
+  const res = await apiPost(`/api/communities/${encodeURIComponent(identifier)}/requests/reject`, { actor_ap_id: actorApId });
+  await assertOk(res, "Failed to reject join request");
+}
+async function fetchCommunityInvites(identifier) {
+  const res = await apiFetch(`/api/communities/${encodeURIComponent(identifier)}/invites`);
+  await assertOk(res, "Failed to fetch invites");
+  const data = await res.json();
+  return (data.invites || []).map((invite) => ({
+    ...invite,
+    invited_by: normalizeActor(invite.invited_by)
+  }));
+}
+async function createCommunityInvite(identifier, options) {
+  const res = await apiPost(`/api/communities/${encodeURIComponent(identifier)}/invites`, options);
+  await assertOk(res, "Failed to create invite");
+  return await res.json();
+}
+async function revokeCommunityInvite(identifier, inviteId) {
+  const res = await apiDelete(`/api/communities/${encodeURIComponent(identifier)}/invites/${encodeURIComponent(inviteId)}`);
+  await assertOk(res, "Failed to revoke invite");
+}
+async function updateCommunitySettings(identifier, settings) {
+  const res = await apiPatch(`/api/communities/${encodeURIComponent(identifier)}/settings`, settings);
+  await assertOk(res, "Failed to update community settings");
+}
+async function removeCommunityMember(identifier, actorApId) {
+  const res = await apiDelete(`/api/communities/${encodeURIComponent(identifier)}/members/${encodeURIComponent(actorApId)}`);
+  await assertOk(res, "Failed to remove member");
+}
+async function updateCommunityMemberRole(identifier, actorApId, role) {
+  const res = await apiPatch(`/api/communities/${encodeURIComponent(identifier)}/members/${encodeURIComponent(actorApId)}`, { role });
+  await assertOk(res, "Failed to update member role");
+}
+async function deleteCommunityMessage(identifier, messageId) {
+  const res = await apiDelete(`/api/communities/${encodeURIComponent(identifier)}/messages/${encodeURIComponent(messageId)}`);
+  await assertOk(res, "Failed to delete message");
+}
+
+// src/lib/api/dm.ts
+var normalizeDmMessage = (message) => ({
+  ...message,
+  sender: normalizeActor(message.sender)
+});
+var normalizeDmRequest = (request) => ({
+  ...request,
+  sender: normalizeActor(request.sender)
+});
+async function fetchDMContacts() {
+  const res = await apiFetch("/api/dm/contacts");
+  await assertOk(res, "Failed to load conversations");
+  const data = await res.json();
+  return {
+    mutual_followers: (data.mutual_followers || []).map(normalizeActor),
+    communities: (data.communities || []).map(normalizeActor),
+    request_count: data.request_count || 0
+  };
+}
+async function fetchDMUnreadCount() {
+  const res = await apiFetch("/api/dm/unread/count");
+  const data = await res.json();
+  return {
+    total: data.total || 0,
+    dm: data.dm || 0,
+    community: data.community || 0
+  };
+}
+async function fetchDMRequests() {
+  const res = await apiFetch("/api/dm/requests");
+  await assertOk(res, "Failed to load message requests");
+  const data = await res.json();
+  return (data.requests || []).map(normalizeDmRequest);
+}
+async function rejectDMRequest(senderApId, block) {
+  const res = await apiPost("/api/dm/requests/reject", {
+    sender_ap_id: senderApId,
+    block
+  });
+  await assertOk(res, "Failed to reject request");
+}
+async function fetchUserDMMessages(userApId, options) {
+  const params = new URLSearchParams;
+  if (options?.limit)
+    params.set("limit", String(options.limit));
+  if (options?.before)
+    params.set("before", options.before);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(`/api/dm/user/${encodeURIComponent(userApId)}/messages${query}`);
+  const data = await res.json();
+  return {
+    messages: (data.messages || []).map(normalizeDmMessage),
+    conversation_id: data.conversation_id ?? null,
+    hasMore: data.has_more ?? false
+  };
+}
+async function sendUserDMMessage(userApId, content) {
+  const res = await apiPost(`/api/dm/user/${encodeURIComponent(userApId)}/messages`, { content });
+  await assertOk(res, "Failed to send message");
+  const data = await res.json();
+  return {
+    message: normalizeDmMessage(data.message),
+    conversation_id: data.conversation_id
+  };
+}
+async function sendUserDMTyping(userApId) {
+  const res = await apiPost(`/api/dm/user/${encodeURIComponent(userApId)}/typing`);
+  await assertOk(res, "Failed to send typing");
+}
+async function fetchUserDMTyping(userApId) {
+  const res = await apiFetch(`/api/dm/user/${encodeURIComponent(userApId)}/typing`);
+  await assertOk(res, "Failed to fetch typing");
+  const data = await res.json();
+  return {
+    is_typing: !!data.is_typing,
+    last_typed_at: data.last_typed_at ?? null
+  };
+}
+async function markDMAsRead(userApId) {
+  const res = await apiPost(`/api/dm/user/${encodeURIComponent(userApId)}/read`);
+  await assertOk(res, "Failed to mark as read");
+}
+async function archiveDMConversation(userApId) {
+  const res = await apiPost(`/api/dm/user/${encodeURIComponent(userApId)}/archive`);
+  await assertOk(res, "Failed to archive conversation");
+}
+async function unarchiveDMConversation(userApId) {
+  const res = await apiDelete(`/api/dm/user/${encodeURIComponent(userApId)}/archive`);
+  await assertOk(res, "Failed to unarchive conversation");
+}
+async function fetchArchivedDMConversations() {
+  const res = await apiFetch("/api/dm/archived");
+  await assertOk(res, "Failed to load archived conversations");
+  const data = await res.json();
+  return (data.archived || []).map((c) => {
+    const a = normalizeActor(c);
+    return {
+      ...a,
+      type: "user",
+      last_message: null,
+      unread_count: 0
+    };
+  });
+}
+async function markCommunityAsRead(communityApId) {
+  const res = await apiPost(`/api/dm/community/${encodeURIComponent(communityApId)}/read`);
+  await assertOk(res, "Failed to mark as read");
+}
+async function fetchDMContact(apId) {
+  const res = await apiFetch(`/api/dm/contact/${encodeURIComponent(apId)}`);
+  if (res.status === 404)
+    return null;
+  await assertOk(res, "Failed to resolve contact");
+  const data = await res.json();
+  return data.contact ? normalizeActor(data.contact) : null;
+}
+
+// src/lib/api/notifications.ts
+async function fetchNotifications(options) {
+  const params = new URLSearchParams;
+  if (options?.limit)
+    params.set("limit", options.limit.toString());
+  if (options?.type && options.type !== "all")
+    params.set("type", options.type);
+  if (options?.before)
+    params.set("before", options.before);
+  if (options?.archived)
+    params.set("archived", "true");
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(`/api/notifications${query}`);
+  await assertOk(res, "Failed to load notifications");
+  const data = await res.json();
+  return {
+    notifications: (data.notifications || []).map(normalizeNotification),
+    hasMore: data.has_more ?? false,
+    nextCursor: data.next_cursor ?? null
+  };
+}
+async function fetchUnreadCount() {
+  const res = await apiFetch("/api/notifications/unread/count");
+  const data = await res.json();
+  return data.count || 0;
+}
+async function markNotificationsRead(ids) {
+  const res = await apiPost("/api/notifications/read", { ids });
+  await assertOk(res, "Failed to mark as read");
+}
+async function archiveNotifications(ids) {
+  const res = await apiPost("/api/notifications/archive", { ids });
+  await assertOk(res, "Failed to archive");
+}
+async function unarchiveNotifications(ids) {
+  const res = await apiDelete("/api/notifications/archive", { ids });
+  await assertOk(res, "Failed to unarchive");
+}
+async function archiveAllNotifications() {
+  const res = await apiPost("/api/notifications/archive/all", {});
+  await assertOk(res, "Failed to archive all");
+  const data = await res.json();
+  return data.archived_count ?? 0;
+}
+
+// src/lib/api/search.ts
+function pageParams(query, opts) {
+  const params = new URLSearchParams({ q: query });
+  if (opts?.sort)
+    params.set("sort", opts.sort);
+  if (opts?.offset)
+    params.set("offset", String(opts.offset));
+  if (opts?.limit)
+    params.set("limit", String(opts.limit));
+  return params.toString();
+}
+async function searchActors(query, opts) {
+  const res = await apiFetch(`/api/search/actors?${pageParams(query, opts)}`);
+  const data = await res.json();
+  return {
+    items: (data.actors || []).map(normalizeActor),
+    hasMore: data.has_more ?? false
+  };
+}
+async function searchRemote(query) {
+  const res = await apiFetch(`/api/search/remote?q=${encodeURIComponent(query)}`);
+  const data = await res.json();
+  return (data.actors || []).map(normalizeActor);
+}
+async function searchPosts(query, opts) {
+  const res = await apiFetch(`/api/search/posts?${pageParams(query, opts)}`);
+  const data = await res.json();
+  return {
+    items: (data.posts || []).map(normalizePost),
+    hasMore: data.has_more ?? false
+  };
+}
+async function searchHashtag(tag, opts) {
+  const params = new URLSearchParams;
+  if (opts?.sort)
+    params.set("sort", opts.sort);
+  if (opts?.offset)
+    params.set("offset", String(opts.offset));
+  if (opts?.limit)
+    params.set("limit", String(opts.limit));
+  const qs = params.toString();
+  const res = await apiFetch(`/api/search/hashtag/${encodeURIComponent(tag)}${qs ? `?${qs}` : ""}`);
+  const data = await res.json();
+  return {
+    items: (data.posts || []).map(normalizePost),
+    hasMore: data.has_more ?? false
+  };
+}
+async function fetchTrendingHashtags(limit = 10) {
+  const res = await apiFetch(`/api/search/hashtags/trending?limit=${limit}`);
+  const data = await res.json();
+  return data.trending || [];
+}
+
+// src/lib/api/media.ts
+var allowedMimeTypes = [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "video/mp4",
+  "video/webm"
+];
+var maxImageFileSize = 20 * 1024 * 1024;
+var maxVideoFileSize = 40 * 1024 * 1024;
+var filenameRegex = /^[\w\-. ]+$/;
+
+class FileValidationError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FileValidationError";
+  }
+}
+function validateFile(file) {
+  if (!allowedMimeTypes.includes(file.type)) {
+    throw new FileValidationError(`Invalid file type: ${file.type}. Allowed types: ${allowedMimeTypes.join(", ")}`, "INVALID_TYPE");
+  }
+  const maxFileSize = file.type.startsWith("video/") ? maxVideoFileSize : maxImageFileSize;
+  if (file.size > maxFileSize) {
+    const sizeMB = (file.size / (1024 * 1024)).toFixed(2);
+    const maxMB = maxFileSize / (1024 * 1024);
+    throw new FileValidationError(`File too large: ${sizeMB}MB. Maximum size: ${maxMB}MB`, "FILE_TOO_LARGE");
+  }
+  if (!filenameRegex.test(file.name)) {
+    throw new FileValidationError(`Invalid filename: ${file.name}. Filename can only contain letters, numbers, dots, hyphens, underscores, and spaces.`, "INVALID_FILENAME");
+  }
+}
+async function uploadMedia(file) {
+  validateFile(file);
+  const formData = new FormData;
+  formData.append("file", file);
+  const res = await apiFetch("/api/media/upload", {
+    method: "POST",
+    body: formData,
+    timeoutMs: UPLOAD_REQUEST_TIMEOUT_MS
+  });
+  await assertOk(res, "Failed to upload");
+  return res.json();
+}
+
+// src/lib/api/stories.ts
+async function fetchStories(community) {
+  const qs = community ? `?community=${encodeURIComponent(community)}` : "";
+  const res = await apiFetch(`/api/stories${qs}`);
+  await assertOk(res, "Failed to fetch stories");
+  const data = await res.json();
+  return (data.actor_stories || []).map(normalizeActorStories);
+}
+async function createStory(story) {
+  const res = await apiPost("/api/stories", story);
+  await assertOk(res, "Failed to create story");
+  const data = await res.json();
+  return normalizeStory(data.story);
+}
+async function deleteStory(apId) {
+  const res = await apiPost("/api/stories/delete", { ap_id: apId });
+  await assertOk(res, "Failed to delete story");
+}
+async function markStoryViewed(apId) {
+  const res = await apiPost("/api/stories/view", { ap_id: apId });
+  await assertOk(res, "Failed to mark story as viewed");
+}
+async function voteOnStory(apId, optionIndex) {
+  const res = await apiPost("/api/stories/vote", {
+    ap_id: apId,
+    option_index: optionIndex
+  });
+  await assertOk(res, "Failed to vote on story");
+  return await res.json();
+}
+async function likeStory(apId) {
+  const res = await apiPost(`/api/stories/${encodeURIComponent(apId)}/like`);
+  await assertOk(res, "Failed to like story");
+  return await res.json();
+}
+async function unlikeStory(apId) {
+  const res = await apiDelete(`/api/stories/${encodeURIComponent(apId)}/like`);
+  await assertOk(res, "Failed to unlike story");
+  return await res.json();
+}
+async function shareStory(apId) {
+  const res = await apiPost(`/api/stories/${encodeURIComponent(apId)}/share`);
+  await assertOk(res, "Failed to share story");
+  return await res.json();
+}
+
+// src/lib/api/recommendations.ts
+async function fetchRecommendedUsers() {
+  const res = await apiFetch("/api/recommendations/users");
+  if (!res.ok)
+    return [];
+  const data = await res.json();
+  return (data.users || []).map((u) => ({
+    ...normalizeActor(u),
+    mutual_count: u.mutual_count
+  }));
+}
+
+// src/lib/api/moderation.ts
+async function fetchBlockedDomains() {
+  const res = await apiFetch("/api/moderation/domains");
+  await assertOk(res, "Failed to fetch blocked domains");
+  const data = await res.json();
+  return data.domains || [];
+}
+async function blockDomain(domain, reason) {
+  const res = await apiPost("/api/moderation/domains", { domain, reason });
+  await assertOk(res, "Failed to block domain");
+}
+async function unblockDomain(domain) {
+  const res = await apiDelete("/api/moderation/domains", { domain });
+  await assertOk(res, "Failed to unblock domain");
+}
+async function fetchBlockedActors() {
+  const res = await apiFetch("/api/moderation/actors");
+  await assertOk(res, "Failed to fetch blocked actors");
+  const data = await res.json();
+  return data.actors || [];
+}
+async function blockActor(apId, reason) {
+  const res = await apiPost("/api/moderation/actors", { ap_id: apId, reason });
+  await assertOk(res, "Failed to block actor");
+}
+async function unblockActor(apId) {
+  const res = await apiDelete("/api/moderation/actors", { ap_id: apId });
+  await assertOk(res, "Failed to unblock actor");
+}
+async function fetchReports(options) {
+  const query = options?.onlyOpen ? "?status=open" : "";
+  const res = await apiFetch(`/api/moderation/reports${query}`);
+  await assertOk(res, "Failed to fetch reports");
+  const data = await res.json();
+  return data.reports || [];
+}
+async function resolveReport(id, reopen = false) {
+  const res = await apiPost(`/api/moderation/reports/${encodeURIComponent(id)}/resolve`, { reopen });
+  await assertOk(res, "Failed to resolve report");
+}
+async function reportContent(input) {
+  const res = await apiPost("/api/moderation/reports/outbound", {
+    target_actor_ap_id: input.targetActorApId,
+    post_ap_id: input.postApId,
+    reason: input.reason
+  });
+  await assertOk(res, "Failed to submit report");
+}
+// src/social-server.ts
+async function fetchCurrentActor() {
+  const res = await apiFetch("/api/auth/me");
+  if (res.status === 401 || res.status === 403)
+    return null;
+  await assertOk(res, "Failed to load current user");
+  const data = await res.json();
+  return data.actor ?? null;
+}
+async function fetchSocialServerDiscovery() {
+  const res = await apiFetch("/.well-known/social-server");
+  await assertOk(res, "Failed to load social server discovery");
+  return await res.json();
+}
+export {
+  voteOnStory,
+  validateFile,
+  uploadMedia,
+  updateProfile,
+  updateCommunitySettings,
+  updateCommunityMemberRole,
+  unrepostPost,
+  unmuteUser,
+  unlikeStory,
+  unlikePost,
+  unfollow,
+  unbookmarkPost,
+  unblockUser,
+  unblockDomain,
+  unblockActor,
+  unarchiveNotifications,
+  unarchiveDMConversation,
+  switchAccount,
+  shareStory,
+  setYurucommuApiTransportResolver,
+  setYurucommuApiTransport,
+  setAlsoKnownAs,
+  sendUserDMTyping,
+  sendUserDMMessage,
+  sendCommunityMessage,
+  searchRemote,
+  searchPosts,
+  searchHashtag,
+  searchActors,
+  revokeCommunityInvite,
+  resolveReport,
+  repostPost,
+  reportContent,
+  removeCommunityMember,
+  rejectFollowRequest,
+  rejectDMRequest,
+  rejectCommunityJoinRequest,
+  normalizeStory,
+  normalizePost,
+  normalizeNotification,
+  normalizeActorStories,
+  normalizeActor,
+  muteUser,
+  moveAccount,
+  maxVideoFileSize,
+  maxImageFileSize,
+  markStoryViewed,
+  markNotificationsRead,
+  markDMAsRead,
+  markCommunityAsRead,
+  logout,
+  login,
+  likeStory,
+  likePost,
+  leaveCommunity,
+  joinCommunity,
+  getYurucommuApiTransport,
+  follow,
+  fetchUserDMTyping,
+  fetchUserDMMessages,
+  fetchUnreadCount,
+  fetchTrendingHashtags,
+  fetchTimeline,
+  fetchStories,
+  fetchSocialServerDiscovery,
+  fetchReports,
+  fetchReplies,
+  fetchRecommendedUsers,
+  fetchPost,
+  fetchNotifications,
+  fetchMutedUsers,
+  fetchFollowing,
+  fetchFollowers,
+  fetchDMUnreadCount,
+  fetchDMRequests,
+  fetchDMContacts,
+  fetchDMContact,
+  fetchCurrentActor,
+  fetchCommunityMessages,
+  fetchCommunityMembers,
+  fetchCommunityJoinRequests,
+  fetchCommunityInvites,
+  fetchCommunity,
+  fetchCommunities,
+  fetchBookmarks,
+  fetchBlockedUsers,
+  fetchBlockedDomains,
+  fetchBlockedActors,
+  fetchArchivedDMConversations,
+  fetchAlsoKnownAs,
+  fetchActorPosts,
+  fetchActor,
+  fetchAccounts,
+  extractErrorMessage,
+  editPost,
+  deleteStory,
+  deletePost,
+  deleteCommunityMessage,
+  deleteAccount,
+  createStory,
+  createPost,
+  createCommunityInvite,
+  createCommunity,
+  createAccount,
+  clearYurucommuApiTransport,
+  bookmarkPost,
+  blockUser,
+  blockDomain,
+  blockActor,
+  assertOk,
+  archiveNotifications,
+  archiveDMConversation,
+  archiveAllNotifications,
+  apiPut,
+  apiPost,
+  apiPatch,
+  apiFetch,
+  apiDelete,
+  allowedMimeTypes,
+  acceptFollowRequest,
+  acceptCommunityJoinRequest,
+  FileValidationError,
+  ApiError
+};