@voltro/plugin-comments 0.84.0 → 0.86.0

package/dist/quote.js

@@ -0,0 +1,25 @@
+//#region src/quote.ts
+var e = 1e3, t = (t, n, r) => {
+	let i = Math.max(0, Math.min(n, r)), a = Math.min(t.length, Math.max(n, r), i + e), o = t.slice(Math.max(0, i - 32), i), s = t.slice(a, a + 32);
+	return {
+		exact: t.slice(i, a),
+		...o === "" ? {} : { prefix: o },
+		...s === "" ? {} : { suffix: s }
+	};
+}, n = (e, t) => {
+	if (t.exact === "") return null;
+	let n = null;
+	for (let r = e.indexOf(t.exact); r !== -1; r = e.indexOf(t.exact, r + 1)) {
+		let i = e.slice(0, r), a = e.slice(r + t.exact.length), o = (t.prefix !== void 0 && i.endsWith(t.prefix) ? 1 : 0) + (t.suffix !== void 0 && a.startsWith(t.suffix) ? 1 : 0);
+		(n === null || o > n.score) && (n = {
+			start: r,
+			score: o
+		});
+	}
+	return n === null ? null : {
+		start: n.start,
+		end: n.start + t.exact.length
+	};
+};
+//#endregion
+export { e as QUOTE_MAX_LENGTH, n as findQuote, t as textQuote };

package/dist/rpc.d.ts

@@ -3,6 +3,7 @@ import { PluginRpcClientDescriptor } from '@voltro/protocol';
 import { QueryProcedureDescriptor } from '@voltro/protocol';
 import { ReactivityChannel } from '@voltro/protocol';
 import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
 
 /**
  * The plugin's canonical package name — the key an app's `alias` is recorded
@@ -16,6 +17,16 @@ import { Schema } from 'effect';
  */
 export declare const BASE_NAME = "@voltro/plugin-comments";
 
+/**
+ * What a thread is for. All three share the anchor and the same comments;
+ * the kind keeps them apart in the UI and in policy:
+ *  - `discussion` — talk about the anchored thing (the default);
+ *  - `note` — a standing editorial note (context for whoever edits next);
+ *  - `review` — the conversation of a review. A thread is never a task,
+ *    a suggestion or a decision; those live with their own owners.
+ */
+export declare const COMMENT_THREAD_KINDS: readonly ["discussion", "note", "review"];
+
 /** The anchor's access check refused the caller — or no access rule is
  *  declared at all (fail-closed: undeclared access is a refusal, not a pass).
  *  Also the answer for a thread whose anchor row no longer resolves (a
@@ -23,35 +34,30 @@ export declare const BASE_NAME = "@voltro/plugin-comments";
  *  pointing here, and this is what they find — "no longer available", not a
  *  leak and not a crash. */
 declare class CommentAccessRefused extends CommentAccessRefused_base {
+    get message(): string;
 }
 
-declare const CommentAccessRefused_base: Schema.TaggedErrorClass<CommentAccessRefused, "CommentAccessRefused", {
-    readonly _tag: Schema.tag<"CommentAccessRefused">;
-} & {
-    anchor: typeof Schema.String;
-    reason: typeof Schema.String;
-}>;
+declare const CommentAccessRefused_base: Schema.Class<CommentAccessRefused, Schema.TaggedStruct<"CommentAccessRefused", {
+    readonly anchor: Schema.String;
+    readonly reason: Schema.String;
+}>, YieldableError>;
 
 /** The thread / comment id resolves to nothing the caller may see. */
 declare class CommentNotFound extends CommentNotFound_base {
 }
 
-declare const CommentNotFound_base: Schema.TaggedErrorClass<CommentNotFound, "CommentNotFound", {
-    readonly _tag: Schema.tag<"CommentNotFound">;
-} & {
-    id: typeof Schema.String;
-}>;
+declare const CommentNotFound_base: Schema.Class<CommentNotFound, Schema.TaggedStruct<"CommentNotFound", {
+    readonly id: Schema.String;
+}>, YieldableError>;
 
 /** Only the author edits or deletes their own comment (a `comments:moderate`
  *  scope overrides for delete). */
 declare class CommentNotYours extends CommentNotYours_base {
 }
 
-declare const CommentNotYours_base: Schema.TaggedErrorClass<CommentNotYours, "CommentNotYours", {
-    readonly _tag: Schema.tag<"CommentNotYours">;
-} & {
-    id: typeof Schema.String;
-}>;
+declare const CommentNotYours_base: Schema.Class<CommentNotYours, Schema.TaggedStruct<"CommentNotYours", {
+    readonly id: Schema.String;
+}>, YieldableError>;
 
 /** One push channel for the whole surface: every comment write publishes, and
  *  `comments.list` re-runs for subscribers. Table-granular by design for now —
@@ -60,94 +66,119 @@ export declare const commentsFeed: ReactivityChannel;
 
 export declare const commentsRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
 
+/** The app's status policy (`statusPolicy`) refused resolving or reopening
+ *  this thread for the caller — the thread keeps its status. */
+declare class CommentStatusRefused extends CommentStatusRefused_base {
+}
+
+declare const CommentStatusRefused_base: Schema.Class<CommentStatusRefused, Schema.TaggedStruct<"CommentStatusRefused", {
+    readonly threadId: Schema.String;
+    readonly reason: Schema.String;
+}>, YieldableError>;
+
+export declare type CommentThreadKind = (typeof COMMENT_THREAD_KINDS)[number];
+
 export declare const createDescriptor: MutationProcedureDescriptor<"comments.create", Schema.Struct<{
-    anchor: typeof Schema.String;
-    body: typeof Schema.String;
+    readonly anchor: Schema.String;
+    readonly body: Schema.String;
     /** Reply into an existing thread; absent opens a new thread. */
-    threadId: Schema.optional<typeof Schema.String>;
-    mentions: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    readonly threadId: Schema.optional<Schema.String>;
+    readonly mentions: Schema.optional<Schema.$Array<Schema.String>>;
     /** A new thread's passage; ignored on a reply. */
-    quote: Schema.optional<Schema.Struct<{
-        exact: Schema.filter<Schema.filter<typeof Schema.String>>;
-        prefix: Schema.optional<Schema.filter<typeof Schema.String>>;
-        suffix: Schema.optional<Schema.filter<typeof Schema.String>>;
+    readonly quote: Schema.optional<Schema.Struct<{
+        readonly exact: Schema.String;
+        readonly prefix: Schema.optional<Schema.String>;
+        readonly suffix: Schema.optional<Schema.String>;
     }>>;
+    /** A new thread's kind (default `discussion`); ignored on a reply. */
+    readonly kind: Schema.optional<Schema.Literals<readonly ["discussion", "note", "review"]>>;
 }>, Schema.Struct<{
-    threadId: typeof Schema.String;
-    commentId: typeof Schema.String;
-}>, Schema.Union<[typeof CommentAccessRefused, typeof CommentNotFound]>>;
+    readonly threadId: Schema.String;
+    readonly commentId: Schema.String;
+}>, Schema.Union<readonly [typeof CommentAccessRefused, typeof CommentNotFound]>>;
 
 export declare const deleteDescriptor: MutationProcedureDescriptor<"comments.delete", Schema.Struct<{
-    commentId: typeof Schema.String;
+    readonly commentId: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, Schema.Union<[typeof CommentAccessRefused, typeof CommentNotFound, typeof CommentNotYours]>>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Union<readonly [typeof CommentAccessRefused, typeof CommentNotFound, typeof CommentNotYours]>>;
 
 export declare const editDescriptor: MutationProcedureDescriptor<"comments.edit", Schema.Struct<{
-    commentId: typeof Schema.String;
-    body: typeof Schema.String;
+    readonly commentId: Schema.String;
+    readonly body: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, Schema.Union<[typeof CommentAccessRefused, typeof CommentNotFound, typeof CommentNotYours]>>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Union<readonly [typeof CommentAccessRefused, typeof CommentNotFound, typeof CommentNotYours]>>;
 
 export declare const listDescriptor: QueryProcedureDescriptor<"comments.list", Schema.Struct<{
-    anchor: typeof Schema.String;
-}>, Schema.Array$<Schema.Struct<{
-    id: typeof Schema.String;
-    anchor: typeof Schema.String;
+    readonly anchor: Schema.String;
+}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly anchor: Schema.String;
+    readonly kind: Schema.Literals<readonly ["discussion", "note", "review"]>;
     /** The selected passage the thread was opened on, if any. */
-    quote: Schema.NullOr<Schema.Struct<{
-        exact: Schema.filter<Schema.filter<typeof Schema.String>>;
-        prefix: Schema.optional<Schema.filter<typeof Schema.String>>;
-        suffix: Schema.optional<Schema.filter<typeof Schema.String>>;
+    readonly quote: Schema.NullOr<Schema.Struct<{
+        readonly exact: Schema.String;
+        readonly prefix: Schema.optional<Schema.String>;
+        readonly suffix: Schema.optional<Schema.String>;
     }>>;
-    status: Schema.Literal<["open", "resolved"]>;
-    createdBy: typeof Schema.String;
-    createdAt: typeof Schema.String;
-    comments: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        threadId: typeof Schema.String;
-        body: typeof Schema.String;
-        authorSubjectId: typeof Schema.String;
-        mentions: Schema.Array$<typeof Schema.String>;
-        editedAt: Schema.NullOr<typeof Schema.String>;
-        createdAt: typeof Schema.String;
-        reactions: Schema.Array$<Schema.Struct<{
-            emoji: typeof Schema.String;
-            count: typeof Schema.Number;
+    readonly status: Schema.Literals<readonly ["open", "resolved"]>;
+    readonly createdBy: Schema.String;
+    readonly createdAt: Schema.String;
+    readonly comments: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly threadId: Schema.String;
+        readonly body: Schema.String;
+        readonly authorSubjectId: Schema.String;
+        readonly mentions: Schema.$Array<Schema.String>;
+        readonly editedAt: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly reactions: Schema.$Array<Schema.Struct<{
+            readonly emoji: Schema.String;
+            readonly count: Schema.Number;
             /** Whether the CALLER reacted with this emoji (drives the toggle UI). */
-            mine: typeof Schema.Boolean;
+            readonly mine: Schema.Boolean;
         }>>;
     }>>;
     /** Comments newer than the caller's `lastReadAt` for this thread. */
-    unreadCount: typeof Schema.Number;
+    readonly unreadCount: Schema.Number;
+    /** Every status change, oldest first (the first is the thread opening). */
+    readonly history: Schema.$Array<Schema.Struct<{
+        readonly from: Schema.NullOr<Schema.Literals<readonly ["open", "resolved"]>>;
+        readonly to: Schema.Literals<readonly ["open", "resolved"]>;
+        readonly by: Schema.String;
+        readonly at: Schema.String;
+        readonly reason: Schema.NullOr<Schema.String>;
+    }>>;
 }>>, typeof CommentAccessRefused>;
 
 export declare const markReadDescriptor: MutationProcedureDescriptor<"comments.markRead", Schema.Struct<{
-    threadId: typeof Schema.String;
+    readonly threadId: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
+    readonly ok: Schema.Boolean;
 }>, typeof CommentNotFound>;
 
 export declare const mentionSearchDescriptor: QueryProcedureDescriptor<"comments.mentionSearch", Schema.Struct<{
-    query: typeof Schema.String;
-}>, Schema.Array$<Schema.Struct<{
-    subjectId: typeof Schema.String;
-    label: typeof Schema.String;
-}>>, typeof Schema.Never>;
+    readonly query: Schema.String;
+}>, Schema.$Array<Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly label: Schema.String;
+}>>, Schema.Never>;
 
 export declare const reactDescriptor: MutationProcedureDescriptor<"comments.react", Schema.Struct<{
-    commentId: typeof Schema.String;
-    emoji: typeof Schema.String;
+    readonly commentId: Schema.String;
+    readonly emoji: Schema.String;
 }>, Schema.Struct<{
-    reacted: typeof Schema.Boolean;
-}>, Schema.Union<[typeof CommentAccessRefused, typeof CommentNotFound]>>;
+    readonly reacted: Schema.Boolean;
+}>, Schema.Union<readonly [typeof CommentAccessRefused, typeof CommentNotFound]>>;
 
 export declare const resolveDescriptor: MutationProcedureDescriptor<"comments.resolve", Schema.Struct<{
-    threadId: typeof Schema.String;
-    resolved: typeof Schema.Boolean;
+    readonly threadId: Schema.String;
+    readonly resolved: Schema.Boolean;
+    /** Why — kept with the status change. */
+    readonly reason: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, Schema.Union<[typeof CommentAccessRefused, typeof CommentNotFound]>>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Union<readonly [typeof CommentAccessRefused, typeof CommentNotFound, typeof CommentStatusRefused]>>;
 
 export { }

package/dist/rpc.js

@@ -1,2 +1,194 @@
-import { a as e, c as t, d as n, i as r, l as i, n as a, o, r as s, s as c, t as l, u } from "./rpc-DlFs6xXs.js";
-export { l as BASE_NAME, a as commentsFeed, s as commentsRpcClientImports, r as createDescriptor, e as deleteDescriptor, o as editDescriptor, c as listDescriptor, t as markReadDescriptor, i as mentionSearchDescriptor, u as reactDescriptor, n as resolveDescriptor };
+import { CommentAccessRefused as e, CommentNotFound as t, CommentNotYours as n, CommentStatusRefused as r } from "./errors.js";
+import { QUOTE_MAX_LENGTH as i } from "./quote.js";
+import { Schema as a } from "effect";
+import { defineMutation as o, defineQuery as s, reactivityChannel as c } from "@voltro/protocol";
+//#region src/rpc.ts
+var l = "@voltro/plugin-comments", u = c("comments"), d = a.Struct({
+	id: a.String,
+	threadId: a.String,
+	body: a.String,
+	authorSubjectId: a.String,
+	mentions: a.Array(a.String),
+	editedAt: a.NullOr(a.String),
+	createdAt: a.String,
+	reactions: a.Array(a.Struct({
+		emoji: a.String,
+		count: a.Number,
+		mine: a.Boolean
+	}))
+}), f = a.Struct({
+	exact: a.String.pipe(a.check(a.isMinLength(1)), a.check(a.isMaxLength(i))),
+	prefix: a.optional(a.String.pipe(a.check(a.isMaxLength(32)))),
+	suffix: a.optional(a.String.pipe(a.check(a.isMaxLength(32))))
+}), p = [
+	"discussion",
+	"note",
+	"review"
+], m = a.Literals(p), h = a.Struct({
+	from: a.NullOr(a.Literals(["open", "resolved"])),
+	to: a.Literals(["open", "resolved"]),
+	by: a.String,
+	at: a.String,
+	reason: a.NullOr(a.String)
+}), g = a.Struct({
+	id: a.String,
+	anchor: a.String,
+	kind: m,
+	quote: a.NullOr(f),
+	status: a.Literals(["open", "resolved"]),
+	createdBy: a.String,
+	createdAt: a.String,
+	comments: a.Array(d),
+	unreadCount: a.Number,
+	history: a.Array(h)
+}), _ = s({
+	name: "comments.list",
+	source: u,
+	input: a.Struct({ anchor: a.String }),
+	output: a.Array(g),
+	error: e,
+	openAccess: "delegated: the executor runs the app-declared anchor access rule (viaEntity guard or scope) and is fail-closed — an undeclared rule refuses every read"
+}), v = o({
+	name: "comments.create",
+	input: a.Struct({
+		anchor: a.String,
+		body: a.String,
+		threadId: a.optional(a.String),
+		mentions: a.optional(a.Array(a.String)),
+		quote: a.optional(f),
+		kind: a.optional(m)
+	}),
+	output: a.Struct({
+		threadId: a.String,
+		commentId: a.String
+	}),
+	error: a.Union([e, t]),
+	openAccess: "delegated: the executor runs the app-declared anchor access rule before any write; the author is always the calling subject"
+}), y = o({
+	name: "comments.edit",
+	input: a.Struct({
+		commentId: a.String,
+		body: a.String
+	}),
+	output: a.Struct({ ok: a.Boolean }),
+	error: a.Union([
+		e,
+		t,
+		n
+	]),
+	openAccess: "author-scoped: only the comment's own author may edit, checked in the executor on top of the anchor access rule"
+}), b = o({
+	name: "comments.resolve",
+	input: a.Struct({
+		threadId: a.String,
+		resolved: a.Boolean,
+		reason: a.optional(a.String.pipe(a.check(a.isMaxLength(500))))
+	}),
+	output: a.Struct({ ok: a.Boolean }),
+	error: a.Union([
+		e,
+		t,
+		r
+	]),
+	openAccess: "delegated: anchor access rule in the executor, then the app's optional status policy — without one, anyone who may read the anchor may resolve/reopen (the Liveblocks semantic); every change is recorded"
+}), x = o({
+	name: "comments.delete",
+	input: a.Struct({ commentId: a.String }),
+	output: a.Struct({ ok: a.Boolean }),
+	error: a.Union([
+		e,
+		t,
+		n
+	]),
+	openAccess: "author-scoped, with a comments:moderate scope override — both checked in the executor on top of the anchor access rule"
+}), S = o({
+	name: "comments.react",
+	input: a.Struct({
+		commentId: a.String,
+		emoji: a.String
+	}),
+	output: a.Struct({ reacted: a.Boolean }),
+	error: a.Union([e, t]),
+	openAccess: "delegated: anchor access rule in the executor; the toggle writes only the calling subject's own reaction row"
+}), C = o({
+	name: "comments.markRead",
+	input: a.Struct({ threadId: a.String }),
+	output: a.Struct({ ok: a.Boolean }),
+	error: t,
+	openAccess: "self-scoped write: stamps only the calling subject's own read marker for the thread"
+}), w = s({
+	name: "comments.mentionSearch",
+	input: a.Struct({ query: a.String }),
+	output: a.Array(a.Struct({
+		subjectId: a.String,
+		label: a.String
+	})),
+	openAccess: "delegated: the app-declared mention resolver receives the CALLING subject and its default filters to the caller's tenant — cross-tenant subjects are structurally unreachable"
+}), T = [
+	{
+		tag: "comments.list",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "listDescriptor"
+		}
+	},
+	{
+		tag: "comments.create",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "createDescriptor"
+		}
+	},
+	{
+		tag: "comments.edit",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "editDescriptor"
+		}
+	},
+	{
+		tag: "comments.resolve",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "resolveDescriptor"
+		}
+	},
+	{
+		tag: "comments.delete",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "deleteDescriptor"
+		}
+	},
+	{
+		tag: "comments.react",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "reactDescriptor"
+		}
+	},
+	{
+		tag: "comments.markRead",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "markReadDescriptor"
+		}
+	},
+	{
+		tag: "comments.mentionSearch",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "mentionSearchDescriptor"
+		}
+	}
+];
+//#endregion
+export { l as BASE_NAME, p as COMMENT_THREAD_KINDS, u as commentsFeed, T as commentsRpcClientImports, v as createDescriptor, x as deleteDescriptor, y as editDescriptor, _ as listDescriptor, C as markReadDescriptor, w as mentionSearchDescriptor, S as reactDescriptor, b as resolveDescriptor };

package/dist/web.d.ts

@@ -1,3 +1,13 @@
+/**
+ * What a thread is for. All three share the anchor and the same comments;
+ * the kind keeps them apart in the UI and in policy:
+ *  - `discussion` — talk about the anchored thing (the default);
+ *  - `note` — a standing editorial note (context for whoever edits next);
+ *  - `review` — the conversation of a review. A thread is never a task,
+ *    a suggestion or a decision; those live with their own owners.
+ */
+export declare const COMMENT_THREAD_KINDS: readonly ["discussion", "note", "review"];
+
 export declare interface CommentQuote {
     /** The selected text. */
     readonly exact: string;
@@ -13,6 +23,8 @@ export declare interface CommentReactionView {
     readonly mine: boolean;
 }
 
+export declare type CommentThreadKind = (typeof COMMENT_THREAD_KINDS)[number];
+
 export declare interface CommentView {
     readonly id: string;
     readonly threadId: string;
@@ -41,9 +53,19 @@ export declare const QUOTE_MAX_LENGTH = 1000;
 /** The quote for `text` between `start` and `end` (a text control's selection). */
 export declare const textQuote: (text: string, start: number, end: number) => CommentQuote;
 
+/** One status change of a thread (the first is its opening). */
+export declare interface ThreadStatusChange {
+    readonly from: 'open' | 'resolved' | null;
+    readonly to: 'open' | 'resolved';
+    readonly by: string;
+    readonly at: string;
+    readonly reason: string | null;
+}
+
 export declare interface ThreadView {
     readonly id: string;
     readonly anchor: string;
+    readonly kind: CommentThreadKind;
     /** The selected passage the thread was opened on, if any. */
     readonly quote: CommentQuote | null;
     readonly status: 'open' | 'resolved';
@@ -51,6 +73,7 @@ export declare interface ThreadView {
     readonly createdAt: string;
     readonly comments: ReadonlyArray<CommentView>;
     readonly unreadCount: number;
+    readonly history: ReadonlyArray<ThreadStatusChange>;
 }
 
 /**
@@ -65,14 +88,15 @@ export declare interface UseCommentsResult {
     readonly pending: boolean;
     /** Sum of the threads' unread counters — the badge number. */
     readonly unreadCount: number;
-    /** A reply with `threadId`; a new thread otherwise, on the passage `quote` if given. */
+    /** A reply with `threadId`; a new thread otherwise, on the passage `quote` if given, of `kind` (default `discussion`). */
     readonly create: (body: string, opts?: {
         threadId?: string;
         mentions?: ReadonlyArray<string>;
         quote?: CommentQuote;
+        kind?: CommentThreadKind;
     }) => Promise<unknown>;
     readonly edit: (commentId: string, body: string) => Promise<unknown>;
-    readonly resolve: (threadId: string, resolved?: boolean) => Promise<unknown>;
+    readonly resolve: (threadId: string, resolved?: boolean, reason?: string) => Promise<unknown>;
     readonly remove: (commentId: string) => Promise<unknown>;
     readonly react: (commentId: string, emoji: string) => Promise<unknown>;
     readonly markRead: (threadId: string) => Promise<unknown>;

package/dist/web.js

@@ -1,9 +1,10 @@
-import { f as e, m as t, p as n, t as r } from "./rpc-DlFs6xXs.js";
-import { pluginTag as i } from "@voltro/protocol";
-import { useMutation as a, useSubscription as o } from "@voltro/client";
+import { QUOTE_MAX_LENGTH as e, findQuote as t, textQuote as n } from "./quote.js";
+import { BASE_NAME as r, COMMENT_THREAD_KINDS as i } from "./rpc.js";
+import { pluginTag as a } from "@voltro/protocol";
+import { useMutation as o, useSubscription as s } from "@voltro/client";
 //#region src/web.ts
-var s = (e) => i(r, e), c = (e, t = "app") => {
-	let { data: n, loading: r } = o(t, s("list"), { anchor: e }), i = a(t, s("create")), c = a(t, s("edit")), l = a(t, s("resolve")), u = a(t, s("delete")), d = a(t, s("react")), f = a(t, s("markRead")), p = n ?? [];
+var c = (e) => a(r, e), l = (e, t = "app") => {
+	let { data: n, loading: r } = s(t, c("list"), { anchor: e }), i = o(t, c("create")), a = o(t, c("edit")), l = o(t, c("resolve")), u = o(t, c("delete")), d = o(t, c("react")), f = o(t, c("markRead")), p = n ?? [];
 	return {
 		threads: p,
 		pending: r,
@@ -13,15 +14,17 @@ var s = (e) => i(r, e), c = (e, t = "app") => {
 			body: t,
 			...n?.threadId === void 0 ? {} : { threadId: n.threadId },
 			...n?.mentions === void 0 ? {} : { mentions: n.mentions },
-			...n?.quote === void 0 ? {} : { quote: n.quote }
+			...n?.quote === void 0 ? {} : { quote: n.quote },
+			...n?.kind === void 0 ? {} : { kind: n.kind }
 		}),
-		edit: (e, t) => c.mutate({
+		edit: (e, t) => a.mutate({
 			commentId: e,
 			body: t
 		}),
-		resolve: (e, t = !0) => l.mutate({
+		resolve: (e, t = !0, n) => l.mutate({
 			threadId: e,
-			resolved: t
+			resolved: t,
+			...n === void 0 ? {} : { reason: n }
 		}),
 		remove: (e) => u.mutate({ commentId: e }),
 		react: (e, t) => d.mutate({
@@ -30,9 +33,9 @@ var s = (e) => i(r, e), c = (e, t = "app") => {
 		}),
 		markRead: (e) => f.mutate({ threadId: e })
 	};
-}, l = (e, t, n = "app") => c(e, n).threads.find((e) => e.id === t), u = (e, t = "app") => {
-	let { data: n } = o(t, s("mentionSearch"), { query: e });
+}, u = (e, t, n = "app") => l(e, n).threads.find((e) => e.id === t), d = (e, t = "app") => {
+	let { data: n } = s(t, c("mentionSearch"), { query: e });
 	return n ?? [];
 };
 //#endregion
-export { e as QUOTE_MAX_LENGTH, n as findQuote, t as textQuote, c as useComments, u as useMentionSearch, l as useThread };
+export { i as COMMENT_THREAD_KINDS, e as QUOTE_MAX_LENGTH, t as findQuote, n as textQuote, l as useComments, d as useMentionSearch, u as useThread };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-comments",
-  "version": "0.84.0",
+  "version": "0.86.0",
   "description": "Comment threads on any anchor your app can name — replies, resolve/reopen, reactions, per-subject unread — live over the existing reactivity channel, with no second push mechanism. Access delegates to your app's own guard (access.viaEntity) or a scope and fails closed when neither is declared; @-mentions are re-filtered to the caller's tenant on search and re-validated at create, then delivered through plugin-notifications when it is installed. useComments / useThread / useMentionSearch in /web, an ejectable <CommentsThread> in @voltro/ui, plus inspect endpoints and a dashboard panel.",
   "keywords": [
     "voltro",
@@ -48,13 +48,13 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/client": "0.84.0",
-    "@voltro/database": "0.84.0",
-    "@voltro/plugin-notifications": "0.84.0",
-    "@voltro/protocol": "0.84.0"
+    "@voltro/client": "0.86.0",
+    "@voltro/database": "0.86.0",
+    "@voltro/plugin-notifications": "0.86.0",
+    "@voltro/protocol": "0.86.0"
   },
   "peerDependencies": {
-    "effect": "^3.22.2",
+    "effect": "4.0.1",
     "react": "^19.0.0"
   },
   "publishConfig": {