agentic-comments 0.7.0 → 0.8.0

package/README.md

@@ -86,6 +86,36 @@ erased message or a thread that holds one.
 Replicas that edit one message at once leave a copy each. When the copies agree on the author kind and time,
 the read keeps the erased copy, or else the latest edit. An edit and a delete made at once keep the edit.
 
+## Account export and erase
+
+`import { commentsAccount } from "agentic-comments/account"` lets a host export and erase one person's data
+without reading the storage layout. Pass the subject (`{ kind, name }`) and `{ documents, actor }`. Each
+document is `{ id, comments, suggestions }`. The actor is made with `stamp()` and must name the subject.
+`exportAccount` returns JSON records in `messages`, `statusChanges`, `edits`, `suggestions`, `decisions`,
+`documents`, and `unread`. `eraseAccount` tombstones the same data as `erasePerson` and returns counts. A second
+erase counts 0, except `unread`: see below.
+
+The package keeps no grants or audit rows. A host that runs the HTTP worker passes `worker: docs` (the
+`CommentsDocs` of the worker). Then the run also covers every stored document: the subject's messages and
+suggestions in it, and the creator that the worker keeps on each row. The creators are listed under `documents`
+and get the tombstone name on erase. Without `worker`, that data stays. A stored document is erased in one
+transaction. A stored document that `documents` also lists is refused, before any write. The check compares ids
+only. A row whose creator cannot be read shows in `unread` of the export, and in the `unread` count of the erase,
+which leaves the row in place. `unread` counts every row it cannot read, whoever made it, so it can stay above 0 on a repeat. A store that loses a race gives `CONFLICT`: run the erase again.
+
+A run covers only the subject's own kind: `human:ada` does not reach `agent_of_human:ada`. Names and mentions of
+the subject inside other people's messages are neither exported nor erased. Records can name other people, such
+as the moderator in `editedBy` or the person in `decidedBy`. A record in `unread` means the export is not
+complete: the store holds entries of the subject that a read cannot show. A missing `documents` list is an
+error, not an empty run. Erase goes document by document. If one fails, the error code tells why, the message names the document when the store allows, and the earlier
+documents stay erased. A failed document in `documents` may be partly erased (its threads and its suggestions
+are two steps). A repeat counts only what is left. The counts of a failed run are lost.
+
+The ids in `documents` and the ids of the worker share one namespace. Erase can make a state a little larger, so a stored
+document near the size limit may stop the run with `STORE_FULL`: the host must shrink or delete that document, and
+run the erase again. The run reads the list of stored documents once. Block the subject before the erase, so no
+document is made during it. A repeat erase finishes what a race left.
+
 ## Anchors for plain text
 
 `agentic-comments/anchor` pins a range of a plain string. It needs no Yjs and no framework.

package/dist/account.d.ts

@@ -0,0 +1,62 @@
+import { C as Comments, c as Suggestions, b as Author, A as Actor } from './suggestions-G1seGf5d.js';
+import 'yjs';
+import 'agentic-identity';
+
+/** One document the host holds comments on. The host loads it; the package never lists documents. */
+interface CommentsAccountDocument {
+    /** A stable id for the document. It goes in each exported record. */
+    id: string;
+    comments: Comments;
+    suggestions: Suggestions;
+}
+/** What `CommentsDocs` offers the plug-in. */
+interface AccountWorker {
+    /** The id of each stored document. */
+    accountDocumentIds(): Promise<string[]>;
+    /** Runs `fn` on each stored document. With `save`, the state is written back in the same transaction. A document deleted meanwhile is skipped. `committed` is called with the id after its transaction commits. */
+    eachAccountDocument(fn: (doc: CommentsAccountDocument) => void, save: boolean, committed?: (id: string) => void): Promise<void>;
+    /** The documents the subject created. `unread` names the rows whose creator cannot be read, so the export is not complete for them. */
+    exportCreated(author: Author): Promise<{
+        documents: {
+            documentId: string;
+            createdAt: unknown;
+        }[];
+        unread: string[];
+    }>;
+    /** `count` is the creators it tombstoned. `unread` names the rows whose creator cannot be read, which it leaves in place. */
+    eraseCreated(author: Author): Promise<{
+        count: number;
+        unread: string[];
+    }>;
+}
+interface CommentsAccountDeps {
+    /** Every document that may hold data of the subject. */
+    documents: Iterable<CommentsAccountDocument>;
+    /** Made with `stamp()`. It must name the subject: the same kind and name. A moderate scope does not widen the run. */
+    actor: Actor;
+    /**
+     * The document store of the HTTP worker (`CommentsDocs`), when the host runs it. Its rows hold the threads of each
+     * document and the creator of each document, outside what `documents` can reach. Pass it, and the run covers every
+     * stored document. Without it, a worker host leaves that data in place.
+     */
+    worker?: AccountWorker;
+}
+type JsonRecord = Record<string, unknown>;
+interface CommentsAccount {
+    id: "comments";
+    /**
+     * Collections, each record tagged with `documentId`: `messages` (with the thread anchor), `statusChanges`,
+     * `edits` (the subject's edits of other people's messages), `suggestions` (the ones the subject wrote),
+     * `decisions` (accepts and rejects by the subject), `documents` (the worker documents the subject created, only
+     * when `deps.worker` is set), and `unread` (stored entries of the subject that a read
+     * cannot show; the export is not complete when this has a record). The package keeps no grants or audit rows. Its
+     * one owner-like record is the creator of a worker document, which `deps.worker` covers. A host that runs the
+     * worker and omits `worker` leaves that creator in place.
+     */
+    exportAccount(subject: Author, deps: CommentsAccountDeps): Promise<Record<"messages" | "statusChanges" | "edits" | "suggestions" | "decisions" | "documents" | "unread", JsonRecord[]>>;
+    /** Replaces what the subject wrote with a tombstone (see `Comments.erasePerson`). Counts by kind, summed over documents. The thread shape stays. A repeat finds nothing and counts 0. A decision that the subject made on their own suggestion is deleted and not counted, while `unread` in the export counts it. */
+    eraseAccount(subject: Author, deps: CommentsAccountDeps): Promise<Record<"messages" | "statuses" | "edits" | "suggestions" | "decisions" | "documents" | "unread", number>>;
+}
+declare const commentsAccount: CommentsAccount;
+
+export { type AccountWorker, type CommentsAccount, type CommentsAccountDeps, type CommentsAccountDocument, commentsAccount };

package/dist/account.js

@@ -0,0 +1,114 @@
+import {
+  Actor,
+  Comments,
+  CommentsError,
+  Suggestions,
+  assertActor,
+  readAuthor,
+  shown
+} from "./chunk-4G5BDTBA.js";
+
+// src/account.ts
+import { StoreConflictError } from "agentic-identity";
+var plain = (value) => JSON.parse(JSON.stringify(value));
+function check(subject, deps) {
+  const who = readAuthor(subject);
+  if (!who) throw new CommentsError("INVALID_INPUT", "subject needs a known kind and a name");
+  const actor = assertActor(deps?.actor);
+  if (actor.kind !== who.kind || actor.name !== who.name) throw new CommentsError("FORBIDDEN", "actor does not match the subject");
+  if (typeof deps?.documents?.[Symbol.iterator] !== "function") throw new CommentsError("INVALID_INPUT", "deps.documents must be a list of documents");
+  const documents = [...deps.documents];
+  const ids = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const bad = (why) => {
+    throw new CommentsError("INVALID_INPUT", `deps: ${why}`);
+  };
+  if (deps.worker !== void 0 && ["accountDocumentIds", "eachAccountDocument", "exportCreated", "eraseCreated"].some((m) => typeof deps.worker?.[m] !== "function")) bad("worker needs accountDocumentIds, eachAccountDocument, exportCreated, and eraseCreated");
+  for (const d of documents) {
+    if (typeof d?.id !== "string" || d.id === "" || ids.has(d.id)) bad("each document needs a unique id");
+    if (!(d.comments instanceof Comments) || !(d.suggestions instanceof Suggestions)) bad("each document needs Comments and Suggestions made by this package");
+    if (d.suggestions.comments.ydoc !== d.comments.ydoc) bad("suggestions must be made on the same comments");
+    if (seen.has(d.comments.ydoc)) bad("two documents share one Yjs document");
+    ids.add(d.id);
+    seen.add(d.comments.ydoc);
+  }
+  return { documents, own: Actor.of(who) };
+}
+function collect({ id: documentId, comments, suggestions }, own, out) {
+  const c = comments.exportPerson(own.name, own);
+  const s = suggestions.exportPerson(own.name, own);
+  for (const t of c.threads) {
+    for (const message of t.messages) out.messages.push({ ...message, documentId, threadId: t.threadId, anchor: t.anchor });
+    if (t.statusChange) out.statusChanges.push({ ...t.statusChange, documentId, threadId: t.threadId });
+  }
+  for (const e of c.edits) out.edits.push({ ...e, documentId });
+  for (const x of s.authored) out.suggestions.push({ ...x, documentId });
+  for (const d of s.decided) out.decisions.push({ documentId, suggestionId: d.id, status: d.status, at: d.at });
+  const unread = c.unread + s.unread;
+  if (unread > 0) out.unread.push({ documentId, count: unread });
+}
+async function stopAt(where, run) {
+  try {
+    return await run();
+  } catch (cause) {
+    const known = cause instanceof CommentsError;
+    const reason = cause instanceof Error ? cause.message : "unknown error";
+    if (!known && !(cause instanceof StoreConflictError)) throw cause;
+    throw new CommentsError(known ? cause.code : "CONFLICT", `erase stopped at ${where}: ${reason}`, { cause });
+  }
+}
+async function refuseOverlap(documents, worker) {
+  const listed = new Set(documents.map((d) => d.id));
+  if ((await worker.accountDocumentIds()).some((id) => listed.has(id))) throw new CommentsError("INVALID_INPUT", "deps.worker holds a document that deps.documents also lists");
+}
+function wipe({ comments, suggestions }, own, counts) {
+  const c = comments.erasePerson(own.name, own);
+  const s = suggestions.erasePerson(own.name, own);
+  counts.messages += c.messages;
+  counts.statuses += c.statuses;
+  counts.edits += c.edits;
+  counts.suggestions += s.suggestions;
+  counts.decisions += s.decisions;
+}
+var commentsAccount = {
+  id: "comments",
+  async exportAccount(subject, deps) {
+    const { documents, own } = check(subject, deps);
+    const out = { messages: [], statusChanges: [], edits: [], suggestions: [], decisions: [], documents: [], unread: [] };
+    if (deps.worker) await refuseOverlap(documents, deps.worker);
+    for (const doc of documents) collect(doc, own, out);
+    if (deps.worker) {
+      await deps.worker.eachAccountDocument((doc) => collect(doc, own, out), false);
+      const created = await deps.worker.exportCreated(own);
+      out.documents.push(...created.documents);
+      for (const documentId of created.unread) out.unread.push({ documentId, count: 1 });
+    }
+    return plain(out);
+  },
+  async eraseAccount(subject, deps) {
+    const { documents, own } = check(subject, deps);
+    if (deps.worker) await refuseOverlap(documents, deps.worker);
+    const counts = { messages: 0, statuses: 0, edits: 0, suggestions: 0, decisions: 0, documents: 0, unread: 0 };
+    for (const doc of documents) await stopAt(`document ${shown(doc.id)}`, () => wipe(doc, own, counts));
+    if (deps.worker) {
+      const each = /* @__PURE__ */ new Map();
+      const done = /* @__PURE__ */ new Set();
+      await stopAt(
+        "a worker document",
+        () => deps.worker.eachAccountDocument((doc) => {
+          const one = { messages: 0, statuses: 0, edits: 0, suggestions: 0, decisions: 0, documents: 0, unread: 0 };
+          wipe(doc, own, one);
+          each.set(doc.id, one);
+        }, true, (id) => void done.add(id))
+      );
+      for (const [id, c] of each) if (done.has(id)) for (const k of Object.keys(counts)) counts[k] += c[k];
+      const creators = await stopAt("the worker creators", () => deps.worker.eraseCreated(own));
+      counts.documents = creators.count;
+      counts.unread = creators.unread.length;
+    }
+    return counts;
+  }
+};
+export {
+  commentsAccount
+};

package/dist/{chunk-6MS4LASK.js → chunk-4G5BDTBA.js}

@@ -1,16 +1,13 @@
 // src/errors.ts
 var CommentsError = class extends Error {
-  constructor(code, message) {
-    super(message);
+  constructor(code, message, options) {
+    super(message, options);
     this.code = code;
     this.name = "CommentsError";
   }
   code;
 };
 
-// src/anchor.ts
-import * as Y from "yjs";
-
 // src/text.ts
 var HIDDEN = /[\p{Cc}\p{Cf}]/u;
 var ID = /^[\w-]{1,64}$/;
@@ -21,6 +18,7 @@ var shown = (value) => JSON.stringify(safeId(value));
 var safeText = (value) => String(value).replace(/[^\p{L}\p{N}\p{P}\p{S} ]/gu, "?").slice(0, 200);
 
 // src/anchor.ts
+import * as Y from "yjs";
 var MAX_QUOTE = 2e3;
 var MAX_ANCHOR = 4096;
 var MAX_KEY = 256;
@@ -1020,6 +1018,7 @@ var Suggestions = class {
 
 export {
   CommentsError,
+  shown,
   textOf,
   textAnchor,
   textRange,
@@ -1027,6 +1026,7 @@ export {
   ERASED_NAME,
   Actor,
   stamp,
+  assertActor,
   readAuthor,
   authorLabel,
   invalid,

package/dist/{chunk-EFO5PSJL.js → chunk-6UQ6CDLJ.js}

@@ -1,6 +1,6 @@
 // src/version.ts
 import { createRequire } from "module";
-var VERSION = true ? "0.7.0" : readPackageVersion();
+var VERSION = true ? "0.8.0" : readPackageVersion();
 
 export {
   VERSION

package/dist/{chunk-OV2GGL3T.js → chunk-J6JGWDUP.js}

@@ -1,12 +1,12 @@
 import {
   VERSION
-} from "./chunk-EFO5PSJL.js";
+} from "./chunk-6UQ6CDLJ.js";
 import {
   CommentsService
-} from "./chunk-B7LTOLUO.js";
+} from "./chunk-TTNT27PG.js";
 import {
   CommentsError
-} from "./chunk-6MS4LASK.js";
+} from "./chunk-4G5BDTBA.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/{chunk-M77Q5CWI.js → chunk-LFYTCHXS.js}

@@ -2,7 +2,7 @@ import {
   CommentsError,
   PRINCIPAL_KINDS,
   stamp
-} from "./chunk-6MS4LASK.js";
+} from "./chunk-4G5BDTBA.js";
 
 // src/file-store.ts
 import { createHash } from "crypto";

package/dist/{chunk-B7LTOLUO.js → chunk-TTNT27PG.js}

@@ -7,7 +7,7 @@ import {
   textAnchor,
   textOf,
   textRange
-} from "./chunk-6MS4LASK.js";
+} from "./chunk-4G5BDTBA.js";
 
 // src/local-host.ts
 import * as Y from "yjs";

package/dist/cli.js

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 import {
   VERSION
-} from "./chunk-EFO5PSJL.js";
+} from "./chunk-6UQ6CDLJ.js";
 import {
   FileStore,
   lockTimeoutFrom,
   operatorActor
-} from "./chunk-M77Q5CWI.js";
+} from "./chunk-LFYTCHXS.js";
 import {
   CommentsService,
   TEXT_ROOT
-} from "./chunk-B7LTOLUO.js";
+} from "./chunk-TTNT27PG.js";
 import {
   CommentsError
-} from "./chunk-6MS4LASK.js";
+} from "./chunk-4G5BDTBA.js";
 
 // src/cli.ts
 import { readFileSync, realpathSync } from "fs";
@@ -178,7 +178,7 @@ async function runCli(argv, io) {
       return 0;
     }
     if (p.command === "mcp") {
-      const { startMcp } = await import("./mcp-LP3X55C2.js");
+      const { startMcp } = await import("./mcp-IFQQHOA2.js");
       await startMcp(store, operatorActor(p.flags["--as"] ?? io.env.AGENTIC_COMMENTS_AS, io.env.AGENTIC_COMMENTS_SCOPES));
       return 0;
     }

package/dist/client.d.ts

@@ -1,8 +1,8 @@
-import { L as ListFilter, A as AnchorSpec } from './service-BvIE6t5n.js';
-import { C as CommentsErrorCode } from './errors-C-xvp24-.js';
+import { L as ListFilter, A as AnchorSpec } from './service-ZdZPWrwI.js';
+import { C as CommentsErrorCode } from './errors-Cin-719h.js';
 import { PrincipalKind } from 'agentic-identity';
 export { PrincipalKind } from 'agentic-identity';
-import { T as Thread, N as NewReply, M as Message, P as PersonExport, a as PersonSuggestions, S as Suggestion } from './suggestions-CnkEcTuY.js';
+import { T as Thread, N as NewReply, M as Message, P as PersonExport, a as PersonSuggestions, S as Suggestion } from './suggestions-G1seGf5d.js';
 import 'yjs';
 
 /** Codes the comment rules return, plus the ones the Worker and its auth return. */

package/dist/{errors-C-xvp24-.d.ts → errors-Cin-719h.d.ts}

@@ -1,7 +1,9 @@
 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);
+    constructor(code: CommentsErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
 }
 
 export { type CommentsErrorCode as C, CommentsError as a };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-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';
+import { b as Author, C as Comments, c as Suggestions } from './suggestions-G1seGf5d.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-G1seGf5d.js';
+export { a as CommentsError, C as CommentsErrorCode } from './errors-Cin-719h.js';
 export { PRINCIPAL_KINDS, PrincipalKind } from 'agentic-identity';
 import 'yjs';
 

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-EFO5PSJL.js";
+} from "./chunk-6UQ6CDLJ.js";
 import {
   ACCEPT_SCOPE,
   Actor,
@@ -17,7 +17,7 @@ import {
   textAnchor,
   textOf,
   validDate
-} from "./chunk-6MS4LASK.js";
+} from "./chunk-4G5BDTBA.js";
 
 // src/notifications.ts
 import * as Y from "yjs";

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-BvIE6t5n.js';
-import { u as SuggestionHost, A as Actor } from './suggestions-CnkEcTuY.js';
+export { A as AnchorSpec, C as CommentsService, L as ListFilter } from './service-ZdZPWrwI.js';
+import { u as SuggestionHost, A as Actor } from './suggestions-G1seGf5d.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-M77Q5CWI.js";
+} from "./chunk-LFYTCHXS.js";
 import {
   CommentsService,
   TEXT_ROOT,
   VALUES_ROOT,
   localHost
-} from "./chunk-B7LTOLUO.js";
-import "./chunk-6MS4LASK.js";
+} from "./chunk-TTNT27PG.js";
+import "./chunk-4G5BDTBA.js";
 export {
   CommentsService,
   FileStore,

package/dist/mcp-IFQQHOA2.js

@@ -0,0 +1,11 @@
+import {
+  createMcpServer,
+  startMcp
+} from "./chunk-J6JGWDUP.js";
+import "./chunk-6UQ6CDLJ.js";
+import "./chunk-TTNT27PG.js";
+import "./chunk-4G5BDTBA.js";
+export {
+  createMcpServer,
+  startMcp
+};

package/dist/mcp-bin.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import {
   startMcp
-} from "./chunk-OV2GGL3T.js";
+} from "./chunk-J6JGWDUP.js";
 import {
   VERSION
-} from "./chunk-EFO5PSJL.js";
+} from "./chunk-6UQ6CDLJ.js";
 import {
   FileStore,
   lockTimeoutFrom,
   operatorActor
-} from "./chunk-M77Q5CWI.js";
-import "./chunk-B7LTOLUO.js";
-import "./chunk-6MS4LASK.js";
+} from "./chunk-LFYTCHXS.js";
+import "./chunk-TTNT27PG.js";
+import "./chunk-4G5BDTBA.js";
 
 // src/mcp-bin.ts
 var MCP_HELP = `agentic-comments-mcp ${VERSION}

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

@@ -1,5 +1,5 @@
 import * as Y from 'yjs';
-import { A as Actor, T as Thread, M as Message, P as PersonExport, a as PersonSuggestions, S as Suggestion } from './suggestions-CnkEcTuY.js';
+import { A as Actor, T as Thread, M as Message, P as PersonExport, a as PersonSuggestions, S as Suggestion } from './suggestions-G1seGf5d.js';
 
 /** Where a comment or suggestion points, in terms a person or agent can write down. */
 type AnchorSpec = {

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

@@ -383,11 +383,14 @@ interface SuggestionFilter {
  * with the accept scope that did not write it, accepts. Accept and reject are safe across replicas.
  */
 declare class Suggestions {
-    private readonly comments;
+    /** The threads these suggestions anchor to. */
+    readonly comments: Comments;
     private readonly host;
     private readonly onTransaction;
     private failures;
-    constructor(comments: Comments, host: SuggestionHost);
+    constructor(
+    /** The threads these suggestions anchor to. */
+    comments: Comments, host: SuggestionHost);
     /** Stop listening to the document. */
     close(): void;
     private get ydoc();

package/dist/ui.d.ts

@@ -1,10 +1,10 @@
 import * as react from 'react';
 import { CommentsClient, Me } from './client.js';
 export { createClient } from './client.js';
-import { b as Author, S as Suggestion } from './suggestions-CnkEcTuY.js';
-import './service-BvIE6t5n.js';
+import { b as Author, S as Suggestion } from './suggestions-G1seGf5d.js';
+import './service-ZdZPWrwI.js';
 import 'yjs';
-import './errors-C-xvp24-.js';
+import './errors-Cin-719h.js';
 import 'agentic-identity';
 
 /** The calls the panel makes. A `CommentsClient` fits, and so does any object with these methods. */

package/dist/worker.d.ts

@@ -2,8 +2,9 @@ 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-CnkEcTuY.js';
-import { C as CommentsService } from './service-BvIE6t5n.js';
+import { CommentsAccountDocument } from './account.js';
+import { A as Actor, b as Author } from './suggestions-G1seGf5d.js';
+import { C as CommentsService } from './service-ZdZPWrwI.js';
 import 'yjs';
 
 interface WorkerEnv {
@@ -36,6 +37,29 @@ declare class CommentsDocs {
     create(id: string, text: string, actor: Actor): Promise<void>;
     read<T>(id: string, actor: Actor, run: (service: CommentsService) => T): Promise<T>;
     write<T>(id: string, actor: Actor, run: (service: CommentsService) => T): Promise<T>;
+    /** For the account plug-in: the id of each stored document. */
+    accountDocumentIds(): Promise<string[]>;
+    private ids;
+    /**
+     * For the account plug-in: runs `fn` on each stored document, with its `Comments` and `Suggestions`. With `save`,
+     * each document runs in one transaction and the state is written back there. A throw leaves it as it was. A document deleted since the list was read is skipped.
+     * A damaged document stops the run with CORRUPT.
+     */
+    eachAccountDocument(fn: (doc: CommentsAccountDocument) => void, save: boolean, committed?: (id: string) => void): Promise<void>;
+    private scan;
+    /** The documents this subject created: the creator is kept on the row. For the account plug-in. */
+    exportCreated(author: Author): Promise<{
+        documents: {
+            documentId: string;
+            createdAt: unknown;
+        }[];
+        unread: string[];
+    }>;
+    /** Give the creator of each document this subject made the tombstone name. Returns how many, and the rows it could not read. A repeat finds none. */
+    eraseCreated(author: Author): Promise<{
+        count: number;
+        unread: string[];
+    }>;
 }
 /** The docs, or a function that makes them from the Worker bindings. */
 type DocsSource = CommentsDocs | ((env: WorkerEnv) => Promise<CommentsDocs>);

package/dist/worker.js

@@ -1,15 +1,20 @@
 import {
   CommentsService,
-  TEXT_ROOT
-} from "./chunk-B7LTOLUO.js";
+  TEXT_ROOT,
+  localHost
+} from "./chunk-TTNT27PG.js";
 import {
   ACCEPT_SCOPE,
+  Comments,
   CommentsError,
+  ERASED_NAME,
   MODERATE_SCOPE,
+  Suggestions,
   exact,
   invalid,
+  readAuthor,
   stamp
-} from "./chunk-6MS4LASK.js";
+} from "./chunk-4G5BDTBA.js";
 
 // src/worker.ts
 import { Hono } from "hono";
@@ -150,6 +155,89 @@ var CommentsDocs = class {
       return result;
     });
   }
+  /** For the account plug-in: the id of each stored document. */
+  async accountDocumentIds() {
+    return this.ids();
+  }
+  async ids() {
+    const ids = [];
+    let cursor;
+    do {
+      const page = await this.store.query(DOCS, { limit: 100, ...cursor ? { cursor } : {} });
+      for (const { id } of page.items) ids.push(id);
+      cursor = page.nextCursor;
+    } while (cursor);
+    return ids;
+  }
+  /**
+   * For the account plug-in: runs `fn` on each stored document, with its `Comments` and `Suggestions`. With `save`,
+   * each document runs in one transaction and the state is written back there. A throw leaves it as it was. A document deleted since the list was read is skipped.
+   * A damaged document stops the run with CORRUPT.
+   */
+  async eachAccountDocument(fn, save, committed) {
+    const open = (id, row) => {
+      const ydoc = this.load(row, id);
+      ydoc.getText(TEXT_ROOT);
+      const comments = new Comments(ydoc);
+      return { ydoc, doc: { id, comments, suggestions: new Suggestions(comments, localHost) } };
+    };
+    for (const id of await this.ids()) {
+      if (!save) {
+        const row = await this.store.get(DOCS, id);
+        if (row !== null) fn(open(id, row).doc);
+        continue;
+      }
+      const wrote = await this.store.transaction(async (tx) => {
+        const row = await tx.get(DOCS, id);
+        if (row === null) return false;
+        const { ydoc, doc } = open(id, row);
+        fn(doc);
+        const state = Y.encodeStateAsUpdate(ydoc);
+        if (state.length > MAX_STATE) throw new CommentsError("STORE_FULL", `document "${id}" would pass ${MAX_STATE} bytes of state`);
+        await tx.put(DOCS, id, { state: toBase64(state), createdBy: row?.createdBy ?? null, createdAt: row?.createdAt ?? null });
+        return true;
+      });
+      if (wrote) committed?.(id);
+    }
+  }
+  async scan(author, each, unread) {
+    let cursor;
+    do {
+      const page = await this.store.query(DOCS, { limit: 100, ...cursor ? { cursor } : {} });
+      for (const { id, data } of page.items) {
+        const raw = data?.createdBy;
+        const by = readAuthor(raw);
+        if (!by && raw !== null && raw !== void 0) unread?.push(id);
+        else if (by && by.kind === author.kind && by.name === author.name) await each(id, data);
+      }
+      cursor = page.nextCursor;
+    } while (cursor);
+  }
+  /** The documents this subject created: the creator is kept on the row. For the account plug-in. */
+  async exportCreated(author) {
+    const documents = [];
+    const unread = [];
+    await this.scan(author, async (id, row) => void documents.push({ documentId: id, createdAt: row.createdAt ?? null }), unread);
+    return { documents, unread };
+  }
+  /** Give the creator of each document this subject made the tombstone name. Returns how many, and the rows it could not read. A repeat finds none. */
+  async eraseCreated(author) {
+    const ids = [];
+    const unread = [];
+    await this.scan(author, async (id) => void ids.push(id), unread);
+    let count = 0;
+    for (const id of ids) {
+      const changed = await this.store.transaction(async (tx) => {
+        const row = await tx.get(DOCS, id);
+        const by = readAuthor(row?.createdBy);
+        if (!row || !by || by.kind !== author.kind || by.name !== author.name) return false;
+        await tx.put(DOCS, id, { ...row, createdBy: { kind: by.kind, name: ERASED_NAME } });
+        return true;
+      });
+      if (changed) count++;
+    }
+    return { count, unread };
+  }
 };
 var STATUS = {
   INVALID_AUTHOR: 400,

package/llms.txt

@@ -6,6 +6,7 @@ Keywords: comments,threads,mentions,suggestions,annotations,collaboration,agents
 
 - SDK: import { Comments, Suggestions, textAnchor } from "agentic-comments". The host calls stamp(); an agent never does.
 - Plain text anchors: import { createAnchor, resolveAnchor, mapRange } from "agentic-comments/anchor". No Yjs. resolveAnchor maps through edits, then falls back to quote + context, else orphaned.
+- Account export and erase: import { commentsAccount } from "agentic-comments/account". exportAccount(subject, { documents, actor }) returns JSON records of one subject (pass worker: docs to cover every stored worker document and its creator). eraseAccount tombstones them and returns counts. The actor is made with stamp() and names the subject.
 - Threads live on a Yjs document and merge across replicas.
 - Lifecycle: comments.editMessage, deleteMessage, deleteThread, exportPerson, erasePerson (and the same on the CLI, MCP, HTTP API, and client). Only the author may change their own messages; comments:moderate may change anyone's.
 - React panel: import { CommentsPanel, createClient, mayDecide } from "agentic-comments/ui" and "agentic-comments/ui.css" (with agentic-design/styles.css). Threads, quotes, replies, resolve and reopen, agent badge, accept and reject. An agent never decides its own suggestion. Peer: react, react-dom.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-comments",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Comment threads and suggestions anchored to any content, from people and agents.",
   "keywords": [
     "comments",
@@ -44,6 +44,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./account": {
+      "types": "./dist/account.d.ts",
+      "import": "./dist/account.js"
+    },
     "./anchor": {
       "types": "./dist/anchoring.d.ts",
       "import": "./dist/anchoring.js"

package/dist/mcp-LP3X55C2.js

@@ -1,11 +0,0 @@
-import {
-  createMcpServer,
-  startMcp
-} from "./chunk-OV2GGL3T.js";
-import "./chunk-EFO5PSJL.js";
-import "./chunk-B7LTOLUO.js";
-import "./chunk-6MS4LASK.js";
-export {
-  createMcpServer,
-  startMcp
-};