@boldvideo/bold-js 1.17.0 → 1.19.0

package/CHANGELOG.md

@@ -1,5 +1,67 @@
 # @boldvideo/bold-js
 
+## 1.19.0
+
+### Minor Changes
+
+- d423437: Redesign Community API types to eliminate N+1 queries
+
+  **Breaking changes to Post type:**
+
+  - `viewer` → `author` (creator of the post)
+  - `reactionsCount` → `reactions.count`
+  - `commentsCount` → `comments.count`
+  - `viewerReacted` → `reactions.viewer_has_reacted`
+  - `createdAt` → `created_at`
+
+  **New types:**
+
+  - `UserSummary` - minimal profile with `id`, `name`, `avatar_url`
+  - `ReactionSummary` - `{ count, reacted_by[], viewer_has_reacted? }`
+  - `CommentSummary` - `{ count, commented_by[], items? }`
+  - `CommentThread` and `Reply` - structured comment threading
+  - `PaginationMeta` and `PaginatedResponse<T>` - page-based pagination
+
+  **Pagination changes:**
+
+  - `posts.list()` now uses `page`/`pageSize` instead of `limit`/`offset`
+  - Returns `PaginatedResponse<Post>` with `data[]` and `meta`
+
+  **Benefits:**
+
+  - List endpoint now includes `reacted_by` and `commented_by` arrays (up to 10 users)
+  - Enables avatar display without fetching each post individually
+  - Consistent object shapes between list and detail views
+
+## 1.18.0
+
+### Minor Changes
+
+- 48d8b40: Add Community API for posts, comments, and reactions
+
+  New `bold.community` namespace with full CRUD operations:
+
+  **Posts:**
+
+  - `bold.community.posts.list(opts?)` - List posts with category/limit/offset filters
+  - `bold.community.posts.get(id, viewerId?)` - Get single post with comments
+  - `bold.community.posts.create(viewerId, data)` - Create a post (markdown supported)
+  - `bold.community.posts.update(viewerId, id, data)` - Update post (owner/admin only)
+  - `bold.community.posts.delete(viewerId, id)` - Delete post (owner/admin only)
+  - `bold.community.posts.react(viewerId, id)` - Toggle reaction (like/unlike)
+
+  **Comments:**
+
+  - `bold.community.comments.create(viewerId, postId, data)` - Create comment with optional `parentId` for nested replies
+  - `bold.community.comments.delete(viewerId, id)` - Delete comment (owner/admin only)
+  - `bold.community.comments.react(viewerId, id)` - Toggle reaction
+
+  **New Types:**
+
+  - `Post`, `PostAuthor`, `Comment`, `ReactionResponse`
+  - `ListPostsOptions`, `CreatePostData`, `UpdatePostData`, `CreateCommentData`
+  - `CommunityAPIError` - Error class for Community API operations
+
 ## 1.17.0
 
 ### Minor Changes

package/README.md

@@ -178,6 +178,69 @@ console.log(`Completed ${meta.completed} of ${meta.total} videos`);
 
 ---
 
+## Community API
+
+Build community features with posts, comments, and reactions. All write operations require a `viewerId` (the viewer performing the action).
+
+### Posts
+
+```typescript
+// List posts (optionally filter by category)
+const { data: posts } = await bold.community.posts.list({ 
+  category: 'announcements',
+  limit: 20,
+  offset: 0,
+  viewerId: 'viewer-uuid'  // Include viewerReacted in response
+});
+
+// Get a single post with comments
+const { data: post } = await bold.community.posts.get('post-id', 'viewer-uuid');
+
+// Create a post (requires viewerId)
+const { data: newPost } = await bold.community.posts.create('viewer-uuid', {
+  content: 'Hello community! **Markdown** supported.',
+  category: 'general'
+});
+
+// Update a post (owner or admin only)
+await bold.community.posts.update('viewer-uuid', 'post-id', {
+  content: 'Updated content'
+});
+
+// Delete a post (owner or admin only)
+await bold.community.posts.delete('viewer-uuid', 'post-id');
+
+// React to a post (toggle like/unlike)
+const reaction = await bold.community.posts.react('viewer-uuid', 'post-id');
+console.log(reaction.reacted, reaction.reactionsCount);
+```
+
+### Comments
+
+```typescript
+// Create a comment on a post
+const { data: comment } = await bold.community.comments.create(
+  'viewer-uuid',
+  'post-id',
+  { content: 'Great post!' }
+);
+
+// Reply to a comment (nested)
+const { data: reply } = await bold.community.comments.create(
+  'viewer-uuid',
+  'post-id',
+  { content: 'I agree!', parentId: 'parent-comment-id' }
+);
+
+// Delete a comment (owner or admin only)
+await bold.community.comments.delete('viewer-uuid', 'comment-id');
+
+// React to a comment (toggle)
+const reaction = await bold.community.comments.react('viewer-uuid', 'comment-id');
+```
+
+---
+
 ## AI Methods
 
 All AI methods support both streaming (default) and non-streaming modes.
@@ -378,7 +441,16 @@ import type {
   ListProgressOptions,
   ListVideosOptions,
   ListVideosLatestOptions,
-  ListVideosIndexOptions
+  ListVideosIndexOptions,
+  // Community API
+  Post,
+  PostAuthor,
+  Comment,
+  ReactionResponse,
+  ListPostsOptions,
+  CreatePostData,
+  UpdatePostData,
+  CreateCommentData
 } from '@boldvideo/bold-js';
 ```
 

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  CommunityAPIError: () => CommunityAPIError,
   DEFAULT_API_BASE_URL: () => DEFAULT_API_BASE_URL,
   DEFAULT_INTERNAL_API_BASE_URL: () => DEFAULT_INTERNAL_API_BASE_URL,
   ViewerAPIError: () => ViewerAPIError,
@@ -38,7 +39,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/lib/client.ts
-var import_axios2 = __toESM(require("axios"), 1);
+var import_axios3 = __toESM(require("axios"), 1);
 
 // src/util/camelize.ts
 var isPlainObject = (value) => value !== null && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
@@ -330,6 +331,188 @@ function saveProgress(client) {
   };
 }
 
+// src/lib/community.ts
+var import_axios2 = require("axios");
+var CommunityAPIError = class extends Error {
+  constructor(method, url, error) {
+    var __super = (...args) => {
+      super(...args);
+    };
+    if (error instanceof import_axios2.AxiosError) {
+      const status = error.response?.status;
+      const message = error.response?.data?.error || error.message;
+      __super(`${method} ${url} failed (${status}): ${message}`);
+      this.status = status;
+      this.originalError = error;
+    } else if (error instanceof Error) {
+      __super(`${method} ${url} failed: ${error.message}`);
+      this.originalError = error;
+    } else {
+      __super(`${method} ${url} failed: ${String(error)}`);
+    }
+    this.name = "CommunityAPIError";
+  }
+};
+function requireViewerId(viewerId) {
+  if (!viewerId)
+    throw new Error("Viewer ID is required (X-Viewer-ID)");
+}
+function viewerHeaders(viewerId) {
+  return viewerId ? { "X-Viewer-ID": viewerId } : void 0;
+}
+function toQuery2(params) {
+  const qs = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null)
+      qs.set(k, String(v));
+  }
+  const s = qs.toString();
+  return s ? `?${s}` : "";
+}
+async function get3(client, url, viewerId) {
+  try {
+    const res = await client.get(url, { headers: viewerHeaders(viewerId) });
+    return camelizeKeys(res.data);
+  } catch (error) {
+    throw new CommunityAPIError("GET", url, error);
+  }
+}
+async function post2(client, url, data, viewerId) {
+  try {
+    const res = await client.post(url, data, { headers: viewerHeaders(viewerId) });
+    return camelizeKeys(res.data);
+  } catch (error) {
+    throw new CommunityAPIError("POST", url, error);
+  }
+}
+async function put(client, url, data, viewerId) {
+  try {
+    const res = await client.put(url, data, { headers: viewerHeaders(viewerId) });
+    return camelizeKeys(res.data);
+  } catch (error) {
+    throw new CommunityAPIError("PUT", url, error);
+  }
+}
+async function del(client, url, viewerId) {
+  try {
+    const res = await client.delete(url, { headers: viewerHeaders(viewerId) });
+    return camelizeKeys(res.data);
+  } catch (error) {
+    throw new CommunityAPIError("DELETE", url, error);
+  }
+}
+function listPosts(client) {
+  return async (opts = {}) => {
+    return get3(
+      client,
+      `community/posts${toQuery2({
+        category: opts.category,
+        page: opts.page,
+        page_size: opts.pageSize
+      })}`,
+      opts.viewerId
+    );
+  };
+}
+function getPost(client) {
+  return async (id, viewerId) => {
+    if (!id)
+      throw new Error("Post ID is required");
+    return get3(client, `community/posts/${id}`, viewerId);
+  };
+}
+function createPost(client) {
+  return async (viewerId, data) => {
+    requireViewerId(viewerId);
+    if (!data?.content)
+      throw new Error("Post content is required");
+    return post2(
+      client,
+      "community/posts",
+      { post: { content: data.content, category: data.category } },
+      viewerId
+    );
+  };
+}
+function updatePost(client) {
+  return async (viewerId, id, data) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Post ID is required");
+    const body = {};
+    if (data.content !== void 0)
+      body.content = data.content;
+    if (data.category !== void 0)
+      body.category = data.category;
+    return put(
+      client,
+      `community/posts/${id}`,
+      { post: body },
+      viewerId
+    );
+  };
+}
+function deletePost(client) {
+  return async (viewerId, id) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Post ID is required");
+    return del(client, `community/posts/${id}`, viewerId);
+  };
+}
+function reactToPost(client) {
+  return async (viewerId, id) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Post ID is required");
+    return post2(
+      client,
+      `community/posts/${id}/react`,
+      void 0,
+      viewerId
+    );
+  };
+}
+function createComment(client) {
+  return async (viewerId, postId, data) => {
+    requireViewerId(viewerId);
+    if (!postId)
+      throw new Error("Post ID is required");
+    if (!data?.content)
+      throw new Error("Comment content is required");
+    const body = { content: data.content };
+    if (data.parentId)
+      body.parent_id = data.parentId;
+    return post2(
+      client,
+      `community/posts/${postId}/comments`,
+      { comment: body },
+      viewerId
+    );
+  };
+}
+function deleteComment(client) {
+  return async (viewerId, id) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Comment ID is required");
+    return del(client, `community/comments/${id}`, viewerId);
+  };
+}
+function reactToComment(client) {
+  return async (viewerId, id) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Comment ID is required");
+    return post2(
+      client,
+      `community/comments/${id}/react`,
+      void 0,
+      viewerId
+    );
+  };
+}
+
 // src/util/throttle.ts
 var throttle = (fn, delay) => {
   let wait = false;
@@ -631,7 +814,7 @@ function createClient(apiKey, options = {}) {
   };
   let apiClient;
   try {
-    apiClient = import_axios2.default.create(apiClientOptions);
+    apiClient = import_axios3.default.create(apiClientOptions);
   } catch (error) {
     console.error("Error creating API client", error);
     throw error;
@@ -663,12 +846,28 @@ function createClient(apiKey, options = {}) {
       saveProgress: saveProgress(apiClient)
     },
     ai: createAI(aiConfig),
+    community: {
+      posts: {
+        list: listPosts(apiClient),
+        get: getPost(apiClient),
+        create: createPost(apiClient),
+        update: updatePost(apiClient),
+        delete: deletePost(apiClient),
+        react: reactToPost(apiClient)
+      },
+      comments: {
+        create: createComment(apiClient),
+        delete: deleteComment(apiClient),
+        react: reactToComment(apiClient)
+      }
+    },
     trackEvent: trackEvent(apiClient, userId, { debug }),
     trackPageView: trackPageView(apiClient, userId, { debug })
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CommunityAPIError,
   DEFAULT_API_BASE_URL,
   DEFAULT_INTERNAL_API_BASE_URL,
   ViewerAPIError,

package/dist/index.d.ts

@@ -511,6 +511,173 @@ type ListVideosOptions = (ListVideosLatestOptions & {
     limit?: never;
     viewerId?: never;
 });
+/**
+ * Minimal profile object for list contexts
+ */
+type UserSummary = {
+    id: string;
+    name: string;
+    avatar_url: string | null;
+};
+/**
+ * Author information for posts and comments (extended for admin context)
+ */
+type PostAuthor = UserSummary & {
+    email?: string;
+    isAdmin?: boolean;
+};
+/**
+ * Reaction summary with users who reacted
+ */
+type ReactionSummary = {
+    count: number;
+    /** Users who reacted (capped to 10 from API) */
+    reacted_by: UserSummary[];
+    /** Present when viewer context exists */
+    viewer_has_reacted?: boolean;
+};
+/**
+ * Comment summary with users who commented
+ */
+type CommentSummary = {
+    count: number;
+    /** Users who commented (capped to 10 from API) */
+    commented_by: UserSummary[];
+    /** Full comment threads (present in detail only) */
+    items?: CommentThread[];
+};
+/**
+ * A reply to a comment
+ */
+type Reply = {
+    id: string;
+    content: string;
+    created_at: string;
+    author: UserSummary;
+    parent_comment_id: string;
+};
+/**
+ * A top-level comment with replies
+ */
+type CommentThread = {
+    id: string;
+    content: string;
+    created_at: string;
+    author: UserSummary;
+    replies: Reply[];
+};
+/**
+ * @deprecated Use CommentThread instead
+ * A comment on a community post (legacy format)
+ */
+type Comment = {
+    id: string;
+    content: string;
+    /** Nesting depth (0 = top-level) */
+    depth: number;
+    reactionsCount: number;
+    /** Whether current viewer has reacted (only present when X-Viewer-ID header sent) */
+    viewerReacted?: boolean;
+    /** @deprecated Use author instead */
+    viewer: PostAuthor;
+    author: PostAuthor;
+    /** Nested replies */
+    replies: Comment[];
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * A community post (list view)
+ */
+type Post = {
+    id: string;
+    content: string;
+    category?: string;
+    pinned?: boolean;
+    pinnedAt?: string | null;
+    created_at: string;
+    author: PostAuthor;
+    reactions: ReactionSummary;
+    comments: CommentSummary;
+    /** @deprecated Use created_at */
+    createdAt?: string;
+    /** @deprecated Use reactions.count */
+    reactionsCount?: number;
+    /** @deprecated Use comments.count */
+    commentsCount?: number;
+    /** @deprecated Use reactions.viewer_has_reacted */
+    viewerReacted?: boolean;
+    /** @deprecated Use author */
+    viewer?: PostAuthor;
+    updatedAt?: string;
+};
+/**
+ * Response from react endpoints (toggle)
+ */
+type ReactionResponse = {
+    reacted: boolean;
+    reactionsCount: number;
+};
+/**
+ * Pagination metadata from API
+ */
+type PaginationMeta = {
+    /** Current page (1-indexed) */
+    page: number;
+    /** Items per page */
+    page_size: number;
+    /** Total items across all pages */
+    total_entries: number;
+    /** Total number of pages */
+    total_pages: number;
+};
+/**
+ * Paginated response wrapper
+ */
+type PaginatedResponse<T> = {
+    data: T[];
+    meta: PaginationMeta;
+};
+/**
+ * Options for listing community posts
+ */
+type ListPostsOptions = {
+    /** Filter by category (e.g., "announcements", "general") */
+    category?: string;
+    /** Page number (1-indexed, default: 1) */
+    page?: number;
+    /** Items per page (default: 20, max: 100) */
+    pageSize?: number;
+    /** Viewer ID to include viewer_has_reacted in response */
+    viewerId?: string;
+};
+/**
+ * Data for creating a community post
+ */
+type CreatePostData = {
+    /** Post content (supports markdown) */
+    content: string;
+    /** Category for the post */
+    category?: string;
+};
+/**
+ * Data for updating a community post
+ */
+type UpdatePostData = {
+    /** Post content (supports markdown) */
+    content?: string;
+    /** Category for the post */
+    category?: string;
+};
+/**
+ * Data for creating a comment
+ */
+type CreateCommentData = {
+    /** Comment content */
+    content: string;
+    /** Parent comment ID for replies */
+    parentId?: string;
+};
 
 /**
  * AI client interface for type-safe method overloading
@@ -693,6 +860,33 @@ declare function createClient(apiKey: string, options?: ClientOptions): {
         }>;
     };
     ai: AIClient;
+    community: {
+        posts: {
+            list: (opts?: ListPostsOptions) => Promise<PaginatedResponse<Post>>;
+            get: (id: string, viewerId?: string | undefined) => Promise<{
+                data: Post;
+            }>;
+            create: (viewerId: string, data: CreatePostData) => Promise<{
+                data: Post;
+            }>;
+            update: (viewerId: string, id: string, data: UpdatePostData) => Promise<{
+                data: Post;
+            }>;
+            delete: (viewerId: string, id: string) => Promise<{
+                data?: unknown;
+            }>;
+            react: (viewerId: string, id: string) => Promise<ReactionResponse>;
+        };
+        comments: {
+            create: (viewerId: string, postId: string, data: CreateCommentData) => Promise<{
+                data: Comment;
+            }>;
+            delete: (viewerId: string, id: string) => Promise<{
+                data?: unknown;
+            }>;
+            react: (viewerId: string, id: string) => Promise<ReactionResponse>;
+        };
+    };
     trackEvent: (video: any, event: Event) => void;
     trackPageView: (title: string) => void;
 };
@@ -706,4 +900,13 @@ declare const DEFAULT_API_BASE_URL = "https://app.boldvideo.io/api/v1/";
  */
 declare const DEFAULT_INTERNAL_API_BASE_URL = "https://app.boldvideo.io/i/v1/";
 
-export { AIContextMessage, AIEvent, AIResponse, AIUsage, Account, AccountAI, AnalyticsProvider, AskOptions, AssistantConfig, ChatOptions, Citation, ClientOptions, Conversation, ConversationMessage, ConversationMetadata, CreateViewerData, CustomRedirect, DEFAULT_API_BASE_URL, DEFAULT_INTERNAL_API_BASE_URL, ListProgressOptions, ListVideosIndexOptions, ListVideosLatestOptions, ListVideosOptions, MenuItem, Playlist, Portal, PortalDisplay, PortalHero, PortalLayout, PortalNavigation, PortalTheme, ProgressListMeta, RecommendOptions, RecommendResponse, Recommendation, RecommendationVideo, RecommendationsOptions, RecommendationsResponse, SaveProgressData, SearchOptions, Segment, Settings, Source, ThemeColors, ThemeConfig, UpdateViewerData, Video, VideoAttachment, VideoDownloadUrls, VideoMetadata, VideoSubtitles, VideoTranscript, Viewer, ViewerAPIError, ViewerLookupParams, ViewerProgress, createClient };
+/**
+ * Error thrown by Community API operations
+ */
+declare class CommunityAPIError extends Error {
+    readonly status?: number;
+    readonly originalError?: Error;
+    constructor(method: string, url: string, error: unknown);
+}
+
+export { AIContextMessage, AIEvent, AIResponse, AIUsage, Account, AccountAI, AnalyticsProvider, AskOptions, AssistantConfig, ChatOptions, Citation, ClientOptions, Comment, CommentSummary, CommentThread, CommunityAPIError, Conversation, ConversationMessage, ConversationMetadata, CreateCommentData, CreatePostData, CreateViewerData, CustomRedirect, DEFAULT_API_BASE_URL, DEFAULT_INTERNAL_API_BASE_URL, ListPostsOptions, ListProgressOptions, ListVideosIndexOptions, ListVideosLatestOptions, ListVideosOptions, MenuItem, PaginatedResponse, PaginationMeta, Playlist, Portal, PortalDisplay, PortalHero, PortalLayout, PortalNavigation, PortalTheme, Post, PostAuthor, ProgressListMeta, ReactionResponse, ReactionSummary, RecommendOptions, RecommendResponse, Recommendation, RecommendationVideo, RecommendationsOptions, RecommendationsResponse, Reply, SaveProgressData, SearchOptions, Segment, Settings, Source, ThemeColors, ThemeConfig, UpdatePostData, UpdateViewerData, UserSummary, Video, VideoAttachment, VideoDownloadUrls, VideoMetadata, VideoSubtitles, VideoTranscript, Viewer, ViewerAPIError, ViewerLookupParams, ViewerProgress, createClient };

package/dist/index.js

@@ -291,6 +291,188 @@ function saveProgress(client) {
   };
 }
 
+// src/lib/community.ts
+import { AxiosError as AxiosError2 } from "axios";
+var CommunityAPIError = class extends Error {
+  constructor(method, url, error) {
+    var __super = (...args) => {
+      super(...args);
+    };
+    if (error instanceof AxiosError2) {
+      const status = error.response?.status;
+      const message = error.response?.data?.error || error.message;
+      __super(`${method} ${url} failed (${status}): ${message}`);
+      this.status = status;
+      this.originalError = error;
+    } else if (error instanceof Error) {
+      __super(`${method} ${url} failed: ${error.message}`);
+      this.originalError = error;
+    } else {
+      __super(`${method} ${url} failed: ${String(error)}`);
+    }
+    this.name = "CommunityAPIError";
+  }
+};
+function requireViewerId(viewerId) {
+  if (!viewerId)
+    throw new Error("Viewer ID is required (X-Viewer-ID)");
+}
+function viewerHeaders(viewerId) {
+  return viewerId ? { "X-Viewer-ID": viewerId } : void 0;
+}
+function toQuery2(params) {
+  const qs = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null)
+      qs.set(k, String(v));
+  }
+  const s = qs.toString();
+  return s ? `?${s}` : "";
+}
+async function get3(client, url, viewerId) {
+  try {
+    const res = await client.get(url, { headers: viewerHeaders(viewerId) });
+    return camelizeKeys(res.data);
+  } catch (error) {
+    throw new CommunityAPIError("GET", url, error);
+  }
+}
+async function post2(client, url, data, viewerId) {
+  try {
+    const res = await client.post(url, data, { headers: viewerHeaders(viewerId) });
+    return camelizeKeys(res.data);
+  } catch (error) {
+    throw new CommunityAPIError("POST", url, error);
+  }
+}
+async function put(client, url, data, viewerId) {
+  try {
+    const res = await client.put(url, data, { headers: viewerHeaders(viewerId) });
+    return camelizeKeys(res.data);
+  } catch (error) {
+    throw new CommunityAPIError("PUT", url, error);
+  }
+}
+async function del(client, url, viewerId) {
+  try {
+    const res = await client.delete(url, { headers: viewerHeaders(viewerId) });
+    return camelizeKeys(res.data);
+  } catch (error) {
+    throw new CommunityAPIError("DELETE", url, error);
+  }
+}
+function listPosts(client) {
+  return async (opts = {}) => {
+    return get3(
+      client,
+      `community/posts${toQuery2({
+        category: opts.category,
+        page: opts.page,
+        page_size: opts.pageSize
+      })}`,
+      opts.viewerId
+    );
+  };
+}
+function getPost(client) {
+  return async (id, viewerId) => {
+    if (!id)
+      throw new Error("Post ID is required");
+    return get3(client, `community/posts/${id}`, viewerId);
+  };
+}
+function createPost(client) {
+  return async (viewerId, data) => {
+    requireViewerId(viewerId);
+    if (!data?.content)
+      throw new Error("Post content is required");
+    return post2(
+      client,
+      "community/posts",
+      { post: { content: data.content, category: data.category } },
+      viewerId
+    );
+  };
+}
+function updatePost(client) {
+  return async (viewerId, id, data) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Post ID is required");
+    const body = {};
+    if (data.content !== void 0)
+      body.content = data.content;
+    if (data.category !== void 0)
+      body.category = data.category;
+    return put(
+      client,
+      `community/posts/${id}`,
+      { post: body },
+      viewerId
+    );
+  };
+}
+function deletePost(client) {
+  return async (viewerId, id) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Post ID is required");
+    return del(client, `community/posts/${id}`, viewerId);
+  };
+}
+function reactToPost(client) {
+  return async (viewerId, id) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Post ID is required");
+    return post2(
+      client,
+      `community/posts/${id}/react`,
+      void 0,
+      viewerId
+    );
+  };
+}
+function createComment(client) {
+  return async (viewerId, postId, data) => {
+    requireViewerId(viewerId);
+    if (!postId)
+      throw new Error("Post ID is required");
+    if (!data?.content)
+      throw new Error("Comment content is required");
+    const body = { content: data.content };
+    if (data.parentId)
+      body.parent_id = data.parentId;
+    return post2(
+      client,
+      `community/posts/${postId}/comments`,
+      { comment: body },
+      viewerId
+    );
+  };
+}
+function deleteComment(client) {
+  return async (viewerId, id) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Comment ID is required");
+    return del(client, `community/comments/${id}`, viewerId);
+  };
+}
+function reactToComment(client) {
+  return async (viewerId, id) => {
+    requireViewerId(viewerId);
+    if (!id)
+      throw new Error("Comment ID is required");
+    return post2(
+      client,
+      `community/comments/${id}/react`,
+      void 0,
+      viewerId
+    );
+  };
+}
+
 // src/util/throttle.ts
 var throttle = (fn, delay) => {
   let wait = false;
@@ -624,11 +806,27 @@ function createClient(apiKey, options = {}) {
       saveProgress: saveProgress(apiClient)
     },
     ai: createAI(aiConfig),
+    community: {
+      posts: {
+        list: listPosts(apiClient),
+        get: getPost(apiClient),
+        create: createPost(apiClient),
+        update: updatePost(apiClient),
+        delete: deletePost(apiClient),
+        react: reactToPost(apiClient)
+      },
+      comments: {
+        create: createComment(apiClient),
+        delete: deleteComment(apiClient),
+        react: reactToComment(apiClient)
+      }
+    },
     trackEvent: trackEvent(apiClient, userId, { debug }),
     trackPageView: trackPageView(apiClient, userId, { debug })
   };
 }
 export {
+  CommunityAPIError,
   DEFAULT_API_BASE_URL,
   DEFAULT_INTERNAL_API_BASE_URL,
   ViewerAPIError,

package/llms.txt

@@ -111,6 +111,43 @@ const { data: progress, meta } = await bold.viewers.listProgress(viewer.id, { co
 console.log(`Completed ${meta.completed} of ${meta.total} videos`);
 ```
 
+## Community API
+
+Build community features with posts, comments, and reactions. Write operations require `viewerId`.
+
+### Posts
+
+- `bold.community.posts.list(opts?)` - List posts with pagination (returns `PaginatedResponse<Post>`)
+- `bold.community.posts.get(id, viewerId?)` - Get post with full comments
+- `bold.community.posts.create(viewerId, data)` - Create a post
+- `bold.community.posts.update(viewerId, id, data)` - Update post (owner/admin)
+- `bold.community.posts.delete(viewerId, id)` - Delete post (owner/admin)
+- `bold.community.posts.react(viewerId, id)` - Toggle reaction
+
+### Comments
+
+- `bold.community.comments.create(viewerId, postId, data)` - Create comment
+- `bold.community.comments.delete(viewerId, id)` - Delete comment (owner/admin)
+- `bold.community.comments.react(viewerId, id)` - Toggle reaction
+
+```typescript
+// Example: List posts with pagination
+const response = await bold.community.posts.list({ page: 1, pageSize: 20, viewerId });
+// response.data = Post[]
+// response.meta = { page, page_size, total_entries, total_pages }
+
+// Access users who reacted/commented (for avatar display)
+const post = response.data[0];
+post.reactions.reacted_by;      // UserSummary[] (up to 10)
+post.comments.commented_by;     // UserSummary[] (up to 10)
+post.reactions.viewer_has_reacted; // boolean (when viewerId provided)
+
+// Create and interact
+await bold.community.posts.create(viewerId, { content: 'Hello!', category: 'general' });
+await bold.community.posts.react(viewerId, post.id);
+await bold.community.comments.create(viewerId, post.id, { content: 'Great post!' });
+```
+
 ## AI Methods
 
 All AI methods return `AsyncIterable<AIEvent>` (streaming) or `Promise<AIResponse>` (non-streaming).
@@ -275,9 +312,94 @@ type AIEvent =
 }
 ```
 
+### UserSummary
+
+```typescript
+{
+  id: string;
+  name: string;
+  avatar_url: string | null;
+}
+```
+
+### Post
+
+```typescript
+{
+  id: string;
+  content: string;             // Markdown content
+  created_at: string;
+  author: PostAuthor;          // Creator of the post
+  reactions: ReactionSummary;  // { count, reacted_by, viewer_has_reacted? }
+  comments: CommentSummary;    // { count, commented_by, items? }
+  category?: string;
+  pinned?: boolean;
+  pinnedAt?: string | null;
+  updatedAt?: string;
+}
+```
+
+### ReactionSummary
+
+```typescript
+{
+  count: number;
+  reacted_by: UserSummary[];       // Capped to 10 from API
+  viewer_has_reacted?: boolean;    // Present when viewerId provided
+}
+```
+
+### CommentSummary
+
+```typescript
+{
+  count: number;
+  commented_by: UserSummary[];     // Capped to 10 from API
+  items?: CommentThread[];         // Full threads (detail view only)
+}
+```
+
+### CommentThread
+
+```typescript
+{
+  id: string;
+  content: string;
+  created_at: string;
+  author: UserSummary;
+  replies: Reply[];                // Nested replies
+}
+```
+
+### Reply
+
+```typescript
+{
+  id: string;
+  content: string;
+  created_at: string;
+  author: UserSummary;
+  parent_comment_id: string;
+}
+```
+
+### PaginatedResponse<T>
+
+```typescript
+{
+  data: T[];
+  meta: {
+    page: number;              // Current page (1-indexed)
+    page_size: number;
+    total_entries: number;
+    total_pages: number;
+  };
+}
+```
+
 ### Other types exported
 
-`Playlist`, `Settings`, `Portal`, `MenuItem`, `AIResponse`, `AIUsage`, `AIContextMessage`, `Conversation`, `ConversationMessage`, `RecommendationsResponse`, `Viewer`, `ViewerProgress`, `ViewerLookupParams`, `ListProgressOptions`, `ListVideosOptions`, `ListVideosLatestOptions`, `ListVideosIndexOptions`
+`Playlist`, `Settings`, `Portal`, `MenuItem`, `AIResponse`, `AIUsage`, `AIContextMessage`, `Conversation`, `ConversationMessage`, `RecommendationsResponse`, `Viewer`, `ViewerProgress`, `ViewerLookupParams`, `ListProgressOptions`, `ListVideosOptions`, `ListVideosLatestOptions`, `ListVideosIndexOptions`, `Post`, `PostAuthor`, `UserSummary`, `ReactionSummary`, `CommentSummary`, `CommentThread`, `Reply`, `Comment`, `ReactionResponse`, `ListPostsOptions`, `CreatePostData`, `UpdatePostData`, `CreateCommentData`, `PaginationMeta`, `PaginatedResponse`, `CommunityAPIError`
 
 ## Error Handling
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@boldvideo/bold-js",
   "license": "MIT",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",