@agent-native/core 0.227.0 → 0.228.0-nightly-20261111004142

package/dist/review/actions/create-review-comment.js

@@ -4,7 +4,7 @@ import { sanitizeReviewCommentMetadata } from "../attachments.js";
 import { reviewAuthorNameFromContext } from "../identity.js";
 import { extractReviewMentions, normalizeReviewMentions } from "../mentions.js";
 import { notifyReviewComment, notifyReviewCommentWithReceipt, } from "../notifications.js";
-import { assertReviewableResourceAccess, normalizeReviewVisibility, } from "../registry.js";
+import { assertPersonReviewAnchorKind, assertReviewCommentAccess, normalizeReviewVisibility, reviewCommentPolicy, } from "../registry.js";
 import { insertReviewComment, insertReviewCommentIdempotently, reviewCommentIdForClientOperation, } from "../store.js";
 const mentionSchema = z.object({
     label: z.string().min(1),
@@ -15,6 +15,12 @@ const schema = z.object({
     resourceType: z.string().min(1),
     resourceId: z.string().min(1),
     targetId: z.string().nullable().optional(),
+    surfaceId: z
+        .string()
+        .min(1)
+        .nullable()
+        .optional()
+        .describe("The part of the resource the thread sits on, such as a slide"),
     kind: z
         .enum([
         "comment",
@@ -26,6 +32,19 @@ const schema = z.object({
     ])
         .optional(),
     anchor: z.unknown().nullable().optional(),
+    anchorKind: z
+        .string()
+        .min(1)
+        .nullable()
+        .optional()
+        .describe("The anchor's kind, when the resource declares anchor kinds"),
+    anchorVersion: z
+        .number()
+        .int()
+        .positive()
+        .nullable()
+        .optional()
+        .describe("The version the anchor was written at; defaults to the latest"),
     body: z.string().min(1),
     authorName: z.string().nullable().optional(),
     resolutionTarget: z.enum(["agent", "human"]).nullable().optional(),
@@ -47,18 +66,25 @@ export default defineAction({
     },
     run: async (args, ctx) => {
         const actionCtx = ctx;
-        const access = await assertReviewableResourceAccess(args.resourceType, args.resourceId, actionCtx, "commenter");
+        const access = await assertReviewCommentAccess(args.resourceType, args.resourceId, actionCtx);
         const mentions = normalizeReviewMentions([
             ...normalizeReviewMentions(args.mentions),
             ...extractReviewMentions(args.body),
         ]);
-        const resolutionTarget = args.resolutionTarget ?? (mentions.length > 0 ? "human" : "agent");
+        const resolutionTarget = args.resolutionTarget ??
+            (mentions.length > 0
+                ? "human"
+                : reviewCommentPolicy(args.resourceType).unmentionedRoute);
+        assertPersonReviewAnchorKind(args.anchorKind);
         const input = {
             resourceType: args.resourceType,
             resourceId: args.resourceId,
             targetId: args.targetId ?? null,
+            surfaceId: args.surfaceId ?? null,
             kind: (args.kind ?? "comment"),
             anchor: args.anchor ?? null,
+            anchorKind: args.anchorKind ?? null,
+            anchorVersion: args.anchorVersion ?? null,
             body: args.body,
             authorEmail: actionCtx?.userEmail ?? null,
             authorName: args.authorName ?? reviewAuthorNameFromContext(actionCtx),

package/dist/review/actions/delete-review-comment.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { defineAction, fail } from "../../action.js";
 import { ForbiddenError } from "../../sharing/access.js";
 import { roleSatisfies } from "../../sharing/schema.js";
-import { resolveReviewableResourceAccess } from "../registry.js";
+import { canCommentOnReviewableResource, resolveReviewableResourceAccess, } from "../registry.js";
 import { deleteReviewComment, getReviewCommentById } from "../store.js";
 import { canDeleteReviewThread } from "../thread-delete.js";
 const schema = z.object({
@@ -39,7 +39,7 @@ export default defineAction({
         const isAuthor = Boolean(actionCtx?.userEmail) &&
             normalizeEmail(comment.authorEmail) ===
                 normalizeEmail(actionCtx?.userEmail);
-        if (!access || !roleSatisfies(access.role, "commenter")) {
+        if (!access || !canCommentOnReviewableResource(args.resourceType, access)) {
             throw new ForbiddenError("Not allowed to delete this review comment");
         }
         const isEditor = roleSatisfies(access.role, "editor");

package/dist/review/actions/list-review-comments.d.ts

@@ -4,10 +4,13 @@ declare const _default: import("../../action.js").ActionDefinition<{
     includeResolved?: boolean | undefined;
     includeDeleted?: boolean | undefined;
     targetId?: string | null | undefined;
+    surfaceId?: string | null | undefined;
     newestFirst?: boolean | undefined;
     limit?: number | undefined;
+    cursor?: string | undefined;
 }, {
     comments: import("../types.js").ReviewComment[];
+    nextCursor: string | null | undefined;
     reviewStatus: import("../types.js").ReviewStatusEntry | null;
     summary: import("../store.js").ReviewThreadSummary;
     discussion: {

package/dist/review/actions/list-review-comments.js

@@ -5,8 +5,8 @@ import { isEmailDerivedName, resolveUserProfileName, } from "../../user-profile/
 import { getUserProfiles } from "../../user-profile/store.js";
 import { sanitizeReviewCommentMetadata } from "../attachments.js";
 import { redactPublicReviewCommentIdentity, redactPublicReviewStatusIdentity, shouldRedactReviewIdentity, } from "../identity.js";
-import { assertReviewableResourceAccess } from "../registry.js";
-import { getLiveReviewAuthorsByThread, getReviewStatus, getReviewDiscussionStateForComments, getReviewThreadSummary, queryReviewComments, } from "../store.js";
+import { assertReviewableResourceAccess, canCommentOnReviewableResource, } from "../registry.js";
+import { getLiveReviewAuthorsByThread, getReviewStatus, getReviewDiscussionStateForComments, getReviewThreadSummary, queryReviewCommentPage, queryReviewComments, } from "../store.js";
 import { canDeleteReviewThread } from "../thread-delete.js";
 const schema = z.object({
     resourceType: z.string().min(1),
@@ -14,8 +14,19 @@ const schema = z.object({
     includeResolved: z.boolean().optional(),
     includeDeleted: z.boolean().optional(),
     targetId: z.string().nullable().optional(),
+    surfaceId: z
+        .string()
+        .min(1)
+        .nullable()
+        .optional()
+        .describe("One surface's comments, or null for those on no surface"),
     newestFirst: z.boolean().optional(),
     limit: z.number().int().positive().max(500).optional(),
+    cursor: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("The nextCursor from the previous page; pages run oldest first only"),
 });
 export default defineAction({
     description: "List inline comments, annotations, and review threads for a resource.",
@@ -31,18 +42,28 @@ export default defineAction({
             userEmail: actionCtx?.userEmail ?? null,
             orgId: actionCtx?.orgId ?? null,
         };
-        const [rawComments, reviewStatus, summary] = await Promise.all([
-            queryReviewComments({
-                resourceType: args.resourceType,
-                resourceId: args.resourceId,
-                scope,
-                bypassScope: true,
-                includeResolved: args.includeResolved,
-                includeDeleted: args.includeDeleted,
-                targetId: args.targetId,
-                newestFirst: args.newestFirst,
-                limit: args.limit,
-            }),
+        const query = {
+            resourceType: args.resourceType,
+            resourceId: args.resourceId,
+            scope,
+            bypassScope: true,
+            includeResolved: args.includeResolved,
+            includeDeleted: args.includeDeleted,
+            targetId: args.targetId,
+            surfaceId: args.surfaceId,
+            newestFirst: args.newestFirst,
+            limit: args.limit,
+        };
+        // Newest first lists whole threads by latest activity, which no cursor
+        // can resume, so only oldest first pages; a cursor with it is refused.
+        const [page, reviewStatus, summary] = await Promise.all([
+            args.newestFirst && !args.cursor
+                ? queryReviewComments(query).then((comments) => ({
+                    comments,
+                    // Not paged, so no cursor; null would claim the list is complete.
+                    nextCursor: undefined,
+                }))
+                : queryReviewCommentPage({ ...query, cursor: args.cursor }),
             getReviewStatus(args.resourceType, args.resourceId, scope, {
                 bypassScope: true,
             }),
@@ -52,16 +73,17 @@ export default defineAction({
                 scope,
                 bypassScope: true,
                 targetId: args.targetId,
+                surfaceId: args.surfaceId,
             }),
         ]);
-        const comments = await Promise.all(rawComments.map(async (comment) => ({
+        const comments = await Promise.all(page.comments.map(async (comment) => ({
             ...comment,
             metadata: await sanitizeReviewCommentMetadata(comment.metadata),
         })));
         const discussion = {
             ...(await getReviewDiscussionStateForComments(comments, actionCtx?.userEmail ?? null)),
             canReact: Boolean(actionCtx?.userEmail) &&
-                roleSatisfies(access.role, "commenter"),
+                canCommentOnReviewableResource(args.resourceType, access),
             canSetThreadPreferences: Boolean(actionCtx?.userEmail),
         };
         const profiles = await getUserProfiles(comments.flatMap((comment) => comment.authorEmail &&
@@ -70,7 +92,7 @@ export default defineAction({
             : []));
         const redactIdentity = shouldRedactReviewIdentity(actionCtx, access);
         const isEditor = roleSatisfies(access.role, "editor");
-        const canComment = roleSatisfies(access.role, "commenter");
+        const canComment = canCommentOnReviewableResource(args.resourceType, access, Boolean(actionCtx?.userEmail));
         // Only a commenter's own threads can turn on who else wrote in them: an
         // editor may delete any, and nobody else may delete one they did not start.
         // So each first comment asked about here is the reader's own, and its
@@ -111,12 +133,14 @@ export default defineAction({
         return redactIdentity
             ? {
                 comments: commentsWithCapabilities.map(redactPublicReviewCommentIdentity),
+                nextCursor: page.nextCursor,
                 reviewStatus: redactPublicReviewStatusIdentity(reviewStatus),
                 summary,
                 discussion,
             }
             : {
                 comments: commentsWithCapabilities,
+                nextCursor: page.nextCursor,
                 reviewStatus,
                 summary,
                 discussion,

package/dist/review/actions/react-to-review-comment.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineAction, fail } from "../../action.js";
-import { assertReviewableResourceAccess } from "../registry.js";
+import { assertReviewCommentAccess } from "../registry.js";
 import { getReviewCommentById, setReviewCommentReaction } from "../store.js";
 export default defineAction({
     description: "Add or remove your reaction on a review comment.",
@@ -17,7 +17,7 @@ export default defineAction({
         openWorldHint: false,
     },
     run: async (args, ctx) => {
-        await assertReviewableResourceAccess(args.resourceType, args.resourceId, ctx, "commenter");
+        await assertReviewCommentAccess(args.resourceType, args.resourceId, ctx);
         const comment = await getReviewCommentById(args.commentId, {
             userEmail: ctx?.userEmail,
             orgId: ctx?.orgId,

package/dist/review/actions/reply-review-comment.d.ts

@@ -20,9 +20,13 @@ declare const _default: import("../../action.js").ActionDefinition<{
     threadId: string;
     parentCommentId: string | null;
     targetId: string | null;
+    surfaceId?: string | null;
     kind: import("../types.js").ReviewCommentKind;
     status: import("../types.js").ReviewCommentStatus;
     anchor: unknown;
+    anchorKind?: string | null;
+    anchorVersion?: number | null;
+    revision?: number;
     body: string;
     authorEmail: string | null;
     authorName: string | null;

package/dist/review/actions/reply-review-comment.js

@@ -4,7 +4,7 @@ import { sanitizeReviewCommentMetadata } from "../attachments.js";
 import { reviewAuthorNameFromContext } from "../identity.js";
 import { extractReviewMentions, normalizeReviewMentions } from "../mentions.js";
 import { notifyReviewComment, notifyReviewCommentWithReceipt, } from "../notifications.js";
-import { assertReviewableResourceAccess, normalizeReviewVisibility, } from "../registry.js";
+import { assertReviewCommentAccess, normalizeReviewVisibility, } from "../registry.js";
 import { getReviewCommentById, getReviewThreadRoot, insertReviewReply, insertReviewReplyIdempotently, ReviewCommentDeletedError, ReviewThreadNotFoundError, ReviewThreadNotOpenError, reviewCommentIdForClientOperation, } from "../store.js";
 const mentionSchema = z.object({
     label: z.string().min(1),
@@ -40,7 +40,7 @@ export default defineAction({
             userEmail: actionCtx?.userEmail ?? null,
             orgId: actionCtx?.orgId ?? null,
         };
-        const access = await assertReviewableResourceAccess(args.resourceType, args.resourceId, actionCtx, "commenter");
+        const access = await assertReviewCommentAccess(args.resourceType, args.resourceId, actionCtx);
         const clientOperationCommentId = args.clientOperationId
             ? reviewCommentIdForClientOperation(args.clientOperationId)
             : null;
@@ -87,13 +87,22 @@ export default defineAction({
             threadId: parent.threadId,
             parentCommentId: parent.id,
             targetId: parent.targetId,
+            surfaceId: parent.surfaceId,
             kind: parent.kind,
             // A retry rebuilds the reply from its parent, whose anchor may have moved
             // since, or been cleared when the parent was deleted. The saved reply
-            // keeps the anchor it was sent with.
-            anchor: existingReply?.parentCommentId === parent.id
-                ? existingReply.anchor
-                : parent.anchor,
+            // keeps the anchor it was sent with, and its kind and version with it.
+            ...(existingReply?.parentCommentId === parent.id
+                ? {
+                    anchor: existingReply.anchor,
+                    anchorKind: existingReply.anchorKind,
+                    anchorVersion: existingReply.anchorVersion,
+                }
+                : {
+                    anchor: parent.anchor,
+                    anchorKind: parent.anchorKind,
+                    anchorVersion: parent.anchorVersion,
+                }),
             body: args.body,
             authorEmail: actionCtx?.userEmail ?? null,
             authorName: args.authorName ?? reviewAuthorNameFromContext(actionCtx),

package/dist/review/actions/update-review-comment-anchor.d.ts

@@ -3,9 +3,15 @@ declare const _default: import("../../action.js").ActionDefinition<{
     resourceId: string;
     commentId: string;
     anchor: unknown;
+    anchorKind?: string | null | undefined;
+    anchorVersion?: number | null | undefined;
+    expectedRevision?: number | undefined;
 }, {
     commentId: string;
     anchor: unknown;
+    anchorKind: string | null | undefined;
+    anchorVersion: number | null | undefined;
+    revision: number | undefined;
     updatedCount: number;
 }>;
 export default _default;

package/dist/review/actions/update-review-comment-anchor.js

@@ -2,13 +2,26 @@ import { z } from "zod";
 import { defineAction, fail } from "../../action.js";
 import { ForbiddenError } from "../../sharing/access.js";
 import { roleSatisfies } from "../../sharing/schema.js";
-import { resolveReviewableResourceAccess } from "../registry.js";
-import { getReviewCommentById, updateReviewCommentAnchor } from "../store.js";
+import { assertPersonReviewAnchorKind, canCommentOnReviewableResource, resolveReviewableResourceAccess, } from "../registry.js";
+import { getReviewCommentById, updateReviewComment } from "../store.js";
 const schema = z.object({
     resourceType: z.string().min(1),
     resourceId: z.string().min(1),
     commentId: z.string().min(1),
     anchor: z.unknown().nullable(),
+    anchorKind: z
+        .string()
+        .min(1)
+        .nullable()
+        .optional()
+        .describe("A new kind for the anchor; left out, the comment's kind stays"),
+    anchorVersion: z.number().int().positive().nullable().optional(),
+    expectedRevision: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("The comment's revision when read; a newer one refuses the move with revision_conflict"),
 });
 export default defineAction({
     description: "Move an anchored review comment to a new canvas position.",
@@ -42,25 +55,41 @@ export default defineAction({
             });
         }
         const isAuthor = comment.authorEmail?.trim().toLowerCase() === userEmail;
-        if (!access || !roleSatisfies(access.role, "commenter")) {
+        if (!access || !canCommentOnReviewableResource(args.resourceType, access)) {
             throw new ForbiddenError("Not allowed to move this review comment");
         }
         if (!isAuthor && !roleSatisfies(access.role, "editor")) {
             throw new ForbiddenError("Not allowed to move this review comment");
         }
-        const updatedCount = await updateReviewCommentAnchor({
-            commentId: comment.id,
-            resourceType: args.resourceType,
-            resourceId: args.resourceId,
+        // The kind the moved anchor ends up with, worked out as the store does.
+        assertPersonReviewAnchorKind(args.anchorKind !== undefined
+            ? args.anchorKind
+            : args.anchor === null
+                ? null
+                : comment.anchorKind);
+        const moved = await updateReviewComment(comment.id, {
             anchor: args.anchor,
-        });
-        if (updatedCount < 1) {
+            ...(args.anchorKind !== undefined
+                ? { anchorKind: args.anchorKind }
+                : {}),
+            ...(args.anchorVersion !== undefined
+                ? { anchorVersion: args.anchorVersion }
+                : {}),
+        }, { resourceType: args.resourceType, resourceId: args.resourceId }, { expectedRevision: args.expectedRevision, actorEmail: userEmail });
+        if (!moved) {
             fail("Review comment could not be moved", {
                 statusCode: 404,
                 errorCode: "not_found",
             });
         }
-        return { commentId: comment.id, anchor: args.anchor, updatedCount };
+        return {
+            commentId: moved.id,
+            anchor: moved.anchor,
+            anchorKind: moved.anchorKind,
+            anchorVersion: moved.anchorVersion,
+            revision: moved.revision,
+            updatedCount: 1,
+        };
     },
     audit: {
         target: (args) => ({

package/dist/review/actions/update-review-comment.d.ts

@@ -4,10 +4,13 @@ declare const _default: import("../../action.js").ActionDefinition<{
     commentId: string;
     body?: string | undefined;
     anchor?: unknown;
+    anchorKind?: string | null | undefined;
+    anchorVersion?: number | null | undefined;
     mentions?: {
         label: string;
         email?: string | null | undefined;
         id?: string | null | undefined;
     }[] | undefined;
+    expectedRevision?: number | undefined;
 }, import("../types.js").ReviewComment>;
 export default _default;

package/dist/review/actions/update-review-comment.js

@@ -3,7 +3,7 @@ import { defineAction } from "../../action.js";
 import { ForbiddenError } from "../../sharing/access.js";
 import { roleSatisfies } from "../../sharing/schema.js";
 import { extractReviewMentions, normalizeReviewMentions } from "../mentions.js";
-import { resolveReviewableResourceAccess } from "../registry.js";
+import { assertPersonReviewAnchorKind, canCommentOnReviewableResource, resolveReviewableResourceAccess, } from "../registry.js";
 import { getReviewCommentById, updateReviewComment } from "../store.js";
 const mentionSchema = z.object({
     label: z.string().min(1),
@@ -17,7 +17,15 @@ const schema = z
     commentId: z.string().min(1),
     body: z.string().min(1).optional(),
     anchor: z.unknown().optional(),
+    anchorKind: z.string().min(1).nullable().optional(),
+    anchorVersion: z.number().int().positive().nullable().optional(),
     mentions: z.array(mentionSchema).optional(),
+    expectedRevision: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("The comment's revision when read; a newer one refuses the edit with revision_conflict"),
 })
     .refine((args) => args.body !== undefined || args.anchor !== undefined, {
     message: "Provide a body or anchor to update",
@@ -50,12 +58,20 @@ export default defineAction({
                 normalizeEmail(actionCtx?.userEmail);
         const changesContent = args.body !== undefined || args.mentions !== undefined;
         if (!access ||
-            !roleSatisfies(access.role, "commenter") ||
+            !canCommentOnReviewableResource(args.resourceType, access) ||
             (changesContent
                 ? !isAuthor
                 : !isAuthor && !roleSatisfies(access.role, "editor"))) {
             throw new ForbiddenError("Not allowed to update this review comment");
         }
+        if (args.anchor !== undefined) {
+            // The kind the moved anchor ends up with, worked out as the store does.
+            assertPersonReviewAnchorKind(args.anchorKind !== undefined
+                ? args.anchorKind
+                : args.anchor === null
+                    ? null
+                    : comment.anchorKind);
+        }
         const mentions = args.body === undefined
             ? undefined
             : normalizeReviewMentions([
@@ -65,8 +81,17 @@ export default defineAction({
         const updated = await updateReviewComment(args.commentId, {
             ...(args.body !== undefined ? { body: args.body } : {}),
             ...(args.anchor !== undefined ? { anchor: args.anchor } : {}),
+            ...(args.anchor !== undefined && args.anchorKind !== undefined
+                ? { anchorKind: args.anchorKind }
+                : {}),
+            ...(args.anchor !== undefined && args.anchorVersion !== undefined
+                ? { anchorVersion: args.anchorVersion }
+                : {}),
             ...(mentions !== undefined ? { mentions } : {}),
-        }, { resourceType: args.resourceType, resourceId: args.resourceId });
+        }, { resourceType: args.resourceType, resourceId: args.resourceId }, {
+            expectedRevision: args.expectedRevision,
+            actorEmail: actionCtx?.userEmail ?? null,
+        });
         if (!updated)
             throw new Error("Review comment not found");
         return updated;

package/dist/review/errors.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Refusals from the kit's storage. Each carries the shape an action reports as
+ * its failure (`isActionContractError`), so a store error reaches the caller
+ * with its status and code without the store importing the action runtime.
+ */
+declare class ReviewStorageError extends Error {
+    readonly actionContractError = true;
+    readonly errorCode: string;
+    readonly statusCode: number;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, errorCode: string, statusCode: number, details?: Record<string, unknown>);
+}
+/** An anchor its resource's anchor kind refused, or one with no kind to check it. */
+export declare class ReviewAnchorError extends ReviewStorageError {
+    constructor(message: string);
+}
+/** The comment changed after the caller read it; nothing was written. */
+export declare class ReviewCommentRevisionConflictError extends ReviewStorageError {
+    readonly currentRevision: number;
+    constructor(commentId: string, currentRevision: number);
+}
+/** An outside ID already linked to another comment. */
+export declare class ReviewCommentLinkConflictError extends ReviewStorageError {
+    constructor(provider: string, externalKind: string, externalId: string);
+}
+/**
+ * A list cursor this kit didn't hand out, one from another list, or one used
+ * with another order.
+ */
+export declare class ReviewCursorError extends ReviewStorageError {
+    constructor(message: string);
+}
+export {};

package/dist/review/errors.js

@@ -0,0 +1,51 @@
+/**
+ * Refusals from the kit's storage. Each carries the shape an action reports as
+ * its failure (`isActionContractError`), so a store error reaches the caller
+ * with its status and code without the store importing the action runtime.
+ */
+class ReviewStorageError extends Error {
+    actionContractError = true;
+    errorCode;
+    statusCode;
+    details;
+    constructor(message, errorCode, statusCode, details) {
+        super(message);
+        this.errorCode = errorCode;
+        this.statusCode = statusCode;
+        if (details)
+            this.details = details;
+    }
+}
+/** An anchor its resource's anchor kind refused, or one with no kind to check it. */
+export class ReviewAnchorError extends ReviewStorageError {
+    constructor(message) {
+        super(message, "invalid_anchor", 400);
+        this.name = "ReviewAnchorError";
+    }
+}
+/** The comment changed after the caller read it; nothing was written. */
+export class ReviewCommentRevisionConflictError extends ReviewStorageError {
+    currentRevision;
+    constructor(commentId, currentRevision) {
+        super(`Comment ${commentId} changed since it was read; read it again and retry.`, "revision_conflict", 409, { commentId, currentRevision });
+        this.name = "ReviewCommentRevisionConflictError";
+        this.currentRevision = currentRevision;
+    }
+}
+/** An outside ID already linked to another comment. */
+export class ReviewCommentLinkConflictError extends ReviewStorageError {
+    constructor(provider, externalKind, externalId) {
+        super(`The ${provider} ${externalKind} ${externalId} is already linked to another comment.`, "link_conflict", 409, { provider, externalKind, externalId });
+        this.name = "ReviewCommentLinkConflictError";
+    }
+}
+/**
+ * A list cursor this kit didn't hand out, one from another list, or one used
+ * with another order.
+ */
+export class ReviewCursorError extends ReviewStorageError {
+    constructor(message) {
+        super(message, "invalid_cursor", 400);
+        this.name = "ReviewCursorError";
+    }
+}

package/dist/review/index.d.ts

@@ -1,11 +1,12 @@
-export type { ReviewActorKind, ReviewComment, ReviewCommentKind, ReviewCommentStatus, ReviewCommentReaction, ReviewThreadPreference, ReviewDiscussionState, ReviewMention, ReviewResolutionTarget, ReviewResourceAccess, ReviewResourceContext, ReviewResourceRole, ReviewScope, ReviewStatus, ReviewStatusEntry, ReviewableResourceRegistration, } from "./types.js";
+export type { ReviewActorKind, ReviewAnchorKind, ReviewComment, ReviewCommentKind, ReviewCommentLink, ReviewCommentPolicy, ReviewCommentStatus, ReviewCommentWriteEvent, ReviewCommentReaction, ReviewThreadPreference, ReviewDiscussionState, ReviewMention, ReviewResolutionTarget, ReviewResourceAccess, ReviewResourceContext, ReviewResourceRole, ReviewScope, ReviewStatus, ReviewStatusEntry, ReviewableResourceRegistration, } from "./types.js";
+export { ReviewAnchorError, ReviewCommentLinkConflictError, ReviewCommentRevisionConflictError, ReviewCursorError, } from "./errors.js";
 export { redactPublicReviewCommentIdentity, redactPublicReviewStatusIdentity, reviewAuthorNameFromContext, shouldRedactReviewIdentity, } from "./identity.js";
 export { extractReviewMentions, normalizeReviewMentions } from "./mentions.js";
 export { notifyReviewComment, REVIEW_NOTIFICATION_PREFS_KEY, type ReviewNotificationResult, } from "./notifications.js";
-export { __resetReviewableResourcesForTests, assertReviewableResourceAccess, getReviewableResource, listReviewableResources, registerReviewableResource, resolveReviewableResourceAccess, } from "./registry.js";
-export { __resetReviewInitForTests, ensureReviewTables, getReviewCommentById, getReviewStatus, getReviewThreadSummary, getReviewThreadRoot, queryReviewComments, routeReviewThread, sendReviewThreadToAgent, } from "./store.js";
+export { __resetReviewableResourcesForTests, assertReviewableResourceAccess, assertReviewCommentAccess, canCommentOnReviewableResource, getReviewableResource, listReviewableResources, normalizeReviewAnchor, REVIEW_SUGGESTION_ANCHOR_KIND, registerReviewableResource, resolveReviewableResourceAccess, reviewCommentPolicy, } from "./registry.js";
+export { __resetReviewInitForTests, ensureReviewTables, findReviewCommentLink, getReviewCommentById, getReviewStatus, getReviewThreadSummary, getReviewThreadRoot, linkReviewComment, listReviewCommentLinks, queryReviewCommentPage, queryReviewComments, routeReviewThread, sendReviewThreadToAgent, } from "./store.js";
 export * from "./suggestions/types.js";
 export { registerSuggestionAdapter, getSuggestionAdapter, listSuggestionAdapters, __resetSuggestionAdaptersForTests, } from "./suggestions/registry.js";
 export { ensureSuggestionTables, getDecision, getSuggestion, getSuggestionByCreationKey, listSuggestions, rebaseSuggestion, __resetSuggestionTablesForTests, } from "./suggestions/store.js";
 export { suggestionActorKind, suggestionActorKindMatchesReceipt, } from "./suggestions/actor-kind.js";
-export type { GetReviewThreadSummaryInput, ReviewThreadSummary, } from "./store.js";
+export type { GetReviewThreadSummaryInput, QueryReviewCommentsInput, ReviewCommentPage, ReviewCommentPosition, ReviewThreadSummary, } from "./store.js";

package/dist/review/index.js

@@ -1,8 +1,9 @@
+export { ReviewAnchorError, ReviewCommentLinkConflictError, ReviewCommentRevisionConflictError, ReviewCursorError, } from "./errors.js";
 export { redactPublicReviewCommentIdentity, redactPublicReviewStatusIdentity, reviewAuthorNameFromContext, shouldRedactReviewIdentity, } from "./identity.js";
 export { extractReviewMentions, normalizeReviewMentions } from "./mentions.js";
 export { notifyReviewComment, REVIEW_NOTIFICATION_PREFS_KEY, } from "./notifications.js";
-export { __resetReviewableResourcesForTests, assertReviewableResourceAccess, getReviewableResource, listReviewableResources, registerReviewableResource, resolveReviewableResourceAccess, } from "./registry.js";
-export { __resetReviewInitForTests, ensureReviewTables, getReviewCommentById, getReviewStatus, getReviewThreadSummary, getReviewThreadRoot, queryReviewComments, routeReviewThread, sendReviewThreadToAgent, } from "./store.js";
+export { __resetReviewableResourcesForTests, assertReviewableResourceAccess, assertReviewCommentAccess, canCommentOnReviewableResource, getReviewableResource, listReviewableResources, normalizeReviewAnchor, REVIEW_SUGGESTION_ANCHOR_KIND, registerReviewableResource, resolveReviewableResourceAccess, reviewCommentPolicy, } from "./registry.js";
+export { __resetReviewInitForTests, ensureReviewTables, findReviewCommentLink, getReviewCommentById, getReviewStatus, getReviewThreadSummary, getReviewThreadRoot, linkReviewComment, listReviewCommentLinks, queryReviewCommentPage, queryReviewComments, routeReviewThread, sendReviewThreadToAgent, } from "./store.js";
 export * from "./suggestions/types.js";
 export { registerSuggestionAdapter, getSuggestionAdapter, listSuggestionAdapters, __resetSuggestionAdaptersForTests, } from "./suggestions/registry.js";
 export { ensureSuggestionTables, getDecision, getSuggestion, getSuggestionByCreationKey, listSuggestions, rebaseSuggestion, __resetSuggestionTablesForTests, } from "./suggestions/store.js";