agentic-comments 0.5.1 → 0.6.0

package/dist/cli.js

@@ -3,17 +3,17 @@ import {
   FileStore,
   lockTimeoutFrom,
   operatorActor
-} from "./chunk-QJXI3P5D.js";
+} from "./chunk-2NBFTJ47.js";
 import {
   VERSION
-} from "./chunk-REFQNIEP.js";
+} from "./chunk-ES3NZ7SX.js";
 import {
   CommentsService,
   TEXT_ROOT
-} from "./chunk-NQWRFKJ6.js";
+} from "./chunk-T77DPNIV.js";
 import {
   CommentsError
-} from "./chunk-BSNBDKR2.js";
+} from "./chunk-VAVKBAHM.js";
 
 // src/cli.ts
 import { readFileSync, realpathSync } from "fs";
@@ -24,6 +24,7 @@ var FLAGS = {
   "--file": "value",
   "--as": "value",
   "--body": "value",
+  "--message": "value",
   "--mention": "many",
   "--text-quote": "value",
   "--occurrence": "value",
@@ -50,14 +51,19 @@ var ALLOWED = {
   resolve: SHARED,
   reopen: SHARED,
   relocate: SHARED,
+  "edit-message": [...SHARED, "--message", "--body", "--mention"],
+  "delete-message": [...SHARED, "--message"],
+  "delete-thread": SHARED,
+  "export-person": SHARED,
+  "erase-person": SHARED,
   suggestions: [...SHARED, "--status", "--anchor-state"],
   suggest: [...SHARED, ...ANCHOR, "--replace", "--value", "--summary"],
   accept: SHARED,
   reject: SHARED,
   mcp: SHARED
 };
-var TAKES_ID = ["show", "reply", "resolve", "reopen", "relocate", "accept", "reject"];
-var COMMANDS = ["init", "list", "show", "comment", "reply", "resolve", "reopen", "relocate", "suggestions", "suggest", "accept", "reject", "mcp"];
+var TAKES_ID = ["show", "reply", "resolve", "reopen", "relocate", "accept", "reject", "edit-message", "delete-message", "delete-thread", "export-person", "erase-person"];
+var COMMANDS = ["init", "list", "show", "comment", "reply", "resolve", "reopen", "relocate", "edit-message", "delete-message", "delete-thread", "export-person", "erase-person", "suggestions", "suggest", "accept", "reject", "mcp"];
 function parseArgs(argv) {
   const [command, ...rest] = argv;
   if (command === void 0 || command === "--help" || command === "-h") return { command: "help", flags: {}, many: {} };
@@ -112,6 +118,15 @@ function need(p) {
   if (p.id === void 0) throw new UsageError(`${p.command} needs an id`);
   return p.id;
 }
+function needName(p) {
+  if (p.id === void 0) throw new UsageError(`${p.command} needs the name of a person`);
+  return p.id;
+}
+function flag(p, name) {
+  const value = p.flags[name];
+  if (value === void 0) throw new UsageError(`${p.command} needs ${name}`);
+  return value;
+}
 var HELP = `agentic-comments ${VERSION}
 Comment threads and suggestions anchored to any content, from people and agents.
 
@@ -121,6 +136,7 @@ Setup:
   --file <path>     The store file. Or AGENTIC_COMMENTS_FILE. Default ./comments.ydoc.
   --as <kind:name>  Who acts. Or AGENTIC_COMMENTS_AS. Kinds: human, agent_of_human, agent_of_agent, agent, user_token.
   Scopes come only from AGENTIC_COMMENTS_SCOPES, a comma list such as comments:accept.
+  Another person's message, thread, or data needs comments:moderate.
 
 Commands:
   init [--text <t> | --text-file <p>]         Create the store.
@@ -129,6 +145,11 @@ Commands:
   comment <anchor> --body <t> [--mention h]   Start a thread.
   reply <id> --body <t> [--mention h]         Reply.
   resolve <id> | reopen <id> | relocate <id>
+  edit-message <id> --message <mid> --body <t> [--mention h]   Change a message you wrote.
+  delete-message <id> --message <mid>         Delete a message you wrote.
+  delete-thread <id>                          Delete a thread. Needs every message to be yours.
+  export-person <name>                        Export what a person wrote.
+  erase-person <name>                         Replace what a person wrote with a tombstone.
   suggestions [--status s] [--anchor-state s] List suggestions.
   suggest <anchor> (--replace <t> | --value <json>) [--summary <t>]
   accept <id> | reject <id>
@@ -155,7 +176,7 @@ async function runCli(argv, io) {
       return 0;
     }
     if (p.command === "mcp") {
-      const { startMcp } = await import("./mcp-XUV3RPOO.js");
+      const { startMcp } = await import("./mcp-JX5L6VQW.js");
       await startMcp(store, operatorActor(p.flags["--as"] ?? io.env.AGENTIC_COMMENTS_AS, io.env.AGENTIC_COMMENTS_SCOPES));
       return 0;
     }
@@ -163,7 +184,7 @@ async function runCli(argv, io) {
     const mentions = p.many["--mention"];
     const filter = { status: p.flags["--status"], anchorState: p.flags["--anchor-state"], mentioning: p.flags["--mentioning"] };
     const clean = Object.fromEntries(Object.entries(filter).filter(([, v]) => v !== void 0));
-    const result = p.command === "list" ? service.threads(clean) : p.command === "show" ? service.thread(need(p)) : p.command === "comment" ? service.comment({ anchor: anchorOf(p), body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "reply" ? service.reply(need(p), { body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "resolve" ? service.resolve(need(p)) : p.command === "reopen" ? service.reopen(need(p)) : p.command === "relocate" ? service.relocate(need(p)) : p.command === "suggestions" ? service.suggestions(Object.fromEntries(Object.entries(clean).filter(([k]) => k !== "mentioning"))) : p.command === "suggest" ? service.suggest({ anchor: anchorOf(p), change: changeOf(p), ...p.flags["--summary"] === void 0 ? {} : { summary: p.flags["--summary"] } }) : p.command === "accept" ? service.accept(need(p)) : service.reject(need(p));
+    const result = p.command === "list" ? service.threads(clean) : p.command === "show" ? service.thread(need(p)) : p.command === "comment" ? service.comment({ anchor: anchorOf(p), body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "reply" ? service.reply(need(p), { body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "edit-message" ? service.editMessage(need(p), flag(p, "--message"), { body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "delete-message" ? service.deleteMessage(need(p), flag(p, "--message")) : p.command === "delete-thread" ? service.deleteThread(need(p)) : p.command === "export-person" ? service.exportPerson(needName(p)) : p.command === "erase-person" ? service.erasePerson(needName(p)) : p.command === "resolve" ? service.resolve(need(p)) : p.command === "reopen" ? service.reopen(need(p)) : p.command === "relocate" ? service.relocate(need(p)) : p.command === "suggestions" ? service.suggestions(Object.fromEntries(Object.entries(clean).filter(([k]) => k !== "mentioning"))) : p.command === "suggest" ? service.suggest({ anchor: anchorOf(p), change: changeOf(p), ...p.flags["--summary"] === void 0 ? {} : { summary: p.flags["--summary"] } }) : p.command === "accept" ? service.accept(need(p)) : service.reject(need(p));
     io.out(JSON.stringify(result));
     return 0;
   } catch (error) {

package/dist/client.d.ts

@@ -1,8 +1,8 @@
-import { L as ListFilter, A as AnchorSpec } from './service-hpWbnSmc.js';
-import { C as CommentsErrorCode } from './errors-CNgWMVQT.js';
+import { L as ListFilter, A as AnchorSpec } from './service-BvIE6t5n.js';
+import { C as CommentsErrorCode } from './errors-C-xvp24-.js';
 import { PrincipalKind } from 'agentic-identity';
 export { PrincipalKind } from 'agentic-identity';
-import { T as Thread, N as NewReply, M as Message, S as Suggestion } from './suggestions-CvJwo6r4.js';
+import { T as Thread, N as NewReply, M as Message, P as PersonExport, a as PersonSuggestions, S as Suggestion } from './suggestions-CnkEcTuY.js';
 import 'yjs';
 
 /** Codes the comment rules return, plus the ones the Worker and its auth return. */
@@ -35,6 +35,18 @@ interface Me {
 }
 type ThreadFilter = ListFilter;
 type SuggestionListFilter = Pick<ListFilter, "status" | "anchorState">;
+/** What `exportPerson` returns: the messages and status changes of one person, and their suggestions. */
+type PersonData = PersonExport & {
+    suggestions: PersonSuggestions;
+};
+/** What `erasePerson` changed in one document. */
+interface Erased {
+    messages: number;
+    statuses: number;
+    edits: number;
+    suggestions: number;
+    decisions: number;
+}
 interface CommentsClient {
     me(options?: CallOptions): Promise<Me>;
     createDocument(input: {
@@ -58,6 +70,19 @@ interface CommentsClient {
     resolve(docId: string, threadId: string, options?: CallOptions): Promise<Thread>;
     reopen(docId: string, threadId: string, options?: CallOptions): Promise<Thread>;
     relocate(docId: string, threadId: string, options?: CallOptions): Promise<Thread>;
+    editMessage(docId: string, threadId: string, messageId: string, input: {
+        body: string;
+        mentions?: string[];
+    }, options?: CallOptions): Promise<Message>;
+    deleteMessage(docId: string, threadId: string, messageId: string, options?: CallOptions): Promise<{
+        threadId: string;
+        messageId: string;
+    }>;
+    deleteThread(docId: string, threadId: string, options?: CallOptions): Promise<{
+        threadId: string;
+    }>;
+    exportPerson(docId: string, person: string, options?: CallOptions): Promise<PersonData>;
+    erasePerson(docId: string, person: string, options?: CallOptions): Promise<Erased>;
     listSuggestions(docId: string, filter?: SuggestionListFilter, options?: CallOptions): Promise<Suggestion[]>;
     suggest(docId: string, input: {
         anchor: AnchorSpec;
@@ -69,4 +94,4 @@ interface CommentsClient {
 }
 declare function createClient(options: ClientOptions): CommentsClient;
 
-export { AnchorSpec, type ApiErrorCode, type CallOptions, type ClientOptions, CommentsApiError, type CommentsClient, CommentsErrorCode, ListFilter, type Me, Message, NewReply, Suggestion, type SuggestionListFilter, Thread, type ThreadFilter, createClient };
+export { AnchorSpec, type ApiErrorCode, type CallOptions, type ClientOptions, CommentsApiError, type CommentsClient, CommentsErrorCode, type Erased, ListFilter, type Me, Message, NewReply, type PersonData, PersonExport, PersonSuggestions, Suggestion, type SuggestionListFilter, Thread, type ThreadFilter, createClient };

package/dist/client.js

@@ -4,6 +4,7 @@ var CODES = {
   INVALID_INPUT: true,
   INVALID_ANCHOR: true,
   NO_THREAD: true,
+  NO_MESSAGE: true,
   THREAD_RESOLVED: true,
   CORRUPT: true,
   NO_SUGGESTION: true,
@@ -40,15 +41,21 @@ var CommentsApiError = class extends Error {
 var KINDS = { human: true, agent_of_human: true, agent_of_agent: true, agent: true, user_token: true };
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isString = (v) => typeof v === "string";
+var isAuthor = (v) => isObject(v) && typeof v.kind === "string" && Object.hasOwn(KINDS, v.kind) && isString(v.name);
+var personThread = (v) => isObject(v) && isString(v.threadId) && isObject(v.anchor) && Array.isArray(v.messages) && v.messages.every(SHAPES.message) && (v.statusChange === void 0 || isObject(v.statusChange) && (v.statusChange.status === "open" || v.statusChange.status === "resolved") && isString(v.statusChange.at) && isAuthor(v.statusChange.by));
 var SHAPES = {
-  me: (v) => isObject(v) && (typeof v.kind === "string" && Object.hasOwn(KINDS, v.kind)) && isString(v.name) && Array.isArray(v.scopes),
+  me: (v) => isObject(v) && (typeof v.kind === "string" && Object.hasOwn(KINDS, v.kind)) && isString(v.name) && Array.isArray(v.scopes) && v.scopes.every(isString),
   created: (v) => isObject(v) && isString(v.id),
   document: (v) => isObject(v) && isString(v.id) && isString(v.text),
-  thread: (v) => isObject(v) && isString(v.id) && isObject(v.anchor) && (v.status === "open" || v.status === "resolved") && Array.isArray(v.messages),
+  thread: (v) => isObject(v) && isString(v.id) && isObject(v.anchor) && isObject(v.anchorState) && isString(v.anchorState.state) && (v.status === "open" || v.status === "resolved") && isAuthor(v.statusBy) && isString(v.statusAt) && Array.isArray(v.messages) && v.messages.every(SHAPES.message) && typeof v.skipped === "number",
   threads: (v) => Array.isArray(v) && v.every(SHAPES.thread),
-  message: (v) => isObject(v) && isString(v.id) && isString(v.body) && isObject(v.author),
-  suggestion: (v) => isObject(v) && isString(v.id) && isObject(v.anchor) && isString(v.status) && isObject(v.author),
-  suggestions: (v) => Array.isArray(v) && v.every(SHAPES.suggestion)
+  message: (v) => isObject(v) && isString(v.id) && isString(v.at) && isString(v.body) && Array.isArray(v.mentions) && v.mentions.every(isString) && isAuthor(v.author) && (v.editedAt === void 0 || isString(v.editedAt)) && (v.editedBy === void 0 || isAuthor(v.editedBy)),
+  suggestion: (v) => isObject(v) && isString(v.id) && isObject(v.anchor) && isObject(v.anchorState) && isString(v.anchorState.state) && (v.status === "pending" || v.status === "accepted" || v.status === "rejected") && isAuthor(v.author) && isString(v.createdAt) && "change" in v && (v.summary === void 0 || isString(v.summary)) && (v.decidedBy === void 0 || isAuthor(v.decidedBy)) && (v.decidedAt === void 0 || isString(v.decidedAt)),
+  suggestions: (v) => Array.isArray(v) && v.every(SHAPES.suggestion),
+  deletedMessage: (v) => isObject(v) && isString(v.threadId) && isString(v.messageId),
+  deletedThread: (v) => isObject(v) && isString(v.threadId),
+  person: (v) => isObject(v) && isString(v.person) && isString(v.exportedAt) && Array.isArray(v.threads) && v.threads.every(personThread) && Array.isArray(v.edits) && v.edits.every((e) => isObject(e) && isString(e.threadId) && isString(e.messageId) && isString(e.at)) && typeof v.unread === "number" && isObject(v.suggestions) && Array.isArray(v.suggestions.authored) && v.suggestions.authored.every(SHAPES.suggestion) && Array.isArray(v.suggestions.decided) && v.suggestions.decided.every((d) => isObject(d) && isString(d.id) && (d.status === "accepted" || d.status === "rejected") && isString(d.at)) && typeof v.suggestions.unread === "number",
+  erased: (v) => isObject(v) && ["messages", "statuses", "edits", "suggestions", "decisions"].every((k) => typeof v[k] === "number")
 };
 function createClient(options) {
   if (typeof options.baseUrl !== "string" || options.baseUrl === "") throw new TypeError("createClient needs a baseUrl");
@@ -120,6 +127,11 @@ function createClient(options) {
     resolve: (id, threadId, o) => call("POST", `${thread(id, threadId)}/resolve`, void 0, o, "thread"),
     reopen: (id, threadId, o) => call("POST", `${thread(id, threadId)}/reopen`, void 0, o, "thread"),
     relocate: (id, threadId, o) => call("POST", `${thread(id, threadId)}/relocate`, void 0, o, "thread"),
+    editMessage: (id, threadId, messageId, input, o) => call("PATCH", `${thread(id, threadId)}/messages/${seg(messageId)}`, input, o, "message"),
+    deleteMessage: (id, threadId, messageId, o) => call("DELETE", `${thread(id, threadId)}/messages/${seg(messageId)}`, void 0, o, "deletedMessage"),
+    deleteThread: (id, threadId, o) => call("DELETE", thread(id, threadId), void 0, o, "deletedThread"),
+    exportPerson: (id, person, o) => call("GET", `${doc(id)}/people/${seg(person)}/export`, void 0, o, "person"),
+    erasePerson: (id, person, o) => call("DELETE", `${doc(id)}/people/${seg(person)}`, void 0, o, "erased"),
     listSuggestions: (id, filter, o) => call("GET", `${doc(id)}/suggestions${query(filter)}`, void 0, o, "suggestions"),
     suggest: (id, input, o) => call("POST", `${doc(id)}/suggestions`, input, o, "suggestion"),
     accept: (id, suggestionId, o) => call("POST", `${suggestion(id, suggestionId)}/accept`, void 0, o, "suggestion"),

package/dist/errors-C-xvp24-.d.ts

@@ -0,0 +1,7 @@
+type CommentsErrorCode = "INVALID_AUTHOR" | "INVALID_INPUT" | "INVALID_ANCHOR" | "NO_THREAD" | "NO_MESSAGE" | "THREAD_RESOLVED" | "CORRUPT" | "NO_SUGGESTION" | "FORBIDDEN" | "ALREADY_DECIDED" | "APPLY_FAILED" | "RELOCATE_FAILED" | "STORE_MISSING" | "STORE_EXISTS" | "STORE_CORRUPT" | "STORE_LOCKED" | "STORE_FULL" | "NO_DOCUMENT" | "DOCUMENT_EXISTS" | "CONFLICT" | "MISCONFIGURED" | "USAGE";
+declare class CommentsError extends Error {
+    readonly code: CommentsErrorCode;
+    constructor(code: CommentsErrorCode, message: string);
+}
+
+export { type CommentsErrorCode as C, CommentsError as a };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { a as Author, C as Comments, b as Suggestions } from './suggestions-CvJwo6r4.js';
-export { c as ACCEPT_SCOPE, A as Actor, d as Anchor, e as AnchorKind, f as AnchorState, g as ApplyContext, h as CanvasAnchor, i as CellAnchor, j as CommentsOptions, M as Message, N as NewReply, k as NewSuggestion, l as NewThread, R as RelativePositionJson, m as RevertContext, n as SlideAnchor, o as StampInput, S as Suggestion, p as SuggestionFilter, q as SuggestionHost, r as TextAnchor, T as Thread, s as ThreadFilter, t as authorLabel, u as stamp, v as textAnchor, w as textOf } from './suggestions-CvJwo6r4.js';
-export { a as CommentsError, C as CommentsErrorCode } from './errors-CNgWMVQT.js';
+import { b as Author, C as Comments, c as Suggestions } from './suggestions-CnkEcTuY.js';
+export { d as ACCEPT_SCOPE, A as Actor, e as Anchor, f as AnchorKind, g as AnchorState, h as ApplyContext, i as CanvasAnchor, j as CellAnchor, k as CommentsOptions, E as ERASED_BODY, l as ERASED_NAME, m as EditMessage, n as MODERATE_SCOPE, M as Message, N as NewReply, o as NewSuggestion, p as NewThread, P as PersonExport, R as RelativePositionJson, q as RevertContext, r as SlideAnchor, s as StampInput, S as Suggestion, t as SuggestionFilter, u as SuggestionHost, v as TextAnchor, T as Thread, w as ThreadFilter, x as authorLabel, y as stamp, z as textAnchor, B as textOf } from './suggestions-CnkEcTuY.js';
+export { a as CommentsError, C as CommentsErrorCode } from './errors-C-xvp24-.js';
 export { PRINCIPAL_KINDS, PrincipalKind } from 'agentic-identity';
 import 'yjs';
 

package/dist/index.js

@@ -1,11 +1,14 @@
 import {
   VERSION
-} from "./chunk-REFQNIEP.js";
+} from "./chunk-ES3NZ7SX.js";
 import {
   ACCEPT_SCOPE,
   Actor,
   Comments,
   CommentsError,
+  ERASED_BODY,
+  ERASED_NAME,
+  MODERATE_SCOPE,
   PRINCIPAL_KINDS,
   Suggestions,
   authorLabel,
@@ -14,7 +17,7 @@ import {
   textAnchor,
   textOf,
   validDate
-} from "./chunk-BSNBDKR2.js";
+} from "./chunk-VAVKBAHM.js";
 
 // src/notifications.ts
 import * as Y from "yjs";
@@ -134,7 +137,16 @@ var Notifications = class {
           if (change) this.statusChanged(String(path[0]), change.oldValue, source);
         } else if (path.length === 2 && path[1] === "messages" && event.target instanceof Y.Array) {
           const ids = /* @__PURE__ */ new Set();
-          for (const item of event.changes.added) for (const raw of item.content.getContent()) ids.add(raw?.id);
+          const changes = event.changes;
+          const replaced = /* @__PURE__ */ new Set();
+          for (const item of changes.deleted) for (const raw of item.content.getContent()) replaced.add(raw?.id);
+          const seen = /* @__PURE__ */ new Set();
+          for (const raw of event.target.toArray()) {
+            const id = raw?.id;
+            if (seen.has(id)) replaced.add(id);
+            seen.add(id);
+          }
+          for (const item of changes.added) for (const raw of item.content.getContent()) if (!replaced.has(raw?.id)) ids.add(raw?.id);
           this.messagesAdded(String(path[0]), ids, source);
         }
       });
@@ -212,6 +224,9 @@ export {
   Actor,
   Comments,
   CommentsError,
+  ERASED_BODY,
+  ERASED_NAME,
+  MODERATE_SCOPE,
   Notifications,
   PRINCIPAL_KINDS,
   Suggestions,

package/dist/local.d.ts

@@ -1,6 +1,6 @@
 import * as Y from 'yjs';
-export { A as AnchorSpec, C as CommentsService, L as ListFilter } from './service-hpWbnSmc.js';
-import { q as SuggestionHost, A as Actor } from './suggestions-CvJwo6r4.js';
+export { A as AnchorSpec, C as CommentsService, L as ListFilter } from './service-BvIE6t5n.js';
+import { u as SuggestionHost, A as Actor } from './suggestions-CnkEcTuY.js';
 import 'agentic-identity';
 
 /** The most bytes a saved document holds. A save over this is refused, so a file never grows past what a load accepts. */

package/dist/local.js

@@ -3,14 +3,14 @@ import {
   MAX_FILE,
   lockTimeoutFrom,
   operatorActor
-} from "./chunk-QJXI3P5D.js";
+} from "./chunk-2NBFTJ47.js";
 import {
   CommentsService,
   TEXT_ROOT,
   VALUES_ROOT,
   localHost
-} from "./chunk-NQWRFKJ6.js";
-import "./chunk-BSNBDKR2.js";
+} from "./chunk-T77DPNIV.js";
+import "./chunk-VAVKBAHM.js";
 export {
   CommentsService,
   FileStore,

package/dist/mcp-JX5L6VQW.js

@@ -0,0 +1,11 @@
+import {
+  createMcpServer,
+  startMcp
+} from "./chunk-SR2A5OZW.js";
+import "./chunk-ES3NZ7SX.js";
+import "./chunk-T77DPNIV.js";
+import "./chunk-VAVKBAHM.js";
+export {
+  createMcpServer,
+  startMcp
+};

package/dist/mcp-bin.js

@@ -3,15 +3,15 @@ import {
   FileStore,
   lockTimeoutFrom,
   operatorActor
-} from "./chunk-QJXI3P5D.js";
+} from "./chunk-2NBFTJ47.js";
 import {
   startMcp
-} from "./chunk-TFRLOBJW.js";
+} from "./chunk-SR2A5OZW.js";
 import {
   VERSION
-} from "./chunk-REFQNIEP.js";
-import "./chunk-NQWRFKJ6.js";
-import "./chunk-BSNBDKR2.js";
+} from "./chunk-ES3NZ7SX.js";
+import "./chunk-T77DPNIV.js";
+import "./chunk-VAVKBAHM.js";
 
 // src/mcp-bin.ts
 var MCP_HELP = `agentic-comments-mcp ${VERSION}

package/dist/{service-hpWbnSmc.d.ts → service-BvIE6t5n.d.ts}

@@ -1,5 +1,5 @@
 import * as Y from 'yjs';
-import { A as Actor, T as Thread, M as Message, S as Suggestion } from './suggestions-CvJwo6r4.js';
+import { A as Actor, T as Thread, M as Message, P as PersonExport, a as PersonSuggestions, S as Suggestion } from './suggestions-CnkEcTuY.js';
 
 /** Where a comment or suggestion points, in terms a person or agent can write down. */
 type AnchorSpec = {
@@ -51,6 +51,29 @@ declare class CommentsService {
     resolve(threadId: string): Thread;
     reopen(threadId: string): Thread;
     relocate(threadId: string): Thread;
+    editMessage(threadId: string, messageId: string, input: {
+        body: string;
+        mentions?: string[];
+    }): Message;
+    deleteMessage(threadId: string, messageId: string): {
+        threadId: string;
+        messageId: string;
+    };
+    deleteThread(threadId: string): {
+        threadId: string;
+    };
+    /** Everything the store holds that this person wrote: messages, status changes, and suggestions. */
+    exportPerson(person: string): PersonExport & {
+        suggestions: PersonSuggestions;
+    };
+    /** Tombstone everything this person wrote. Both parts are checked before either is written. */
+    erasePerson(person: string): {
+        messages: number;
+        statuses: number;
+        edits: number;
+        suggestions: number;
+        decisions: number;
+    };
     suggestions(filter?: ListFilter): Suggestion[];
     suggest(input: {
         anchor: AnchorSpec;

package/dist/{suggestions-CvJwo6r4.d.ts → suggestions-CnkEcTuY.d.ts}

@@ -1,6 +1,9 @@
 import * as Y from 'yjs';
 import { PrincipalKind } from 'agentic-identity';
 
+/** The name an erased author shows. No principal may have it, so a tombstone belongs to no one. */
+declare const ERASED_NAME = "erased";
+
 /** What a thread keeps about who wrote a message. Scopes never reach storage. */
 interface Author {
     kind: PrincipalKind;
@@ -102,6 +105,11 @@ interface Message {
     body: string;
     /** Handles named in the body or listed on the input, without the `@`. */
     mentions: string[];
+    /** Set when the message was edited. A message that was never edited has none. */
+    editedAt?: string;
+    editedBy?: Author;
+    /** True for a message that `erasePerson` replaced with a tombstone. */
+    erased?: true;
 }
 interface Thread {
     id: string;
@@ -138,6 +146,34 @@ interface NewReply {
     body: string;
     mentions?: string[];
 }
+interface EditMessage {
+    body: string;
+    mentions?: string[];
+}
+/** What the store holds about one person in one document. It lists only that person's own words and acts. */
+interface PersonExport {
+    person: string;
+    exportedAt: string;
+    threads: {
+        threadId: string;
+        anchor: Anchor;
+        messages: Message[];
+        /** Set when this person made the status change that stands now. */
+        statusChange?: {
+            status: Thread["status"];
+            at: string;
+            by: Author;
+        };
+    }[];
+    /** Messages by other people that this person edited. */
+    edits: {
+        threadId: string;
+        messageId: string;
+        at: string;
+    }[];
+    /** Stored entries with this person's name that the export cannot show. Not 0 means the export is not complete. */
+    unread: number;
+}
 interface ThreadFilter {
     status?: Thread["status"];
     anchorType?: string;
@@ -145,6 +181,11 @@ interface ThreadFilter {
     mentioning?: string;
     anchorState?: AnchorState["state"];
 }
+/** A scope that lets a principal edit, delete, export, or erase what another person wrote. A host gives it to an owner or admin. */
+declare const MODERATE_SCOPE = "comments:moderate";
+/** What an erased message shows in place of its body. The author shows `ERASED_NAME`. */
+declare const ERASED_BODY = "[erased]";
+
 /** Comment threads on a Yjs document. Replies and status merge across replicas. */
 declare class Comments {
     readonly ydoc: Y.Doc;
@@ -188,6 +229,62 @@ declare class Comments {
     relocate(threadId: string, actor: Actor): Thread;
     resolve(threadId: string, actor: Actor): Thread;
     reopen(threadId: string, actor: Actor): Thread;
+    /** A principal may change what it wrote. A principal with the moderate scope may change what anyone wrote. A tombstone is nobody's. */
+    private mayChange;
+    private forbid;
+    /** Replace every stored copy of a message with `next`, or remove it when `next` is undefined. */
+    private rewrite;
+    private find;
+    /** Change the body of a message. Its author and time stay, and it records who edited it and when. */
+    editMessage(threadId: string, messageId: string, input: EditMessage, actor: Actor): Message;
+    private readEdited;
+    /**
+     * Remove one message, also from a resolved thread. The last message of a thread stays: delete the thread instead. Replicas that delete
+     * two messages at once can leave a thread with none. A moderator can still delete that thread.
+     */
+    deleteMessage(threadId: string, messageId: string, actor: Actor): {
+        threadId: string;
+        messageId: string;
+    };
+    /**
+     * Remove a thread and all its messages. Its author may do it when every message is theirs. Once someone
+     * else replied, a message is erased, or a stored message cannot be read, it needs the moderate scope. A
+     * moderator can also remove a thread that cannot be read at all.
+     */
+    deleteThread(threadId: string, actor: Actor): {
+        threadId: string;
+    };
+    /**
+     * Check who an export or erase is for, and that the actor may. A person may act on their own data: the same
+     * kind and name. A principal with the moderate scope may act on anyone's, and then every kind with that name is
+     * included. Returns the name and a test for an author. Used by `Suggestions`.
+     */
+    checkPerson(person: unknown, actor: Actor): {
+        name: string;
+        match: (author: Author) => boolean;
+    };
+    /** The raw stored threads, for the code that must see data a read hides. `list` is missing when the message field is bad. */
+    private stored;
+    /**
+     * What a person wrote in this document: their messages, the status change of theirs that stands, and the
+     * edits they made to other people's messages. `unread` counts stored entries with their name that this read
+     * cannot show: a bad message, a thread that cannot be read, a message past the read limit, or a copy that
+     * lost a merge. When it is not 0 the export is not complete. A person may export their own data.
+     */
+    exportPerson(person: string, actor: Actor): PersonExport;
+    /**
+     * Replace every message a person wrote with a tombstone: the body becomes "[erased]", the author name
+     * becomes "erased", and the mentions go. The author kind stays, so machine-made work stays marked. Thread
+     * shape, order, and times stay. A status change of theirs, and their name as the editor of another person's
+     * message, get the tombstone name. It works on the stored entries, so it reaches a bad message, a message past
+     * the read limit, a thread that cannot be read, and every copy that a merge hid. Names inside other people's
+     * messages are not touched. Returns how many messages, status changes, and edit stamps it erased.
+     */
+    erasePerson(person: string, actor: Actor): {
+        messages: number;
+        statuses: number;
+        edits: number;
+    };
     get(threadId: string): Thread;
     /** Threads in the order they were started. A malformed thread is skipped; `problems()` names it. */
     list(filter?: ThreadFilter): Thread[];
@@ -215,6 +312,17 @@ interface Suggestion {
     decidedBy?: Author;
     decidedAt?: string;
 }
+/** What a person wrote and decided among the suggestions of one document. */
+interface PersonSuggestions {
+    authored: Suggestion[];
+    decided: {
+        id: string;
+        status: "accepted" | "rejected";
+        at: string;
+    }[];
+    /** Stored entries with this person's name that the export cannot show. Not 0 means it is not complete. */
+    unread: number;
+}
 interface ApplyContext {
     suggestionId: string;
     anchor: Anchor;
@@ -302,6 +410,25 @@ declare class Suggestions {
     private index;
     private read;
     private fields;
+    /**
+     * The suggestions a person wrote, and the decisions they made, in this document. `unread` counts stored
+     * suggestions and decision records with their name that this export cannot show: a suggestion that cannot
+     * be read, a decision that lost a merge, a refused decision, or a decision with no suggestion. When it is not
+     * 0 the export is not complete. A person may export their own data.
+     */
+    exportPerson(person: string, actor: Actor): PersonSuggestions;
+    private named;
+    /**
+     * Give every suggestion a person wrote a tombstone author and drop its summary. An accepted one keeps its
+     * change, because that change is already part of the content. A pending or rejected one loses its change, and
+     * can no longer be accepted. A decision they made gets a tombstone decider. A decision that a read refuses (a
+     * principal that decided its own work) is deleted, so erase never turns it into a valid one. Returns how many
+     * suggestions and decisions it changed.
+     */
+    erasePerson(person: string, actor: Actor): {
+        suggestions: number;
+        decisions: number;
+    };
     /** Propose a change. Anyone can suggest. The host stamps the author. */
     add(input: NewSuggestion, actor: Actor): Suggestion;
     /** A person decides. An agent needs the accept scope, and never decides its own suggestion. */
@@ -330,4 +457,4 @@ declare class Suggestions {
     settle(): void;
 }
 
-export { Actor as A, Comments as C, type Message as M, type NewReply as N, type RelativePositionJson as R, type Suggestion as S, type Thread as T, type Author as a, Suggestions as b, ACCEPT_SCOPE as c, type Anchor as d, type AnchorKind as e, type AnchorState as f, type ApplyContext as g, type CanvasAnchor as h, type CellAnchor as i, type CommentsOptions as j, type NewSuggestion as k, type NewThread as l, type RevertContext as m, type SlideAnchor as n, type StampInput as o, type SuggestionFilter as p, type SuggestionHost as q, type TextAnchor as r, type ThreadFilter as s, authorLabel as t, stamp as u, textAnchor as v, textOf as w };
+export { Actor as A, textOf as B, Comments as C, ERASED_BODY as E, type Message as M, type NewReply as N, type PersonExport as P, type RelativePositionJson as R, type Suggestion as S, type Thread as T, type PersonSuggestions as a, type Author as b, Suggestions as c, ACCEPT_SCOPE as d, type Anchor as e, type AnchorKind as f, type AnchorState as g, type ApplyContext as h, type CanvasAnchor as i, type CellAnchor as j, type CommentsOptions as k, ERASED_NAME as l, type EditMessage as m, MODERATE_SCOPE as n, type NewSuggestion as o, type NewThread as p, type RevertContext as q, type SlideAnchor as r, type StampInput as s, type SuggestionFilter as t, type SuggestionHost as u, type TextAnchor as v, type ThreadFilter as w, authorLabel as x, stamp as y, textAnchor as z };

package/dist/worker.d.ts

@@ -2,8 +2,8 @@ import { Hono } from 'hono';
 import { Auth, Store, PrincipalContext, Region } from 'agentic-identity';
 import { RequirePrincipalOptions } from 'agentic-identity/http';
 import { D1Like } from 'agentic-identity/cloudflare';
-import { A as Actor } from './suggestions-CvJwo6r4.js';
-import { C as CommentsService } from './service-hpWbnSmc.js';
+import { A as Actor } from './suggestions-CnkEcTuY.js';
+import { C as CommentsService } from './service-BvIE6t5n.js';
 import 'yjs';
 
 interface WorkerEnv {
@@ -13,8 +13,10 @@ interface WorkerEnv {
     AGENTIC_COMMENTS_UNSAFE_REGION?: string;
     /** D1 database: each document, with its threads, as a Yjs update. */
     DB?: D1Like;
+    /** Set to "1" to read `AGENTIC_COMMENTS_TOKENS`. Without it the list never signs anyone in, and a request gets 503 when the list is set. A dev fallback: never set it in production. */
+    AGENTIC_COMMENTS_UNSAFE_STATIC_TOKENS?: string;
     /**
-     * JSON object: bearer token (32 to 512 bytes of A-Z a-z 0-9 _ -) to `kind:name` (the name uses A-Z a-z 0-9 . _ -), or to `{ "as": "kind:name", "scopes": ["comments:write"] }`.
+     * Dev fallback, read only when `AGENTIC_COMMENTS_UNSAFE_STATIC_TOKENS` is "1". It is tried after the identity credentials. JSON object: bearer token (32 to 512 bytes of A-Z a-z 0-9 _ -) to `kind:name` (the name uses A-Z a-z 0-9 . _ -), or to `{ "as": "kind:name", "scopes": ["comments:write"] }`.
      * Set it as a secret. A short token or a bad entry refuses the whole config.
      */
     AGENTIC_COMMENTS_TOKENS?: string;
@@ -26,7 +28,7 @@ interface WorkerEnv {
 declare function createTokenAuth(raw: string | undefined): Auth;
 /** The documents, on the `Store` port. Each write loads the document, runs the change, and saves in one transaction. */
 declare class CommentsDocs {
-    private readonly store;
+    readonly store: Store;
     constructor(store: Store);
     private id;
     private load;
@@ -38,7 +40,10 @@ declare class CommentsDocs {
 /** The docs, or a function that makes them from the Worker bindings. */
 type DocsSource = CommentsDocs | ((env: WorkerEnv) => Promise<CommentsDocs>);
 interface AppOptions {
-    /** The credential check. The default reads `AGENTIC_COMMENTS_TOKENS`. Pass any `Auth` from agentic-identity to replace it. */
+    /**
+     * The credential check. The default reads credentials and principals from the Store of the documents (`createStoreAuth`),
+     * then the static list when `AGENTIC_COMMENTS_UNSAFE_STATIC_TOKENS=1`. Pass any `Auth` from agentic-identity to replace it.
+     */
     auth?: Auth | ((env: WorkerEnv) => Auth);
     /** Origins that may send a write with a session cookie. A bearer token needs none. Passed to `requirePrincipal`. */
     origins?: RequirePrincipalOptions["origins"];