agentic-comments 0.5.0 → 0.6.0

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-HXXJNFEO.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-HXXJNFEO.js";
+} from "./chunk-2NBFTJ47.js";
 import {
   startMcp
-} from "./chunk-ABXAPWXD.js";
+} from "./chunk-SR2A5OZW.js";
 import {
   VERSION
-} from "./chunk-WQHJNHAR.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

@@ -1,8 +1,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-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 {
@@ -12,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 bytes or more) to `kind:name`, 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;
@@ -25,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;
@@ -37,8 +40,13 @@ 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"];
 }
 type AppEnv = {
     Bindings: WorkerEnv;

package/dist/worker.js

@@ -1,19 +1,20 @@
 import {
   CommentsService,
   TEXT_ROOT
-} from "./chunk-NQWRFKJ6.js";
+} from "./chunk-T77DPNIV.js";
 import {
   ACCEPT_SCOPE,
   CommentsError,
-  PRINCIPAL_KINDS,
+  MODERATE_SCOPE,
   exact,
   invalid,
   stamp
-} from "./chunk-BSNBDKR2.js";
+} from "./chunk-VAVKBAHM.js";
 
 // src/worker.ts
 import { Hono } from "hono";
-import { StoreConflictError, assertRegion, isScope, parseRegion, hasScope } from "agentic-identity";
+import { StoreConflictError, assertRegion, createStoreAuth, isScope, parseRegion, hasScope, parsePrincipal } from "agentic-identity";
+import { requirePrincipal } from "agentic-identity/http";
 import { D1_SCHEMA, createD1Store } from "agentic-identity/cloudflare";
 import * as Y from "yjs";
 var READ = "comments:read";
@@ -22,6 +23,7 @@ var WRITE = "comments:write";
 var ADMIN = "comments:admin";
 var DEFAULT_SCOPES = [COMMENT];
 var MIN_TOKEN_BYTES = 32;
+var TOKEN_SHAPE = /^[A-Za-z0-9_-]{1,512}$/;
 var warned = /* @__PURE__ */ new Set();
 function refuse(reason) {
   if (!warned.has(reason)) {
@@ -40,9 +42,13 @@ function contextOf(entry) {
   const who = typeof entry === "string" ? entry : object?.as;
   const cut = typeof who === "string" ? who.indexOf(":") : -1;
   if (typeof who !== "string" || cut < 1 || cut === who.length - 1) return void 0;
-  const kind = who.slice(0, cut);
-  const name = who.slice(cut + 1);
-  if (!PRINCIPAL_KINDS.includes(kind)) return void 0;
+  let kind;
+  let name;
+  try {
+    ({ kind, id: name } = parsePrincipal({ kind: who.slice(0, cut), id: who.slice(cut + 1) }));
+  } catch {
+    return void 0;
+  }
   const given = object?.scopes;
   if (given !== void 0 && !(Array.isArray(given) && given.every(isScope))) return void 0;
   try {
@@ -61,6 +67,7 @@ function createTokenAuth(raw) {
     for (const [token, entry] of Object.entries(parsed)) {
       const context = contextOf(entry);
       if (new TextEncoder().encode(token).length < MIN_TOKEN_BYTES) throw new Error(`a token is shorter than ${MIN_TOKEN_BYTES} bytes`);
+      if (!TOKEN_SHAPE.test(token)) throw new Error("a token holds a character outside A-Z a-z 0-9 _ - or is over 512 bytes");
       if (!context) throw new Error("an entry is not a valid kind:name or { as, scopes }");
       table.set(token, context);
     }
@@ -80,7 +87,7 @@ function createTokenAuth(raw) {
   };
 }
 function actorOf(context) {
-  const scopes = hasScope(context.scopes, ADMIN) ? [ACCEPT_SCOPE] : [];
+  const scopes = hasScope(context.scopes, ADMIN) ? [ACCEPT_SCOPE, MODERATE_SCOPE] : [];
   return stamp({ kind: context.kind, name: context.principalId, scopes });
 }
 var DOCS = "comments_docs";
@@ -149,6 +156,7 @@ var STATUS = {
   INVALID_INPUT: 400,
   INVALID_ANCHOR: 400,
   NO_THREAD: 404,
+  NO_MESSAGE: 404,
   NO_SUGGESTION: 404,
   NO_DOCUMENT: 404,
   THREAD_RESOLVED: 409,
@@ -185,9 +193,33 @@ function createApp(source, options = {}) {
   });
   app2.get("/health", (c) => c.json({ ok: true, pack: "agentic-comments" }));
   app2.use("/api/v1/*", async (c, next) => {
-    const auth = typeof options.auth === "function" ? options.auth(c.env ?? {}) : options.auth ?? createTokenAuth(c.env?.AGENTIC_COMMENTS_TOKENS);
-    const context = await auth.authenticate(c.req.raw);
-    if (!context) return fail("UNAUTHENTICATED", "send a valid bearer token", 401);
+    let auth;
+    if (typeof options.auth === "function") auth = options.auth(c.env ?? {});
+    else if (options.auth) auth = options.auth;
+    else {
+      const staticOn = c.env?.AGENTIC_COMMENTS_UNSAFE_STATIC_TOKENS === "1";
+      if (c.env?.AGENTIC_COMMENTS_TOKENS && !staticOn) {
+        return fail("NOT_CONFIGURED", "AGENTIC_COMMENTS_TOKENS is a dev fallback. Set AGENTIC_COMMENTS_UNSAFE_STATIC_TOKENS=1 to use it, or remove it and issue agentic-identity credentials", 503);
+      }
+      const store = (await docsOf(c)).store;
+      const auths = [createStoreAuth(store)];
+      if (staticOn) auths.push(createTokenAuth(c.env?.AGENTIC_COMMENTS_TOKENS));
+      auth = {
+        async authenticate(request) {
+          for (const each of auths) {
+            const found = await each.authenticate(request);
+            if (found) return found;
+          }
+          return null;
+        }
+      };
+    }
+    const context = await requirePrincipal(c.req.raw, auth, { origins: options.origins, scope: READ });
+    if (context instanceof Response) {
+      if (context.status === 401) return Response.json({ error: { code: "UNAUTHENTICATED", message: "send a valid bearer token" } }, { status: 401, headers: { "www-authenticate": "Bearer" } });
+      if (context.status === 403) return fail("FORBIDDEN", "this credential may not do this", 403);
+      return fail("INTERNAL", "the credential check is unavailable", context.status);
+    }
     c.set("context", context);
     await next();
   });
@@ -227,6 +259,14 @@ function createApp(source, options = {}) {
   for (const action of ["resolve", "reopen"]) {
     app2.post(`${doc}/threads/:id/${action}`, (c) => act(c, COMMENT, true, (s) => s[action](c.req.param("id"))));
   }
+  app2.patch(`${doc}/threads/:id/messages/:message`, async (c) => {
+    const input = await body(c);
+    return act(c, COMMENT, true, (s) => s.editMessage(c.req.param("id"), c.req.param("message"), input));
+  });
+  app2.delete(`${doc}/threads/:id/messages/:message`, (c) => act(c, COMMENT, true, (s) => s.deleteMessage(c.req.param("id"), c.req.param("message"))));
+  app2.delete(`${doc}/threads/:id`, (c) => act(c, COMMENT, true, (s) => s.deleteThread(c.req.param("id"))));
+  app2.get(`${doc}/people/:name/export`, (c) => act(c, READ, false, (s) => s.exportPerson(c.req.param("name"))));
+  app2.delete(`${doc}/people/:name`, (c) => act(c, COMMENT, true, (s) => s.erasePerson(c.req.param("name"))));
   app2.post(`${doc}/threads/:id/relocate`, (c) => act(c, WRITE, true, (s) => s.relocate(c.req.param("id"))));
   app2.get(`${doc}/suggestions`, (c) => act(c, READ, false, (s) => s.suggestions(c.req.query())));
   app2.post(`${doc}/suggestions`, async (c) => {

package/llms.txt

@@ -7,6 +7,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.
 - 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.
 - Events: new Notifications(comments, suggestions).subscribe(listener). Ids only, never text.
 - CLI: agentic-comments <command>. MCP: agentic-comments mcp. Both use a local store file.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-comments",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Comment threads and suggestions anchored to any content, from people and agents.",
   "keywords": [
     "comments",
@@ -76,7 +76,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.2",
-    "agentic-identity": "^0.4.0",
+    "agentic-identity": "^0.7.0",
     "hono": "^4.13.14",
     "zod": "^3.25.76"
   },

package/dist/errors-CNgWMVQT.d.ts

@@ -1,7 +0,0 @@
-type CommentsErrorCode = "INVALID_AUTHOR" | "INVALID_INPUT" | "INVALID_ANCHOR" | "NO_THREAD" | "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/mcp-JMEXA2RI.js

@@ -1,11 +0,0 @@
-import {
-  createMcpServer,
-  startMcp
-} from "./chunk-ABXAPWXD.js";
-import "./chunk-WQHJNHAR.js";
-import "./chunk-NQWRFKJ6.js";
-import "./chunk-BSNBDKR2.js";
-export {
-  createMcpServer,
-  startMcp
-};