convex-feedback 0.2.0-beta.8 → 0.2.0

package/src/client/index.ts

@@ -22,7 +22,11 @@ import {
 } from "convex/values";
 
 import type { ComponentApi } from "../component/_generated/component.js";
+import { stripActivityEntryContext } from "../component/helpers.js";
 import {
+  activityCommentValidator,
+  activityEntryValidator,
+  actorIsAdmin,
   adminEntryValidator,
   commentSortValidator,
   entryKindValidator,
@@ -31,13 +35,16 @@ import {
   entryStatusFilterValidator,
   entryStatusValidator,
   feedbackMetadataValidator,
+  feedbackReactionValidator,
   publicCommentValidator,
   publicEntryValidator,
   roadmapItemValidator,
   roadmapStatusValidator,
   similarEntriesValidator,
-  actorIsAdmin,
+  type EntryKind,
+  type EntryStatus,
   type FeedbackActor,
+  type FeedbackMetadata,
 } from "../component/model.js";
 import type { FeedbackPublicApi } from "./api.js";
 import {
@@ -53,16 +60,48 @@ export type {
   EntrySort,
   EntryStatus,
   EntryStatusFilter,
+  FeedbackActivityComment,
+  FeedbackActivityEntry,
+  FeedbackActivityEntryWithContext,
   FeedbackActor,
   FeedbackComment,
+  FeedbackCommentReactionTarget,
   FeedbackEntry,
+  FeedbackEntryReactionTarget,
   FeedbackMetadata,
   FeedbackMetadataValue,
+  FeedbackReaction,
   RoadmapItem,
   RoadmapStatus,
   SimilarEntriesResult,
 } from "../component/model.js";
-export type { FeedbackPublicApi } from "./api.js";
+export type {
+  AdminListEntriesArgs,
+  AdminSearchEntriesArgs,
+  CreateCommentArgs,
+  CreateEntryArgs,
+  DeleteCommentArgs,
+  DeleteEntryArgs,
+  DetachFeedbackFromRoadmapArgs,
+  FeedbackPublicApi,
+  FindSimilarEntriesArgs,
+  GetEntryArgs,
+  GetRoadmapItemArgs,
+  ListCommentsArgs,
+  ListEntriesArgs,
+  ListRoadmapArgs,
+  ListRoadmapFeedbackArgs,
+  ListUserCommentsArgs,
+  ListUserEntriesArgs,
+  ListUserReactionsArgs,
+  SearchEntriesArgs,
+  SetCommentLikeArgs,
+  SetEntryPriorityArgs,
+  SetEntryStatusArgs,
+  SetEntryUpvoteArgs,
+  UpdateCommentArgs,
+  UpdateEntryArgs,
+} from "./api.js";
 export {
   createFeedbackConfig,
   defaultFeedbackConfig,
@@ -219,6 +258,742 @@ type RateLimiterResult<
   ? Infer<ReturnsValidator>
   : void;
 
+/**
+ * Full host mutation context supplied to every lifecycle callback.
+ *
+ * This is the host mutation context for the request that triggered the
+ * callback. It includes the host database, authentication, storage,
+ * scheduler, and nested function-call helpers, so callbacks can apply host
+ * business rules or schedule follow-up work.
+ *
+ * When a callback needs to read or write feedback data, prefer a direct
+ * component reference through `ctx.runQuery(components.feedback....)` or
+ * `ctx.runMutation(components.feedback....)`. Calling an exposed host API
+ * through `api.feedback...` is also valid, but it re-enters the host wrapper
+ * and its actor/auth-resolution path. Use the host API when those host-facing
+ * semantics are specifically desired.
+ *
+ * @example Query component data from a callback
+ * ```ts
+ * import { components } from "./_generated/api";
+ *
+ * const entry = await ctx.runQuery(components.feedback.entries.get, {
+ *   entryId: event.entryId,
+ * });
+ * ```
+ */
+export type FeedbackMutationContext = GenericMutationCtx<GenericDataModel>;
+
+/**
+ * Readonly entry creation event passed after auth/rate limiting and before any
+ * component work. Return a {@link FeedbackEntryCreatePatch} to transform only
+ * the supported fields; mutating `event.input` is neither supported nor used.
+ */
+export interface FeedbackEntryBeforeCreateEvent {
+  /** Actor resolved by the host for the request being created. */
+  readonly actor: Readonly<FeedbackActor>;
+
+  /** Readonly snapshot of the caller's validated mutation input. */
+  readonly input: {
+    /** Requested entry category. */
+    readonly kind: EntryKind;
+
+    /** Title submitted by the caller, before component normalization. */
+    readonly title: string;
+
+    /** Body submitted by the caller, before component normalization. */
+    readonly body: string;
+
+    /** Optional diagnostic metadata submitted with the entry. */
+    readonly metadata?: Readonly<{
+      /** Standard metadata collected by the host or UI. */
+      standard?: Readonly<Record<string, string | number | boolean>>;
+
+      /** Additional host-defined metadata. */
+      additional?: Readonly<Record<string, string | number | boolean>>;
+    }>;
+  };
+}
+
+/**
+ * Explicit entry creation transformations. Omitted fields retain the original
+ * mutation arguments, and all returned values still undergo component
+ * validation. Actor identity, IDs, and configured defaults cannot be changed.
+ */
+export interface FeedbackEntryCreatePatch {
+  /** Replacement entry category. */
+  kind?: EntryKind;
+
+  /** Replacement title. */
+  title?: string;
+
+  /** Replacement body. */
+  body?: string;
+
+  /** Replacement diagnostic metadata. */
+  metadata?: FeedbackMetadata;
+}
+
+/**
+ * Readonly comment creation event passed after auth/rate limiting and before
+ * component work. `entryId` and `parentCommentId` are immutable relationship
+ * fields; only an explicitly returned `body` patch is applied.
+ */
+export interface FeedbackCommentBeforeCreateEvent {
+  /** Actor resolved by the host for the request being created. */
+  readonly actor: Readonly<FeedbackActor>;
+
+  /** Readonly snapshot of the caller's validated mutation input. */
+  readonly input: {
+    /** ID of the entry that will own the comment. */
+    readonly entryId: string;
+
+    /** ID of the parent comment when this input creates a reply. */
+    readonly parentCommentId?: string;
+
+    /** Comment body submitted by the caller, before normalization. */
+    readonly body: string;
+  };
+}
+
+/**
+ * Explicit comment creation transformation. Only `body` is supported and the
+ * transformed value still undergoes length and permission validation.
+ */
+export interface FeedbackCommentCreatePatch {
+  /** Replacement comment body. */
+  body?: string;
+}
+
+/**
+ * Helpers supplied to before-create callbacks. `reject(value)` is the only
+ * exception translated by callback rejection configuration: it throws a
+ * `ConvexError` by default or returns the validated value in return mode.
+ * Unexpected callback errors always propagate normally.
+ * The third callback parameter is commonly named `handlers`.
+ *
+ * @typeParam Rejection Value accepted by `reject`. In return mode this is
+ * inferred from `callbacks.rejection.returns`.
+ */
+export interface FeedbackCallbackHelpers<Rejection = Value> {
+  /**
+   * Reject the pending entry or comment creation.
+   *
+   * The call never returns: it throws in the default mode or short-circuits
+   * with the validated rejection value in return mode.
+   */
+  reject: (value: Rejection) => never;
+}
+
+type MaybePromise<ValueType> = ValueType | Promise<ValueType>;
+
+/**
+ * Runs after actor resolution and rate limiting, before the component entry
+ * mutation. It is awaited and may return an explicit creation patch or call
+ * `reject()`; it cannot replace normal component validation.
+ *
+ * @typeParam Rejection Value accepted by `handlers.reject`.
+ * @param ctx Host mutation context for the originating request. Use direct
+ * component references with `ctx.runQuery`/`ctx.runMutation` for feedback data.
+ * @param event Readonly event containing `actor` and `input` (`kind`, `title`,
+ * `body`, and optional `metadata`) for this request.
+ * @param handlers Callback handlers. Call `handlers.reject(value)` to reject
+ * creation.
+ * @returns A supported entry patch, or `undefined` to keep the original input.
+ *
+ * @example Validate and reject an entry before creation
+ * ```ts
+ * const beforeCreate: FeedbackEntryBeforeCreateCallback = (
+ *   ctx,
+ *   event,
+ *   handlers,
+ * ) => {
+ *   void ctx;
+ *   if (event.input.title.trim() === "") {
+ *     handlers.reject("An entry title is required");
+ *   }
+ * };
+ * ```
+ *
+ * @example No-op entry before-create hook
+ * ```ts
+ * const beforeCreate: FeedbackEntryBeforeCreateCallback = (
+ *   ctx,
+ *   event,
+ *   handlers,
+ * ) => {
+ *   void ctx;
+ *   void event;
+ *   void handlers;
+ * };
+ * ```
+ */
+export type FeedbackEntryBeforeCreateCallback<Rejection = Value> = (
+  ctx: FeedbackMutationContext,
+  event: FeedbackEntryBeforeCreateEvent,
+  handlers: FeedbackCallbackHelpers<Rejection>,
+) => MaybePromise<FeedbackEntryCreatePatch | undefined>;
+
+/**
+ * Sanitized persisted entry passed to `entries.afterCreate`.
+ *
+ * The entry is the authoritative component result after creation and
+ * normalization. It is available without another component query.
+ */
+export interface FeedbackEntryAfterCreateEvent {
+  /** Actor resolved by the host for the creation request. */
+  readonly actor: FeedbackActor;
+
+  /** Persisted entry created by the component. */
+  readonly entry: {
+    /** Public component identifier for the created entry. */
+    readonly id: string;
+
+    /** Stable identifier of the actor who created the entry. */
+    readonly actorId: string;
+
+    /** Persisted entry category. */
+    readonly kind: EntryKind;
+
+    /** Initial workflow status assigned by the component. */
+    readonly status: EntryStatus;
+
+    /** Normalized persisted title. */
+    readonly title: string;
+
+    /** Normalized persisted body. */
+    readonly body: string;
+
+    /** Persisted diagnostic metadata, when supplied. */
+    readonly metadata?: FeedbackMetadata;
+
+    /** Authoritative number of upvotes immediately after creation. */
+    readonly upvoteCount: number;
+
+    /** Authoritative number of comments immediately after creation. */
+    readonly commentCount: number;
+  };
+}
+
+/**
+ * Runs exactly once after successful component entry creation and is awaited
+ * in the same host mutation. An uncaught error rolls back creation. Rich entry
+ * context is requested from the component only when this callback is set.
+ *
+ * @param ctx Host mutation context for the originating request.
+ * @param event Persisted event containing `actor` and the created `entry`
+ * (`id`, `actorId`, `kind`, `status`, `title`, `body`, metadata, and counts).
+ * @returns Nothing. The callback may be synchronous or asynchronous.
+ *
+ * @example No-op entry after-create hook
+ * ```ts
+ * const afterCreate: FeedbackEntryAfterCreateCallback = async (ctx, event) => {
+ *   void ctx;
+ *   void event;
+ * };
+ * ```
+ */
+export type FeedbackEntryAfterCreateCallback = (
+  ctx: FeedbackMutationContext,
+  event: FeedbackEntryAfterCreateEvent,
+) => MaybePromise<void>;
+
+/**
+ * Runs after actor resolution and rate limiting, before the component comment
+ * mutation. It is awaited and may transform only `body` or call `reject()`.
+ *
+ * @typeParam Rejection Value accepted by `handlers.reject`.
+ * @param ctx Host mutation context for the originating request.
+ * @param event Readonly event containing `actor` and `input` (`entryId`,
+ * optional `parentCommentId`, and `body`) for this request.
+ * @param handlers Callback handlers. Call `handlers.reject(value)` to reject
+ * creation.
+ * @returns A supported comment patch, or `undefined` to keep the original
+ * input.
+ *
+ * @example No-op comment before-create hook
+ * ```ts
+ * const beforeCreate: FeedbackCommentBeforeCreateCallback = (
+ *   ctx,
+ *   event,
+ *   handlers,
+ * ) => {
+ *   void ctx;
+ *   void event;
+ *   void handlers;
+ * };
+ * ```
+ */
+export type FeedbackCommentBeforeCreateCallback<Rejection = Value> = (
+  ctx: FeedbackMutationContext,
+  event: FeedbackCommentBeforeCreateEvent,
+  handlers: FeedbackCallbackHelpers<Rejection>,
+) => MaybePromise<FeedbackCommentCreatePatch | undefined>;
+
+/**
+ * Persisted comment, entry, and optional parent context passed after creation.
+ *
+ * All IDs and content in this event come from the successful component write;
+ * the optional `parentComment` is present only when the created comment is a
+ * reply.
+ */
+export interface FeedbackCommentAfterCreateEvent {
+  /** Actor resolved by the host for the creation request. */
+  readonly actor: FeedbackActor;
+
+  /** Persisted comment created by the component. */
+  readonly comment: {
+    /** Public component identifier for the created comment. */
+    readonly id: string;
+
+    /** Stable identifier of the actor who created the comment. */
+    readonly actorId: string;
+
+    /** ID of the entry containing the comment. */
+    readonly entryId: string;
+
+    /** ID of the parent comment when this comment is a reply. */
+    readonly parentCommentId?: string;
+
+    /** Normalized persisted comment body. */
+    readonly body: string;
+
+    /** Nesting depth assigned by the component. */
+    readonly depth: number;
+  };
+
+  /** Persisted entry containing the created comment. */
+  readonly entry: {
+    /** Public component identifier for the containing entry. */
+    readonly id: string;
+
+    /** Stable identifier of the entry author. */
+    readonly actorId: string;
+
+    /** Entry category. */
+    readonly kind: EntryKind;
+
+    /** Current workflow status of the entry. */
+    readonly status: EntryStatus;
+
+    /** Entry title. */
+    readonly title: string;
+  };
+
+  /**
+   * Minimal persisted parent-comment context, present only for replies.
+   */
+  readonly parentComment?: {
+    /** Public component identifier for the parent comment. */
+    readonly id: string;
+
+    /** Stable identifier of the parent comment's author. */
+    readonly actorId: string;
+  };
+}
+
+/**
+ * Runs exactly once after successful component comment creation and is awaited
+ * in the same host mutation. An uncaught error rolls back creation. Rich
+ * comment/entry/parent context is requested only when this callback is set.
+ *
+ * @param ctx Host mutation context for the originating request.
+ * @param event Persisted event containing `actor`, `comment`, `entry`, and
+ * optional `parentComment` context returned by the component.
+ * @returns Nothing. The callback may be synchronous or asynchronous.
+ *
+ * @example React to a created comment
+ * ```ts
+ * const afterCreate: FeedbackCommentAfterCreateCallback = async (
+ *   ctx,
+ *   event,
+ * ) => {
+ *   await ctx.scheduler.runAfter(0, internal.notifications.commentCreated, {
+ *     commentId: event.comment.id,
+ *     entryId: event.entry.id,
+ *   });
+ * };
+ * ```
+ */
+export type FeedbackCommentAfterCreateCallback = (
+  ctx: FeedbackMutationContext,
+  event: FeedbackCommentAfterCreateEvent,
+) => MaybePromise<void>;
+
+interface FeedbackReactionChangeBase {
+  /** Whether the actor's reaction was added or removed. */
+  transition: "added" | "removed";
+
+  /** Whether the actor's reaction is active after the transition. */
+  active: boolean;
+
+  /** Reaction count immediately before the transition. */
+  previousCount: number;
+
+  /** Authoritative reaction count immediately after the transition. */
+  count: number;
+
+  /** Actor who requested the reaction change. */
+  actor: FeedbackActor;
+}
+
+/**
+ * Discriminated reaction transition. Events exist only for real state changes:
+ * `added` is false→true and `removed` is true→false. `previousCount` is the
+ * persisted count immediately before the change and `count` is the final one.
+ * Comment-like events intentionally use comment context without reading or
+ * serializing the parent entry. The top-level target IDs are convenience
+ * aliases for the IDs in the nested target context and always match them.
+ */
+export type FeedbackReactionChangeEvent =
+  | (FeedbackReactionChangeBase & {
+      /** Discriminator for an entry-upvote transition. */
+      type: "entry_upvote";
+      /** ID of the upvoted entry; always equal to `entry.id`. */
+      entryId: string;
+
+      /** Persisted context for the upvoted entry. */
+      entry: {
+        /** Public component identifier for the upvoted entry. */
+        id: string;
+
+        /** Stable identifier of the entry author. */
+        actorId: string;
+
+        /** Entry category. */
+        kind: EntryKind;
+
+        /** Current workflow status of the entry. */
+        status: EntryStatus;
+
+        /** Entry title. */
+        title: string;
+      };
+    })
+  | (FeedbackReactionChangeBase & {
+      /** Discriminator for a comment-like transition. */
+      type: "comment_like";
+      /** ID of the liked comment; always equal to `comment.id`. */
+      commentId: string;
+
+      /** ID of the entry containing the liked comment. */
+      entryId: string;
+
+      /** Persisted context for the liked comment. */
+      comment: {
+        /** Public component identifier for the liked comment. */
+        id: string;
+
+        /** Stable identifier of the comment author. */
+        actorId: string;
+
+        /** ID of the entry containing the comment. */
+        entryId: string;
+
+        /** ID of the parent comment when the target is a reply. */
+        parentCommentId?: string;
+
+        /** Persisted comment body. */
+        body: string;
+      };
+    });
+
+/**
+ * Runs after a successful reaction mutation only for an actual transition and
+ * is awaited in the same transaction, so uncaught errors roll back the change.
+ * Extra reaction context is requested only when this callback is configured.
+ *
+ * @param ctx Host mutation context for the originating request. For feedback
+ * reads, prefer direct component references through `ctx.runQuery` or
+ * `ctx.runMutation`.
+ * @param event The authoritative event containing `type`, `transition`,
+ * `active`, `previousCount`, `count`, `actor`, and the target IDs/context.
+ * Use `event.transition` to distinguish additions from removals and the
+ * top-level target IDs for convenient lookups.
+ * @returns Nothing. The callback may be synchronous or asynchronous.
+ *
+ * @example Handle a reaction transition and query component data
+ * ```ts
+ * import { components } from "./_generated/api";
+ *
+ * const afterChange: FeedbackReactionAfterChangeCallback = async (ctx, event) => {
+ *   if (event.transition !== "added") return;
+ *
+ *   const entry = await ctx.runQuery(components.feedback.entries.get, {
+ *     entryId: event.entryId,
+ *   });
+ *   if (entry === null) return;
+ *
+ *   const targetId =
+ *     event.type === "entry_upvote" ? event.entryId : event.commentId;
+ *   // Use `targetId` and the component result for host-side work.
+ * };
+ * ```
+ *
+ * Calling the exposed host API through `api.feedback...` is also valid, but it
+ * re-enters the host wrapper and actor/auth-resolution path. Use that route
+ * only when those host-facing semantics are desired.
+ *
+ * @example No-op reaction after-change hook
+ * ```ts
+ * const afterChange: FeedbackReactionAfterChangeCallback = async (ctx, event) => {
+ *   void ctx;
+ *   void event;
+ * };
+ * ```
+ */
+export type FeedbackReactionAfterChangeCallback = (
+  ctx: FeedbackMutationContext,
+  event: FeedbackReactionChangeEvent,
+) => MaybePromise<void>;
+
+/**
+ * Convex validator for an explicit callback rejection returned to the client.
+ *
+ * Use this with `callbacks.rejection` when a before-create callback should
+ * return a typed result instead of throwing a `ConvexError`.
+ */
+export type FeedbackCallbackReturnValidator = Validator<
+  Value,
+  "required",
+  string
+>;
+
+/**
+ * Default callback rejection mode: `handlers.reject(value)` throws a
+ * `ConvexError` and prevents the component mutation.
+ */
+export interface ThrowingFeedbackCallbackRejectionConfig {
+  /** Selects exception-based callback rejection. This is the default. */
+  behavior?: "throw";
+
+  /** Return-mode validators are not accepted in throwing mode. */
+  returns?: never;
+}
+
+/**
+ * Return mode: `handlers.reject(value)` short-circuits with a validated client
+ * result.
+ *
+ * @typeParam ReturnsValidator Validator for the value passed to `reject`.
+ */
+export interface ReturningFeedbackCallbackRejectionConfig<
+  ReturnsValidator extends FeedbackCallbackReturnValidator,
+> {
+  /** Selects validated return-mode callback rejection. */
+  behavior: "return";
+
+  /** Validator for the value returned when a callback calls `reject`. */
+  returns: ReturnsValidator;
+}
+
+/**
+ * Controls only explicit `reject()` calls from entry/comment before callbacks.
+ * Runtime/programming errors are never converted. Return-mode inference is
+ * added only to `createEntry` and `createComment`.
+ *
+ * @typeParam ReturnsValidator Validator for the value returned to the client
+ * in callback rejection return mode.
+ */
+export type FeedbackCallbackRejectionConfig<
+  ReturnsValidator extends FeedbackCallbackReturnValidator | undefined =
+    undefined,
+> = ReturnsValidator extends FeedbackCallbackReturnValidator
+  ? ReturningFeedbackCallbackRejectionConfig<ReturnsValidator>
+  : ThrowingFeedbackCallbackRejectionConfig;
+
+type CallbackRejectionValue<
+  ReturnsValidator extends FeedbackCallbackReturnValidator | undefined,
+> = ReturnsValidator extends FeedbackCallbackReturnValidator
+  ? Infer<ReturnsValidator>
+  : Value;
+
+/**
+ * Callback properties for entry creation and post-creation work.
+ *
+ * @typeParam Rejection Value accepted by `beforeCreate`'s `handlers.reject`.
+ */
+export interface FeedbackEntryCallbacks<Rejection = Value> {
+  /**
+   * Validate, reject, or transform an entry before the component creates it.
+   *
+   * The callback runs after actor resolution and rate limiting. Returned
+   * fields are still checked by the component's normal validation.
+   * It receives the host `ctx`, readonly `event` (`actor` and `input`), and
+   * `handlers` with `handlers.reject(value)`.
+   *
+   * @example
+   * ```ts
+   * beforeCreate: (ctx, event, handlers) => {},
+   * ```
+   */
+  beforeCreate?: FeedbackEntryBeforeCreateCallback<Rejection>;
+
+  /**
+   * React to an entry after the component has created it successfully.
+   *
+   * The callback is awaited in the originating host mutation; an uncaught
+   * error rolls back the entry creation.
+   * It receives the host `ctx` and persisted `event` containing the created
+   * actor and entry.
+   *
+   * @example
+   * ```ts
+   * afterCreate: async (ctx, event) => {},
+   * ```
+   */
+  afterCreate?: FeedbackEntryAfterCreateCallback;
+}
+
+/**
+ * Callback properties for comment and reply creation.
+ *
+ * @typeParam Rejection Value accepted by `beforeCreate`'s `handlers.reject`.
+ */
+export interface FeedbackCommentCallbacks<Rejection = Value> {
+  /**
+   * Validate, reject, or transform a comment body before the component
+   * creates the comment or reply.
+   * It receives the host `ctx`, readonly `event` (`actor` and `input`), and
+   * `handlers` with `handlers.reject(value)`.
+   *
+   * @example
+   * ```ts
+   * beforeCreate: (ctx, event, handlers) => {},
+   * ```
+   */
+  beforeCreate?: FeedbackCommentBeforeCreateCallback<Rejection>;
+
+  /**
+   * React to a comment or reply after the component has created it
+   * successfully.
+   *
+   * The event includes the created comment, its containing entry, and parent
+   * comment context when the created comment is a reply.
+   * The parameters are the host `ctx` and persisted `event`.
+   *
+   * @example
+   * ```ts
+   * afterCreate: async (ctx, event) => {},
+   * ```
+   */
+  afterCreate?: FeedbackCommentAfterCreateCallback;
+}
+
+/** Callback properties for entry upvotes and comment likes. */
+export interface FeedbackReactionCallbacks {
+  /**
+   * React to a real reaction transition after the component mutation.
+   *
+   * The event contains authoritative counts and direct target IDs. It also
+   * retains the nested `entry` or `comment` context for existing consumers.
+   * The parameters are the host `ctx` and transition `event`.
+   *
+   * @example
+   * ```ts
+   * afterChange: async (ctx, event) => {},
+   * ```
+   */
+  afterChange?: FeedbackReactionAfterChangeCallback;
+}
+
+/**
+ * Type of the lifecycle callback configuration accepted by
+ * `options.callbacks`.
+ *
+ * See the `entries`, `comments`, and `reactions` properties for the callback
+ * group documentation shown directly in configuration IntelliSense.
+ *
+ * @typeParam ReturnsValidator Validator that defines the value returned by
+ * `handlers.reject` when callback rejection uses return mode.
+ */
+export type FeedbackCallbacks<
+  ReturnsValidator extends FeedbackCallbackReturnValidator | undefined =
+    undefined,
+> = {
+  /**
+   * Lifecycle callbacks for entries.
+   *
+   * `beforeCreate` runs after actor resolution and rate limiting, and can
+   * validate, reject, or transform an entry before the component writes it.
+   * `afterCreate` runs after a successful component write and is awaited in
+   * the originating host mutation.
+   *
+   * @example
+   * ```ts
+   * entries: {
+   *   beforeCreate: (ctx, event, handlers) => {
+   *     const titleContainsProfanity = checkForProfanity(event.input.title);
+   *     const bodyContainsProfanity = checkForProfanity(event.input.body);
+   *
+   *     if (titleContainsProfanity || bodyContainsProfanity) {
+   *       handlers.reject({
+   *        kind: "profanity_detected",
+   *        reason: "Entry content contains profanity",
+   *      });
+   *    }
+   *   },
+   * }
+   * ```
+   */
+  entries?: FeedbackEntryCallbacks<CallbackRejectionValue<ReturnsValidator>>;
+
+  /**
+   * Lifecycle callbacks for comments and replies.
+   *
+   * `beforeCreate` can validate, reject, or transform the comment body.
+   * `afterCreate` receives the persisted comment, its containing entry, and
+   * parent-comment context when the created comment is a reply.
+   *
+   * @example
+   * ```ts
+   * comments: {
+   *   afterCreate: async (ctx, event) => {
+   *     await ctx.scheduler.runAfter(0, internal.notifications.commentCreated, {
+   *       commentId: event.comment.id,
+   *       entryId: event.entry.id,
+   *     });
+   *   },
+   * }
+   * ```
+   */
+  comments?: FeedbackCommentCallbacks<CallbackRejectionValue<ReturnsValidator>>;
+
+  /**
+   * Lifecycle callbacks for entry upvotes and comment likes.
+   *
+   * `afterChange` runs only for a real `added` or `removed` transition.
+   * Repeated requests for the current state remain idempotent and do not
+   * invoke it. Direct target IDs are available alongside nested context.
+   *
+   * @example
+   * ```ts
+   * reactions: {
+   *   afterChange: async (ctx, event) => {
+   *     if (event.transition !== "added") return;
+   *
+   *     const docId = event.type === "entry_upvote" ? event.entryId : event.commentId;
+   *     // Notify the target author using docId.
+   *   },
+   * }
+   * ```
+   */
+  reactions?: FeedbackReactionCallbacks;
+} & (ReturnsValidator extends FeedbackCallbackReturnValidator
+  ? {
+      /**
+       * Validated return-mode behavior for explicit `beforeCreate` rejects.
+       */
+      rejection: ReturningFeedbackCallbackRejectionConfig<ReturnsValidator>;
+    }
+  : {
+      /**
+       * Optional rejection behavior for explicit `beforeCreate` rejects.
+       * Defaults to throwing a `ConvexError`.
+       */
+      rejection?: ThrowingFeedbackCallbackRejectionConfig;
+    });
+
 type RegisteredFeedbackFunction<Function> =
   Function extends FunctionReference<
     "mutation",
@@ -240,11 +1015,19 @@ type RegisteredFeedbackFunction<Function> =
         : never
       : never;
 
-type ExposedFeedbackApi<RateLimitResult> = {
+type ExposedFeedbackApi<RateLimitResult, CallbackRejectionResult> = {
   [
-    FunctionName in keyof FeedbackPublicApi<string | undefined, RateLimitResult>
+    FunctionName in keyof FeedbackPublicApi<
+      string | undefined,
+      RateLimitResult,
+      CallbackRejectionResult
+    >
   ]: RegisteredFeedbackFunction<
-    FeedbackPublicApi<string | undefined, RateLimitResult>[FunctionName]
+    FeedbackPublicApi<
+      string | undefined,
+      RateLimitResult,
+      CallbackRejectionResult
+    >[FunctionName]
   >;
 };
 
@@ -266,11 +1049,82 @@ interface ExposeFeedbackOptionsBase {
   config?: FeedbackConfigOverrides;
 }
 
-/** Options for the default mode, where limiter functions reject by throwing. */
-export type ThrowingExposeFeedbackOptions = Omit<
-  ExposeFeedbackOptionsBase,
-  "config"
-> & {
+type FeedbackCallbackOptions<
+  ReturnsValidator extends FeedbackCallbackReturnValidator | undefined,
+> = ReturnsValidator extends FeedbackCallbackReturnValidator
+  ? {
+      /**
+       * Host lifecycle callbacks grouped by domain with validated return-mode
+       * rejection.
+       *
+       * Creation callbacks run in the order actor/auth → rate limiting →
+       * `beforeCreate` → component mutation → `afterCreate`. Reaction
+       * callbacks run after the component mutation only for a real transition.
+       * All callbacks are awaited in the originating host mutation.
+       *
+       * For feedback data, prefer direct component references such as
+       * `ctx.runQuery(components.feedback.entries.get, ...)`. Calling an
+       * exposed host API through `api.feedback...` is also valid, but it
+       * re-enters the host wrapper and actor/auth-resolution path; use it only
+       * when those host-facing semantics are desired.
+       *
+       * @example Configure entry validation
+       * ```ts
+       * callbacks: {
+       *   entries: {
+       *     beforeCreate: (ctx, event, handlers) => {
+       *       void ctx;
+       *       if (event.input.title.trim() === "") {
+       *         handlers.reject("A title is required");
+       *       }
+       *     },
+       *   },
+       * }
+       * ```
+       */
+      callbacks: FeedbackCallbacks<ReturnsValidator>;
+    }
+  : {
+      /**
+       * Optional host lifecycle callbacks grouped by domain. Explicit
+       * rejection throws by default.
+       *
+       * Creation callbacks run in the order actor/auth → rate limiting →
+       * `beforeCreate` → component mutation → `afterCreate`. Reaction
+       * callbacks run after the component mutation only for a real transition.
+       * All callbacks are awaited in the originating host mutation.
+       *
+       * For feedback data, prefer direct component references such as
+       * `ctx.runQuery(components.feedback.entries.get, ...)`. Calling an
+       * exposed host API through `api.feedback...` is also valid, but it
+       * re-enters the host wrapper and actor/auth-resolution path; use it only
+       * when those host-facing semantics are desired.
+       *
+       * @example Configure entry validation
+       * ```ts
+       * callbacks: {
+       *   entries: {
+       *     beforeCreate: (ctx, event, handlers) => {
+       *       void ctx;
+       *       if (event.input.title.trim() === "") {
+       *         handlers.reject("A title is required");
+       *       }
+       *     },
+       *   },
+       * }
+       * ```
+       */
+      callbacks?: FeedbackCallbacks;
+    };
+
+/**
+ * Exposure options with throwing rate limits and optional lifecycle callbacks.
+ * Callback execution/rollback semantics are documented by {@link FeedbackCallbacks}.
+ */
+export type ThrowingExposeFeedbackOptions<
+  CallbackReturnsValidator extends FeedbackCallbackReturnValidator | undefined =
+    undefined,
+> = Omit<ExposeFeedbackOptionsBase, "config"> & {
   /** Optional throwing rate limiters for the component's mutation groups. */
   rateLimiters?: FeedbackRateLimiters;
 
@@ -284,11 +1138,16 @@ export type ThrowingExposeFeedbackOptions = Omit<
      */
     rateLimiting?: FeedbackRateLimitConfig;
   };
-};
+} & FeedbackCallbackOptions<CallbackReturnsValidator>;
 
-/** Options for returning a validated rejection value instead of throwing. */
+/**
+ * Exposure options for validated rate-limit returns plus optional lifecycle
+ * callbacks and independently inferred callback-rejection behavior.
+ */
 export type ReturningExposeFeedbackOptions<
   ReturnsValidator extends FeedbackRateLimitReturnValidator,
+  CallbackReturnsValidator extends FeedbackCallbackReturnValidator | undefined =
+    undefined,
 > = Omit<ExposeFeedbackOptionsBase, "config"> & {
   /**
    * Optional returning rate limiters for the component's mutation groups.
@@ -308,21 +1167,24 @@ export type ReturningExposeFeedbackOptions<
      */
     rateLimiting: FeedbackRateLimitConfig<ReturnsValidator>;
   };
-};
+} & FeedbackCallbackOptions<CallbackReturnsValidator>;
 
 /**
  * Configuration used when exposing feedback functions from the host app.
  *
  * When `ReturnsValidator` is omitted, limiter functions use throwing behavior.
  * Supplying a validator selects return behavior and adds its inferred value to
- * the exposed mutation result types.
+ * the exposed mutation result types. `CallbackReturnsValidator` independently
+ * controls explicit before-callback rejection inference.
  */
 export type ExposeFeedbackOptions<
   ReturnsValidator extends FeedbackRateLimitReturnValidator | undefined =
     undefined,
+  CallbackReturnsValidator extends FeedbackCallbackReturnValidator | undefined =
+    undefined,
 > = ReturnsValidator extends FeedbackRateLimitReturnValidator
-  ? ReturningExposeFeedbackOptions<ReturnsValidator>
-  : ThrowingExposeFeedbackOptions;
+  ? ReturningExposeFeedbackOptions<ReturnsValidator, CallbackReturnsValidator>
+  : ThrowingExposeFeedbackOptions<CallbackReturnsValidator>;
 
 function requireActor(actor: FeedbackActor | null): FeedbackActor {
   if (actor === null) {
@@ -353,6 +1215,78 @@ function rateLimitedReturns<
   ) as RateLimitedReturnsValidator<Base, Limit>;
 }
 
+type CallbackLimitedReturnsValidator<
+  Base extends FeedbackFunctionReturnValidator,
+  Rejection extends FeedbackCallbackReturnValidator | undefined,
+> = Rejection extends FeedbackCallbackReturnValidator
+  ? VUnion<Infer<Base> | Infer<Rejection>, [Base, Rejection]>
+  : Base;
+
+function callbackLimitedReturns<
+  Base extends FeedbackFunctionReturnValidator,
+  Rejection extends FeedbackCallbackReturnValidator | undefined,
+>(
+  base: Base,
+  rejection: Rejection,
+): CallbackLimitedReturnsValidator<Base, Rejection> {
+  return (
+    rejection === undefined ? base : v.union(base, rejection)
+  ) as CallbackLimitedReturnsValidator<Base, Rejection>;
+}
+
+type CallbackResult<
+  ReturnsValidator extends FeedbackCallbackReturnValidator | undefined,
+> = ReturnsValidator extends FeedbackCallbackReturnValidator
+  ? Infer<ReturnsValidator>
+  : never;
+
+class ExplicitFeedbackCallbackRejection extends Error {
+  constructor(readonly value: Value) {
+    super("Feedback callback rejected creation.");
+    this.name = "ExplicitFeedbackCallbackRejection";
+  }
+}
+
+async function runBeforeCreate<Patch, Event, Rejection extends Value>(
+  ctx: FeedbackMutationContext,
+  event: Event,
+  callback:
+    | ((
+        ctx: FeedbackMutationContext,
+        event: Event,
+        helpers: FeedbackCallbackHelpers<Rejection>,
+      ) => MaybePromise<Patch | undefined>)
+    | undefined,
+  rejectionConfig:
+    | ThrowingFeedbackCallbackRejectionConfig
+    | ReturningFeedbackCallbackRejectionConfig<FeedbackCallbackReturnValidator>
+    | undefined,
+): Promise<
+  | { rejected: false; patch: Patch | undefined }
+  | { rejected: true; value: Rejection }
+> {
+  if (callback === undefined) {
+    return { rejected: false, patch: undefined };
+  }
+
+  try {
+    const patch = await callback(ctx, event, {
+      reject: (value) => {
+        throw new ExplicitFeedbackCallbackRejection(value);
+      },
+    });
+    return { rejected: false, patch };
+  } catch (error) {
+    if (!(error instanceof ExplicitFeedbackCallbackRejection)) {
+      throw error;
+    }
+    if (rejectionConfig?.behavior === "return") {
+      return { rejected: true, value: error.value as Rejection };
+    }
+    throw new ConvexError(error.value);
+  }
+}
+
 async function applyRateLimiter<
   ReturnsValidator extends FeedbackRateLimitReturnValidator | undefined,
 >(
@@ -386,6 +1320,10 @@ function asRateLimitContext(ctx: unknown): FeedbackRateLimitContext {
   return ctx as FeedbackRateLimitContext;
 }
 
+function asMutationContext(ctx: unknown): FeedbackMutationContext {
+  return ctx as FeedbackMutationContext;
+}
+
 function clampPositive(
   value: number | undefined,
   fallback: number,
@@ -412,13 +1350,29 @@ function actorIdFields(actor: FeedbackActor | null): {
   return actor === null ? {} : { viewerActorId: actor.id };
 }
 
+function cloneFeedbackMetadata(
+  metadata: FeedbackMetadata | undefined,
+): FeedbackMetadata | undefined {
+  if (metadata === undefined) return undefined;
+  return {
+    ...(metadata.standard === undefined
+      ? {}
+      : { standard: { ...metadata.standard } }),
+    ...(metadata.additional === undefined
+      ? {}
+      : { additional: { ...metadata.additional } }),
+  };
+}
+
 function buildFeedbackApi<
   Name extends string | undefined,
   ReturnsValidator extends FeedbackRateLimitReturnValidator | undefined =
     undefined,
+  CallbackReturnsValidator extends FeedbackCallbackReturnValidator | undefined =
+    undefined,
 >(
   component: ComponentApi<Name>,
-  options: ExposeFeedbackOptions<ReturnsValidator>,
+  options: ExposeFeedbackOptions<ReturnsValidator, CallbackReturnsValidator>,
 ) {
   const config = createFeedbackConfig(options.config);
   const rateLimitConfig = options.config?.rateLimiting;
@@ -426,8 +1380,17 @@ function buildFeedbackApi<
     rateLimitConfig?.behavior === "return"
       ? rateLimitConfig.returns
       : undefined;
+  const callbackRejectionConfig = options.callbacks?.rejection;
+  const callbackReturnValidator =
+    callbackRejectionConfig?.behavior === "return"
+      ? callbackRejectionConfig.returns
+      : undefined;
 
   const idReturns = rateLimitedReturns(v.string(), rateLimitReturnValidator);
+  const createIdReturns = callbackLimitedReturns(
+    idReturns,
+    callbackReturnValidator,
+  );
   const nullReturns = rateLimitedReturns(v.null(), rateLimitReturnValidator);
   const entryUpvoteReturns = rateLimitedReturns(
     v.object({ active: v.boolean(), upvoteCount: v.number() }),
@@ -503,6 +1466,29 @@ function buildFeedbackApi<
       },
     }),
 
+    listUserEntries: queryGeneric({
+      args: {
+        paginationOpts: paginationOptsValidator,
+      },
+      returns: paginationResultValidator(activityEntryValidator),
+      handler: async (ctx, args) => {
+        const actor = requireActor(await options.actor(ctx));
+        const result = await ctx.runQuery(component.entries.listByActor, {
+          actorId: actor.id,
+          paginationOpts: clampPagination(
+            args.paginationOpts,
+            config.entries.maxPageSize,
+          ),
+          includeAdminContext: false,
+        });
+
+        return {
+          ...result,
+          page: result.page.map(stripActivityEntryContext),
+        };
+      },
+    }),
+
     getEntry: queryGeneric({
       args: { entryId: v.string() },
       returns: v.union(publicEntryValidator, v.null()),
@@ -583,7 +1569,7 @@ function buildFeedbackApi<
         body: v.string(),
         metadata: v.optional(feedbackMetadataValidator),
       },
-      returns: idReturns,
+      returns: createIdReturns,
       handler: async (ctx, args) => {
         const actor = requireActor(await options.actor(ctx));
         const limited = await applyRateLimiter(
@@ -593,17 +1579,57 @@ function buildFeedbackApi<
           rateLimitConfig,
         );
         if (limited !== undefined) return limited;
-        return await ctx.runMutation(component.entries.create, {
+
+        const beforeCreate = options.callbacks?.entries?.beforeCreate;
+        let patch: FeedbackEntryCreatePatch | undefined;
+        if (beforeCreate !== undefined) {
+          const callbackInput: FeedbackEntryBeforeCreateEvent["input"] = {
+            kind: args.kind,
+            title: args.title,
+            body: args.body,
+            ...(args.metadata === undefined
+              ? {}
+              : { metadata: cloneFeedbackMetadata(args.metadata) }),
+          };
+          const before = await runBeforeCreate(
+            asMutationContext(ctx),
+            { actor: { ...actor }, input: callbackInput },
+            beforeCreate,
+            callbackRejectionConfig,
+          );
+          if (before.rejected) {
+            return before.value as CallbackResult<CallbackReturnsValidator>;
+          }
+          patch = before.patch;
+        }
+        const metadata =
+          patch !== undefined &&
+          Object.prototype.hasOwnProperty.call(patch, "metadata")
+            ? patch.metadata
+            : args.metadata;
+        const afterCreate = options.callbacks?.entries?.afterCreate;
+        const result = await ctx.runMutation(component.entries.create, {
           actorId: actor.id,
-          kind: args.kind,
-          title: args.title,
-          body: args.body,
+          kind: patch?.kind ?? args.kind,
+          title: patch?.title ?? args.title,
+          body: patch?.body ?? args.body,
           defaultStatus: config.entries.defaultStatus,
           enabledKinds: [...config.entries.enabledKinds],
           maxTitleLength: config.limits.titleLength,
           maxBodyLength: config.limits.bodyLength,
-          ...(args.metadata === undefined ? {} : { metadata: args.metadata }),
+          ...(metadata === undefined ? {} : { metadata }),
+          includeCallbackContext: afterCreate !== undefined,
         });
+        if (afterCreate !== undefined) {
+          if (!("entry" in result)) {
+            throw new ConvexError("Entry callback context was not returned.");
+          }
+          await afterCreate(asMutationContext(ctx), {
+            actor,
+            entry: result.entry,
+          });
+        }
+        return result.id;
       },
     }),
 
@@ -637,6 +1663,23 @@ function buildFeedbackApi<
       },
     }),
 
+    deleteEntry: mutationGeneric({
+      args: { entryId: v.string() },
+      returns: nullReturns,
+      handler: async (ctx, args) => {
+        const actor = await requireAdminActor(ctx);
+        const limited = await applyAdminEditLimit(
+          asRateLimitContext(ctx),
+          actor,
+        );
+        if (limited !== undefined) return limited;
+        return await ctx.runMutation(component.entries.remove, {
+          actor,
+          entryId: args.entryId,
+        });
+      },
+    }),
+
     setEntryStatus: mutationGeneric({
       args: { entryId: v.string(), status: entryStatusValidator },
       returns: nullReturns,
@@ -663,6 +1706,7 @@ function buildFeedbackApi<
         paginationOpts: paginationOptsValidator,
         kinds: v.optional(v.array(entryKindValidator)),
         status: v.optional(entryStatusValidator),
+        statusFilter: v.optional(entryStatusFilterValidator),
         priority: v.optional(entryPriorityValidator),
       },
       returns: paginationResultValidator(adminEntryValidator),
@@ -671,6 +1715,9 @@ function buildFeedbackApi<
         return await ctx.runQuery(component.admin.listEntries, {
           ...(args.kinds === undefined ? {} : { kinds: args.kinds }),
           ...(args.status === undefined ? {} : { status: args.status }),
+          ...(args.statusFilter === undefined
+            ? {}
+            : { statusFilter: args.statusFilter }),
           ...(args.priority === undefined ? {} : { priority: args.priority }),
           paginationOpts: clampPagination(
             args.paginationOpts,
@@ -699,6 +1746,7 @@ function buildFeedbackApi<
         searchQuery: v.string(),
         kinds: v.optional(v.array(entryKindValidator)),
         status: v.optional(entryStatusValidator),
+        statusFilter: v.optional(entryStatusFilterValidator),
         priority: v.optional(entryPriorityValidator),
       },
       returns: paginationResultValidator(adminEntryValidator),
@@ -708,6 +1756,9 @@ function buildFeedbackApi<
           searchQuery: args.searchQuery,
           ...(args.kinds === undefined ? {} : { kinds: args.kinds }),
           ...(args.status === undefined ? {} : { status: args.status }),
+          ...(args.statusFilter === undefined
+            ? {}
+            : { statusFilter: args.statusFilter }),
           ...(args.priority === undefined ? {} : { priority: args.priority }),
           paginationOpts: clampPagination(
             args.paginationOpts,
@@ -751,11 +1802,32 @@ function buildFeedbackApi<
           rateLimitConfig,
         );
         if (limited !== undefined) return limited;
-        return await ctx.runMutation(component.entries.setUpvote, {
+        const afterChange = options.callbacks?.reactions?.afterChange;
+        const result = await ctx.runMutation(component.entries.setUpvote, {
           actorId: actor.id,
           entryId: args.entryId,
           desiredState: args.desiredState,
+          includeCallbackContext: afterChange !== undefined,
         });
+        if (
+          "changed" in result &&
+          result.changed &&
+          afterChange !== undefined
+        ) {
+          await afterChange(asMutationContext(ctx), {
+            type: "entry_upvote",
+            entryId: result.entry.id,
+            transition: result.transition,
+            active: result.active,
+            previousCount: result.previousCount,
+            count: result.count,
+            actor,
+            entry: result.entry,
+          });
+        }
+        return "upvoteCount" in result
+          ? result
+          : { active: result.active, upvoteCount: result.count };
       },
     }),
 
@@ -784,13 +1856,30 @@ function buildFeedbackApi<
       },
     }),
 
+    listUserComments: queryGeneric({
+      args: {
+        paginationOpts: paginationOptsValidator,
+      },
+      returns: paginationResultValidator(activityCommentValidator),
+      handler: async (ctx, args) => {
+        const actor = requireActor(await options.actor(ctx));
+        return await ctx.runQuery(component.comments.listByActor, {
+          actorId: actor.id,
+          paginationOpts: clampPagination(
+            args.paginationOpts,
+            config.comments.maxPageSize,
+          ),
+        });
+      },
+    }),
+
     createComment: mutationGeneric({
       args: {
         entryId: v.string(),
         parentCommentId: v.optional(v.string()),
         body: v.string(),
       },
-      returns: idReturns,
+      returns: createIdReturns,
       handler: async (ctx, args) => {
         const actor = requireActor(await options.actor(ctx));
         const limited = await applyRateLimiter(
@@ -800,16 +1889,54 @@ function buildFeedbackApi<
           rateLimitConfig,
         );
         if (limited !== undefined) return limited;
-        return await ctx.runMutation(component.comments.create, {
+
+        const beforeCreate = options.callbacks?.comments?.beforeCreate;
+        let patch: FeedbackCommentCreatePatch | undefined;
+        if (beforeCreate !== undefined) {
+          const callbackInput: FeedbackCommentBeforeCreateEvent["input"] = {
+            entryId: args.entryId,
+            ...(args.parentCommentId === undefined
+              ? {}
+              : { parentCommentId: args.parentCommentId }),
+            body: args.body,
+          };
+          const before = await runBeforeCreate(
+            asMutationContext(ctx),
+            { actor: { ...actor }, input: callbackInput },
+            beforeCreate,
+            callbackRejectionConfig,
+          );
+          if (before.rejected) {
+            return before.value as CallbackResult<CallbackReturnsValidator>;
+          }
+          patch = before.patch;
+        }
+        const afterCreate = options.callbacks?.comments?.afterCreate;
+        const result = await ctx.runMutation(component.comments.create, {
           actorId: actor.id,
           entryId: args.entryId,
           ...(args.parentCommentId === undefined
             ? {}
             : { parentCommentId: args.parentCommentId }),
-          body: args.body,
+          body: patch?.body ?? args.body,
           maxDepth: config.comments.maxDepth,
           maxCommentLength: config.limits.commentLength,
+          includeCallbackContext: afterCreate !== undefined,
         });
+        if (afterCreate !== undefined) {
+          if (!("comment" in result)) {
+            throw new ConvexError("Comment callback context was not returned.");
+          }
+          await afterCreate(asMutationContext(ctx), {
+            actor,
+            comment: result.comment,
+            entry: result.entry,
+            ...(result.parentComment === undefined
+              ? {}
+              : { parentComment: result.parentComment }),
+          });
+        }
+        return result.id;
       },
     }),
 
@@ -867,10 +1994,49 @@ function buildFeedbackApi<
           rateLimitConfig,
         );
         if (limited !== undefined) return limited;
-        return await ctx.runMutation(component.comments.setLike, {
+        const afterChange = options.callbacks?.reactions?.afterChange;
+        const result = await ctx.runMutation(component.comments.setLike, {
           actorId: actor.id,
           commentId: args.commentId,
           desiredState: args.desiredState,
+          includeCallbackContext: afterChange !== undefined,
+        });
+        if (
+          "changed" in result &&
+          result.changed &&
+          afterChange !== undefined
+        ) {
+          await afterChange(asMutationContext(ctx), {
+            type: "comment_like",
+            commentId: result.comment.id,
+            entryId: result.comment.entryId,
+            transition: result.transition,
+            active: result.active,
+            previousCount: result.previousCount,
+            count: result.count,
+            actor,
+            comment: result.comment,
+          });
+        }
+        return "likeCount" in result
+          ? result
+          : { active: result.active, likeCount: result.count };
+      },
+    }),
+
+    listUserReactions: queryGeneric({
+      args: {
+        paginationOpts: paginationOptsValidator,
+      },
+      returns: paginationResultValidator(feedbackReactionValidator),
+      handler: async (ctx, args) => {
+        const actor = requireActor(await options.actor(ctx));
+        return await ctx.runQuery(component.reactions.listByActor, {
+          actorId: actor.id,
+          paginationOpts: clampPagination(
+            args.paginationOpts,
+            config.entries.maxPageSize,
+          ),
         });
       },
     }),
@@ -892,6 +2058,14 @@ function buildFeedbackApi<
       },
     }),
 
+    getRoadmapItem: queryGeneric({
+      args: { roadmapId: v.string() },
+      returns: v.union(roadmapItemValidator, v.null()),
+      handler: async (ctx, args) => {
+        return await ctx.runQuery(component.roadmap.get, args);
+      },
+    }),
+
     searchRoadmap: queryGeneric({
       args: { searchQuery: v.string(), limit: v.optional(v.number()) },
       returns: v.array(roadmapItemValidator),
@@ -1071,24 +2245,53 @@ function buildFeedbackApi<
  */
 export function exposeFeedbackApi<
   Name extends string | undefined,
-  ReturnsValidator extends FeedbackRateLimitReturnValidator,
+  RateReturnsValidator extends FeedbackRateLimitReturnValidator,
+  CallbackReturnsValidator extends FeedbackCallbackReturnValidator,
 >(
   component: ComponentApi<Name>,
-  options: ReturningExposeFeedbackOptions<ReturnsValidator>,
-): ExposedFeedbackApi<Infer<ReturnsValidator>>;
+  options: ReturningExposeFeedbackOptions<
+    RateReturnsValidator,
+    CallbackReturnsValidator
+  >,
+): ExposedFeedbackApi<
+  Infer<RateReturnsValidator>,
+  Infer<CallbackReturnsValidator>
+>;
+
+/** Exposes returning rate limits with throwing callback rejections. */
+export function exposeFeedbackApi<
+  Name extends string | undefined,
+  RateReturnsValidator extends FeedbackRateLimitReturnValidator,
+>(
+  component: ComponentApi<Name>,
+  options: ReturningExposeFeedbackOptions<RateReturnsValidator>,
+): ExposedFeedbackApi<Infer<RateReturnsValidator>, never>;
+
+/** Exposes throwing rate limits with returning callback rejections. */
+export function exposeFeedbackApi<
+  Name extends string | undefined,
+  CallbackReturnsValidator extends FeedbackCallbackReturnValidator,
+>(
+  component: ComponentApi<Name>,
+  options: ThrowingExposeFeedbackOptions<CallbackReturnsValidator>,
+): ExposedFeedbackApi<never, Infer<CallbackReturnsValidator>>;
 
 /** Exposes feedback using optional throwing rate limiters. */
 export function exposeFeedbackApi<Name extends string | undefined>(
   component: ComponentApi<Name>,
   options: ThrowingExposeFeedbackOptions,
-): ExposedFeedbackApi<never>;
+): ExposedFeedbackApi<never, never>;
 
 export function exposeFeedbackApi<
   Name extends string | undefined,
   ReturnsValidator extends FeedbackRateLimitReturnValidator | undefined,
+  CallbackReturnsValidator extends FeedbackCallbackReturnValidator | undefined,
 >(
   component: ComponentApi<Name>,
-  options: ExposeFeedbackOptions<ReturnsValidator>,
-): ExposedFeedbackApi<RateLimitResult<ReturnsValidator>> {
+  options: ExposeFeedbackOptions<ReturnsValidator, CallbackReturnsValidator>,
+): ExposedFeedbackApi<
+  RateLimitResult<ReturnsValidator>,
+  CallbackResult<CallbackReturnsValidator>
+> {
   return buildFeedbackApi(component, options);
 }