agentic-comments 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pooria Arab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,178 @@
-# Temporary Holding Version
+# agentic-comments
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![MIT license](https://img.shields.io/badge/license-MIT-blue)](https://opensource.org/license/mit)
+
+[Source](https://github.com/pooriaarab/agentic-comments) · [Support](https://github.com/pooriaarab/agentic-comments/issues)
+
+Comment threads and suggestions anchored to any content, from people and agents.
+
+> Status: first release, 0.1.0. Threads, suggestions, and anchor survival work. The CLI, the MCP
+> server, and notifications come next.
+
+## Install
+
+Requires Node.js 20 or later. The quick start imports `yjs`, so install it with this package:
+
+```sh
+npm install agentic-comments yjs
+```
+
+To build from source, see Develop.
+
+## Quick start
+
+```ts
+import * as Y from "yjs";
+import { Comments, stamp, textAnchor } from "agentic-comments";
+
+const doc = new Y.Doc();
+doc.getText("body").insert(0, "Hello brave world");
+
+const comments = new Comments(doc);
+const ada = stamp({ kind: "human", name: "ada" });
+const scribe = stamp({ kind: "agent_of_human", name: "scribe" });
+
+const thread = comments.add({ anchor: textAnchor(doc.getText("body"), 6, 11), body: "Word choice? @scribe" }, ada);
+comments.reply(thread.id, { body: "I suggest a shorter word." }, scribe);
+comments.resolve(thread.id, ada);
+```
+
+The `Comments` object lives on a Yjs document. Send the document updates with your
+normal sync, and every replica sees the same threads.
+
+## Features
+
+- Threads anchored to a text range, a cell key, a slide element, or a canvas element.
+  You can add your own anchor type.
+- A text anchor uses Yjs relative positions, so it follows its text through edits.
+- Messages with mentions. Resolve and reopen a thread.
+- Suggestions: a change your app proposes. A person, or an agent with the accept scope, accepts it.
+  An agent never accepts or rejects its own. Two replicas that accept at once apply it once.
+- The host stamps every author. An operation never reads an author from its input.
+- Every message keeps the author kind, so agent comments stay marked as machine-made.
+- Replies and status merge across replicas. Two replicas that resolve at once agree.
+- A malformed thread from a bad replica is skipped. A bad message is left out, and `skipped` on the
+  thread counts those. `problems()` names them.
+
+## When the content changes
+
+Every thread and suggestion has an `anchorState`:
+
+| State | Meaning |
+| --- | --- |
+| `attached` | The content is there, as it was. |
+| `edited` | A text range is there, with other text. `currentText` shows it. |
+| `orphaned` | The content is gone. The thread stays readable and takes replies. |
+| `unknown` | Nothing can tell. A cell, slide, canvas, or custom anchor has no host answer. |
+
+- A text anchor follows its text through edits by any replica. Deleting the whole range orphans it.
+- For other anchors, pass `exists(anchor)` to `new Comments`. Return `true` or `false`. Any other answer,
+  or a throw, means `unknown`.
+- `list({ anchorState: "orphaned" })` finds threads to review.
+- `relocate(threadId, actor)` moves a text anchor to its quote when the quote occurs exactly once in the
+  same text. It never guesses. It throws `RELOCATE_FAILED` for no match or many.
+- Accept refuses a suggestion whose anchor is orphaned or edited. The suggestion stays pending, and a
+  person can reject it.
+- `currentText` is document text. It can hold any character, so a UI should treat it as untrusted.
+
+## Suggestions
+
+Your app owns the change. This package stores it as JSON, tracks the decision, and calls your `apply`.
+
+```ts
+import { ACCEPT_SCOPE, Suggestions } from "agentic-comments";
+
+const suggestions = new Suggestions(comments, {
+  apply(change, { anchor, by, ydoc }) {
+    // Edit ydoc here. Throw before you edit when the change cannot apply.
+    return { /* a receipt, JSON that lets revert undo this edit */ };
+  },
+  revert(receipt, { ydoc }) {
+    // Undo a duplicate edit. Every replica runs this at once, so use an edit that merges to one result.
+    // Throw before you change anything.
+  },
+});
+
+const s = suggestions.add({ anchor, change: { replacement: "bold" }, summary: "Word choice" }, scribe);
+suggestions.accept(s.id, ada);
+```
+
+- A signed-in person (`human`) accepts or rejects. Every other kind, including `user_token`, needs the
+  `comments:accept` scope, and never decides a suggestion it wrote. Names match exactly, in Unicode NFC form (a name in another form is refused), and two
+  principals that are not signed-in people with the same name count as one, whatever their kinds.
+- Accept checks that a text anchor still matches the document, then runs the edit and writes the
+  record in one step. If `apply` throws before it edits, the suggestion stays pending. If it edits and
+  then fails, the decision is recorded without a receipt, and `problems()` reports it. A host that cannot undo a double apply must say `idempotent: true`.
+- Every replica of a document must use the same host mode: the same `revert`, or the same `idempotent`
+  flag. A mix can leave a duplicate edit in the document.
+- `problems()` entries about an edit that failed after it landed, or a duplicate with no receipt, live in
+  memory on the replica that saw them. Other replicas and a reload do not show them.
+- A decision by an agent with the accept scope is final for everyone, including people.
+- An accept on a replica that has not yet seen a reject wins, even when a person made the reject long before.
+  The window is any time the replicas were apart. An agent with the scope can override a person this way.
+  A host that wants the person to win can accept only while its replica is in sync.
+- Two replicas that accept before they meet each apply the edit. After the merge, the application of
+  the lowest client id stays and `revert` undoes each other one. An accept and a reject at once end as
+  accepted.
+- A receipt is stored data. A peer that can write comment data can choose one, and can rewrite the
+  `anchor` to match. Check the receipt in `revert` before you use it. The sync layer's write control is
+  the real protection. A record with no receipt (an `apply` that edited and
+  then failed) always stays, and the other application is undone. If two records have none, the extra
+  edit cannot be undone. `problems()` reports it. With `idempotent: true`, a duplicate is never undone.
+- `apply` and `revert` must be synchronous, and must edit only the Yjs document. `accept` cannot run
+  inside another Yjs transaction, so not inside an observer or an `apply`.
+- A peer that can write the document can write a decision record. Records with a bad author, time, or
+  receipt, or from a decider who wrote the suggestion as an agent, are not counted. A well-formed forged
+  record is, and it can win settle, so every replica undoes the real edit. The sync layer must decide who
+  may write.
+
+## Author kinds
+
+| Kind | Meaning | Label |
+| --- | --- | --- |
+| `human` | A person signed in. | person |
+| `user_token` | A person, through a token an agent holds. | person via agent |
+| `agent_of_human` | An agent that acts for a person. | agent |
+| `agent_of_agent` | An agent that acts for another agent. | agent |
+| `agent` | An agent with its own identity. | agent |
+
+## Limits
+
+- No file store, CLI, MCP server, or HTTP API yet.
+- `add` checks that a text anchor points into this document and matches its quote.
+- The library trusts the host to call `stamp()` only for a principal it authenticated.
+- A reply to a resolved thread is refused on the replica that sees the resolve. A reply and a
+  resolve made at once on two replicas both stay. The merged thread is resolved and holds the reply.
+- Author and kind are only as trustworthy as every peer that can write the document. A peer can write
+  any author straight into the Yjs data. The sync layer must decide who may write.
+- `relocate` and `exists` never touch a thread whose anchor is attached. `exists` runs for every thread
+  on every read, so keep it fast.
+- A local reply stops at 1,000 messages. Replicas that reply at once can pass that. A read shows the first
+  2,000 valid messages. `skipped` and `problems()` report the rest.
+- Every replica of a document must register the same custom anchor kinds.
+- A repeated message id hides every copy. A peer that appends a copy of a thread's only message makes
+  the thread unreadable.
+- The quoted text of a text anchor is not checked when a thread is read. A peer can store any text there.
+  `textAnchor` refuses a quote whose JSON form passes 4,096 characters. Quotes with many newlines or
+  quotation marks hit that before 2,000 characters.
+- The first visible message decides when a thread started, so a peer that inserts an older message at
+  the front moves the thread in `list()`.
+- A read scans every stored entry. A peer that writes millions of junk entries slows every read.
+- A body mentions anyone named as `@handle`. Put `@` text in backticks to avoid that. Any two backticks in a body pair up, so a loose backtick
+  can hide a real mention that sits between two of them. A scoped
+  package name such as `@scope/pkg` is not a mention.
+- Mentions are stored in lowercase, with no leading `@`. A handle holds up to 64 letters, digits, marks,
+  and `. _ -`. A longer handle in a body is refused.
+
+## Develop
+
+```sh
+git clone https://github.com/pooriaarab/agentic-comments
+cd agentic-comments
+npm ci
+npm run ci:local
+```
+
+## License
+
+MIT.

package/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: agentic-comments
+description: Comment threads and suggestions anchored to any content, from people and agents. Keywords: comments,threads,mentions,suggestions,annotations,collaboration,agents,yjs.
+---
+
+# agentic-comments
+
+Comment threads and suggestions anchored to any content, from people and agents.
+
+## Use the SDK
+
+The host gives you an `Actor` that names you. Pass it to each call.
+
+```ts
+import { Comments } from "agentic-comments";
+
+const comments = new Comments(ydoc);
+const thread = comments.add({ anchor: { type: "cell", key: "Sheet1!B4" }, body: "Check this total." }, actor);
+comments.reply(thread.id, { body: "Fixed." }, actor);
+```
+
+Check `thread.anchorState`. An `orphaned` thread has lost its content. Read it, reply, or call
+`comments.relocate(id, actor)`. Do not treat it as bad data.
+
+Suggest a change with `suggestions.add({ anchor, change, summary }, actor)`. Accept needs a person or
+the `comments:accept` scope. You never accept or reject your own suggestion.
+
+The CLI and the MCP server are not built yet.
+
+## Rules
+
+- The host stamps the author. Never call `stamp()` yourself, and never pass an author in an input.
+- Reopen a resolved thread before you reply.
+- Report refusals and errors as failures.

package/dist/index.d.ts

@@ -0,0 +1,332 @@
+import * as Y from 'yjs';
+
+declare const VERSION: string;
+
+/** A Yjs relative position as JSON. It names an item, not an index, so it follows its text. */
+interface RelativePositionJson {
+    type?: {
+        client: number;
+        clock: number;
+    };
+    tname?: string;
+    item?: {
+        client: number;
+        clock: number;
+    };
+    assoc?: number;
+}
+interface TextAnchor {
+    type: "text";
+    /** The text under the range when the comment was made. `Comments.add` checks it against the document. */
+    text: string;
+    start: RelativePositionJson;
+    end: RelativePositionJson;
+}
+interface CellAnchor {
+    type: "cell";
+    /** A cell key the host app defines, such as `Sheet1!B4` or a stable cell id. */
+    key: string;
+}
+interface SlideAnchor {
+    type: "slide";
+    elementId: string;
+}
+interface CanvasAnchor {
+    type: "canvas";
+    elementId: string;
+}
+/**
+ * Where a thread points. A custom kind (see `AnchorKind`) returns its own shape, so narrow on `type`
+ * before you read its fields.
+ */
+type Anchor = TextAnchor | CellAnchor | SlideAnchor | CanvasAnchor;
+/** Teach `Comments` a new anchor type. `parse` returns a clean copy or throws. */
+interface AnchorKind {
+    type: string;
+    parse(raw: Record<string, unknown>): {
+        type: string;
+    };
+}
+/**
+ * Whether the content under an anchor is still there.
+ * `attached`: yes, as it was. `edited`: the range is there, with other text. `orphaned`: the content is
+ * gone. `unknown`: nothing can tell, as for a cell with no host answer.
+ */
+type AnchorState = {
+    state: "attached";
+} | {
+    state: "edited";
+    currentText: string;
+} | {
+    state: "orphaned";
+} | {
+    state: "unknown";
+};
+/** The text of a Yjs text type. An embed counts as one character, so indexes match Yjs positions. */
+declare function textOf(type: Y.Text | Y.XmlText): string;
+/** Pin a range of a Yjs text. Later edits by any replica do not move the anchor off its text. */
+declare function textAnchor(type: Y.Text | Y.XmlText, from: number, to: number): TextAnchor;
+
+declare const PRINCIPAL_KINDS: readonly ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
+type PrincipalKind = (typeof PRINCIPAL_KINDS)[number];
+/** What a thread keeps about who wrote a message. Scopes never reach storage. */
+interface Author {
+    kind: PrincipalKind;
+    name: string;
+}
+interface StampInput {
+    kind: PrincipalKind;
+    name: string;
+    /** Rights the host granted this principal, such as `comments:accept`. Used to decide, never stored. */
+    scopes?: string[];
+}
+/**
+ * The only author a write accepts. The host makes one from the principal it authenticated, and an
+ * operation never reads an author from its input. An object that `stamp()` did not make is refused,
+ * and a stamped one cannot change.
+ */
+declare class Actor implements Author {
+    readonly kind: PrincipalKind;
+    readonly name: string;
+    readonly scopes: readonly string[];
+    private constructor();
+    static of(input: StampInput): Actor;
+    static is(value: unknown): value is Actor;
+}
+/** Make the author for one authenticated principal. Throws when the kind or name is missing or wrong. */
+declare const stamp: (input: StampInput) => Actor;
+/** The label a UI shows. Agent work stays marked as machine-made. */
+declare function authorLabel(author: Author): "person" | "person via agent" | "agent";
+
+interface Message {
+    id: string;
+    at: string;
+    author: Author;
+    body: string;
+    /** Handles named in the body or listed on the input, without the `@`. */
+    mentions: string[];
+}
+interface Thread {
+    id: string;
+    anchor: Anchor;
+    status: "open" | "resolved";
+    /**
+     * The status change that won, and when. For a new thread, who opened it. Replicas that change the
+     * status at once agree on one change. Yjs picks it by client id, not by time.
+     */
+    statusBy: Author;
+    statusAt: string;
+    messages: Message[];
+    /** Whether the anchored content is still there. A thread whose content is gone stays readable. */
+    anchorState: AnchorState;
+    /** How many stored entries this read did not show: invalid ones, repeated ids, and valid ones past the read limit. `problems()` names them. */
+    skipped: number;
+}
+interface CommentsOptions {
+    now?: () => Date;
+    /** More anchor types. A type that is already built in is refused. */
+    anchors?: AnchorKind[];
+    /**
+     * Tell whether the content a cell, slide, canvas, or custom anchor points at still exists. Return `true`
+     * or `false`. Any other answer, or a throw, means unknown. Text anchors do not need it.
+     */
+    exists?: (anchor: Anchor) => boolean | undefined;
+}
+interface NewThread {
+    anchor: Anchor;
+    body: string;
+    mentions?: string[];
+}
+interface NewReply {
+    body: string;
+    mentions?: string[];
+}
+interface ThreadFilter {
+    status?: Thread["status"];
+    anchorType?: string;
+    /** A handle, with or without the `@`. */
+    mentioning?: string;
+    anchorState?: AnchorState["state"];
+}
+/** Comment threads on a Yjs document. Replies and status merge across replicas. */
+declare class Comments {
+    readonly ydoc: Y.Doc;
+    private readonly kinds;
+    private readonly now;
+    private readonly exists?;
+    /** Every replica of a document must register the same custom anchor kinds. Others read those threads as malformed. */
+    constructor(ydoc: Y.Doc, options?: CommentsOptions);
+    private get map();
+    /** The clock, as an ISO time. Used by `Suggestions`. */
+    time(): string;
+    /** Whether the content under an anchor is still there. This never throws. */
+    anchorState(anchor: Anchor): AnchorState;
+    /** Read an anchor from stored data. This does not check the document. */
+    parseAnchor(raw: unknown): Anchor;
+    /** Parse an anchor from input and check it against this document. Throws `INVALID_ANCHOR` when it fails. */
+    checkAnchor(raw: unknown): Anchor;
+    /** A text anchor must name text in this document, in order, and match its quote. */
+    private checkInDocument;
+    /** Build a message, and refuse it unless a read would show it back. Nothing is written yet. */
+    private message;
+    private readMessage;
+    /** A thread with a bad anchor or status is malformed. A bad message is skipped and named in `issues`. */
+    private read;
+    private fields;
+    /** Start a thread with its first message. The anchor and body are checked before anything is written. */
+    add(input: NewThread, actor: Actor): Thread;
+    /**
+     * Add a message. The resolved check runs on this replica only. A reply and a resolve made at once
+     * on two replicas both stay, and the merged thread is resolved with the reply in it.
+     */
+    reply(threadId: string, input: NewReply, actor: Actor): Message;
+    private setStatus;
+    /**
+     * Move a text anchor whose range is gone or edited to its quote, when the quote occurs exactly once in
+     * the same text. There is no fuzzy match. Throws `RELOCATE_FAILED` when it cannot say where. An attached
+     * thread is returned as it is.
+     */
+    relocate(threadId: string, actor: Actor): Thread;
+    resolve(threadId: string, actor: Actor): Thread;
+    reopen(threadId: string, actor: Actor): Thread;
+    get(threadId: string): Thread;
+    /** Threads in the order they were started. A malformed thread is skipped; `problems()` names it. */
+    list(filter?: ThreadFilter): Thread[];
+    /** Threads or messages that could not be read, for example from a replica that wrote bad data. */
+    problems(): {
+        id: string;
+        reason: string;
+    }[];
+    private readAll;
+}
+
+type CommentsErrorCode = "INVALID_AUTHOR" | "INVALID_INPUT" | "INVALID_ANCHOR" | "NO_THREAD" | "THREAD_RESOLVED" | "CORRUPT" | "NO_SUGGESTION" | "FORBIDDEN" | "ALREADY_DECIDED" | "APPLY_FAILED" | "RELOCATE_FAILED";
+declare class CommentsError extends Error {
+    readonly code: CommentsErrorCode;
+    constructor(code: CommentsErrorCode, message: string);
+}
+
+/** The scope that lets an agent accept or reject a suggestion that another principal wrote. */
+declare const ACCEPT_SCOPE = "comments:accept";
+interface Suggestion {
+    id: string;
+    anchor: Anchor;
+    /** Whether the anchored content is still there. Accept refuses an orphaned or edited one. */
+    anchorState: AnchorState;
+    /** What the host app proposes. This package never reads it. The host's `apply` does. */
+    change: unknown;
+    summary?: string;
+    author: Author;
+    createdAt: string;
+    status: "pending" | "accepted" | "rejected";
+    decidedBy?: Author;
+    decidedAt?: string;
+}
+interface ApplyContext {
+    suggestionId: string;
+    anchor: Anchor;
+    /** Who wrote the suggestion. */
+    author: Author;
+    /** Who accepts it. Label the edit with this author. */
+    by: Author;
+    ydoc: Y.Doc;
+}
+interface RevertContext {
+    suggestionId: string;
+    anchor: Anchor;
+    /** Who wrote the suggestion. */
+    author: Author;
+    /** Who made the application being undone. */
+    by: Author;
+    ydoc: Y.Doc;
+}
+/**
+ * The host app's side. Each hook is synchronous, so the check and the edit stay in one step.
+ * Make every edit in `ydoc`, so it merges with the rest.
+ */
+interface SuggestionHost {
+    /** Check a change when it is suggested. Return the clean change, or throw. */
+    parse?(change: unknown): unknown;
+    /**
+     * Make the edit. Throw before you change anything when the edit cannot apply, for example when the
+     * anchored content changed. Yjs cannot undo a partial edit. If `apply` edits and then fails, the
+     * decision is recorded as accepted with no receipt, and `problems()` reports it. Return a receipt,
+     * JSON data that lets `revert` undo this edit.
+     */
+    apply(change: unknown, context: ApplyContext): unknown;
+    /**
+     * Two replicas can accept one suggestion before they meet. Each applies the edit. After a merge one
+     * application stays and `revert` undoes each other. Every replica runs it at the same time, and the
+     * results must merge to one outcome, as a Yjs delete of the same range does. Throw before you change
+     * anything. A receipt comes from stored data. A peer that can write comment data can choose it, so
+     * check it before you use it. The anchor and the author are stored data too, so a check against them
+     * helps against a mistake and not against a peer that can write comment data.
+     */
+    revert?(receipt: unknown, context: RevertContext): void;
+    /** Say that applying the same change twice is harmless. Then `revert` is not needed, and a duplicate is not undone. */
+    idempotent?: boolean;
+}
+interface NewSuggestion {
+    anchor: Anchor;
+    change: unknown;
+    summary?: string;
+}
+interface SuggestionFilter {
+    status?: Suggestion["status"];
+    anchorState?: AnchorState["state"];
+}
+/**
+ * Suggested changes to content, from people and agents. Nothing changes until a person, or an agent
+ * with the accept scope that did not write it, accepts. Accept and reject are safe across replicas.
+ */
+declare class Suggestions {
+    private readonly comments;
+    private readonly host;
+    private readonly onTransaction;
+    private failures;
+    constructor(comments: Comments, host: SuggestionHost);
+    /** Stop listening to the document. */
+    close(): void;
+    private get ydoc();
+    private get map();
+    private get applied();
+    private get rejected();
+    private change;
+    /**
+     * Records of one kind for one suggestion, in client order. A record that is not valid is not counted:
+     * one with no author or time, a receipt that is not small JSON, or a decider who decided their own work.
+     */
+    private records;
+    /** Group the entries of a decision map by suggestion id in one pass, so a read does not scan the map per suggestion. */
+    private index;
+    private read;
+    private fields;
+    /** 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. */
+    private mayDecide;
+    /**
+     * Apply the change as the accepting author and record the decision, in one step. Accepting an
+     * accepted suggestion changes nothing. When `apply` throws, the suggestion stays pending.
+     */
+    accept(suggestionId: string, actor: Actor): Suggestion;
+    /** Same right as accept. A person can withdraw their own suggestion. */
+    reject(suggestionId: string, actor: Actor): Suggestion;
+    get(suggestionId: string): Suggestion;
+    /** In the order they were made. A malformed suggestion is skipped, and `problems()` names it. */
+    list(filter?: SuggestionFilter): Suggestion[];
+    /** Suggestions that could not be read, and reverts that failed. */
+    problems(): {
+        id: string;
+        reason: string;
+    }[];
+    private readAll;
+    /**
+     * Two replicas can accept one suggestion before they meet. After a merge, the application of the
+     * lowest client id stays, and the host reverts each other one. Every replica reaches the same result.
+     * A revert that throws leaves its record, so the next merge tries again.
+     */
+    settle(): void;
+}
+
+export { ACCEPT_SCOPE, Actor, type Anchor, type AnchorKind, type AnchorState, type ApplyContext, type Author, type CanvasAnchor, type CellAnchor, Comments, CommentsError, type CommentsErrorCode, type CommentsOptions, type Message, type NewReply, type NewSuggestion, type NewThread, PRINCIPAL_KINDS, type PrincipalKind, type RelativePositionJson, type RevertContext, type SlideAnchor, type StampInput, type Suggestion, type SuggestionFilter, type SuggestionHost, Suggestions, type TextAnchor, type Thread, type ThreadFilter, VERSION, authorLabel, stamp, textAnchor, textOf };