@fileverse-dev/ddoc 3.2.9 → 3.3.0-viem-1

package/dist/package/components/inline-comment/comment-card.d.ts

@@ -1,4 +1,22 @@
-import { CommentCardProps } from './types';
+import { MouseEvent } from 'react';
+import { CommentCardProps, CommentReplyProps, EnsStatus } from './types';
 
+export declare const CommentReply: ({ commentId, replyId, reply, username, createdAt, isThreadResolved, }: CommentReplyProps) => import("react/jsx-runtime").JSX.Element;
+interface CommentRepliesThreadProps {
+    id?: string;
+    displayedReplies: CommentCardProps['replies'];
+    ensStatus: EnsStatus;
+    handleReplyToggleClick: (event: MouseEvent<HTMLElement>) => void;
+    isCommentDrawerContext?: boolean;
+    isResolved?: boolean;
+    replyToggleLabel: string;
+    shouldShowReplyThread: boolean;
+    shouldShowReplyToggle: boolean;
+    shouldShowResolvedMobileReplyCount: boolean;
+    showAllReplies: boolean;
+    visibleReplies: CommentCardProps['replies'];
+}
+export declare const CommentRepliesThread: ({ id, displayedReplies, ensStatus, handleReplyToggleClick, isCommentDrawerContext, isResolved, replyToggleLabel, shouldShowReplyThread, shouldShowReplyToggle, shouldShowResolvedMobileReplyCount, showAllReplies, visibleReplies, }: CommentRepliesThreadProps) => import("react/jsx-runtime").JSX.Element | null;
 export declare const CommentCard: (props: CommentCardProps) => import("react/jsx-runtime").JSX.Element;
 export declare const UserDisplaySkeleton: () => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/inline-comment/comment-drawer-constants.d.ts

@@ -0,0 +1 @@
+export declare const ALL_TABS_OPTION_ID = "__all_tabs__";

package/dist/package/components/inline-comment/comment-drawer-desktop.d.ts

@@ -0,0 +1,35 @@
+import { IComment } from '../../extensions/comment';
+
+interface DrawerSelectOption {
+    id: string;
+    label: string;
+}
+interface CommentDrawerDesktopProps {
+    activeCommentId: string | null;
+    commentType: string;
+    commentTypeOptions: DrawerSelectOption[];
+    filteredComments: IComment[];
+    isCollaborationEnabled: boolean;
+    isCommentTypeSelectOpen: boolean;
+    isConnected: boolean;
+    isNavbarVisible: boolean;
+    isOpen: boolean;
+    isPresentationMode: boolean;
+    isPreviewMode: boolean;
+    isTabSelectOpen: boolean;
+    newCommentTabId: string;
+    onClose: () => void;
+    onCommentFocus: (commentId: string, tabId?: string) => void;
+    onCommentTypeChange: (commentType: string) => void;
+    onCommentTypeSelectOpenChange: (open: boolean) => void;
+    onReset: () => void;
+    onTabChange: (tabId: string) => void;
+    onTabSelectOpenChange: (open: boolean) => void;
+    sectionLabel: string;
+    selectedTab: string;
+    selectedTabLabel: string;
+    tabList: DrawerSelectOption[];
+    tabNameById: Record<string, string>;
+}
+export declare const CommentDrawerDesktop: ({ activeCommentId, commentType, commentTypeOptions, filteredComments, isCollaborationEnabled, isCommentTypeSelectOpen, isConnected, isNavbarVisible, isOpen, isPresentationMode, isPreviewMode, isTabSelectOpen, newCommentTabId, onClose, onCommentFocus, onCommentTypeChange, onCommentTypeSelectOpenChange, onReset, onTabChange, onTabSelectOpenChange, sectionLabel, selectedTab, selectedTabLabel, tabList, tabNameById, }: CommentDrawerDesktopProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/inline-comment/comment-drawer-mobile.d.ts

@@ -0,0 +1,43 @@
+import { IComment } from '../../extensions/comment';
+import { InlineCommentDraft, SuggestionFloatingDraftCard } from './context/types';
+
+interface CommentDrawerMobileProps {
+    activeCommentId: string | null;
+    activeDraft: InlineCommentDraft | null;
+    activeDraftId: string | null;
+    activeSuggestionDraftCard: SuggestionFloatingDraftCard | null;
+    canGoToNextMobileComment: boolean;
+    canGoToPreviousMobileComment: boolean;
+    comments: IComment[];
+    isCollaborationEnabled: boolean;
+    isCommentMobileFocused: boolean;
+    isConnected: boolean;
+    isDiscardCommentOverlayVisible: boolean;
+    isDiscardSuggestionOverlayVisible: boolean;
+    isInlineDraftOpen: boolean;
+    isMobileDrawerVisible: boolean;
+    isNavbarVisible: boolean;
+    isPresentationMode: boolean;
+    mobileActiveCommentsCount: number;
+    mobileDraftRef: React.RefObject<HTMLDivElement>;
+    mobileFocusedCommentIndex: number;
+    onAttemptCloseNewComment: () => void;
+    onAttemptCloseSuggestionDraft: () => void;
+    onCancelDiscardComment: () => void;
+    onCancelDiscardSuggestion: () => void;
+    onCloseDrawer: () => void;
+    onCommentFocus: (commentId: string, tabId?: string) => void;
+    onCreateComment: () => void;
+    onDiscardSuggestionDraft: () => void;
+    onFocusSuggestionDraft: () => void;
+    onNextMobileComment: () => void;
+    onPreviousMobileComment: () => void;
+    onStartNewMobileComment: () => void;
+    onSubmitSuggestionDraft: () => void;
+    onUpdateInlineDraftText: (draftId: string, text: string) => void;
+    onViewAllComments: () => void;
+    tabNameById: Record<string, string>;
+    username: string | null;
+}
+export declare const CommentDrawerMobile: ({ activeCommentId, activeDraft, activeDraftId, activeSuggestionDraftCard, canGoToNextMobileComment, canGoToPreviousMobileComment, comments, isCollaborationEnabled, isCommentMobileFocused, isConnected, isDiscardCommentOverlayVisible, isDiscardSuggestionOverlayVisible, isInlineDraftOpen, isMobileDrawerVisible, isNavbarVisible, isPresentationMode, mobileActiveCommentsCount, mobileDraftRef, mobileFocusedCommentIndex, onAttemptCloseNewComment, onAttemptCloseSuggestionDraft, onCancelDiscardComment, onCancelDiscardSuggestion, onCloseDrawer, onCommentFocus, onCreateComment, onDiscardSuggestionDraft, onFocusSuggestionDraft, onNextMobileComment, onPreviousMobileComment, onStartNewMobileComment, onSubmitSuggestionDraft, onUpdateInlineDraftText, onViewAllComments, tabNameById, username, }: CommentDrawerMobileProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/inline-comment/comment-floating-layout.d.ts

@@ -1,4 +1,6 @@
 export declare const FLOATING_COMMENT_CARD_GAP = 8;
+export declare const FLOATING_COMMENT_BOTTOM_SPACE = 48;
+export declare const FLOATING_COMMENT_RIGHT_SPACE = 48;
 export declare const enum FloatingLayoutInvalidationFlag {
     None = 0,
     Anchor = 1,

package/dist/package/components/inline-comment/comment-reply-input.d.ts

@@ -4,5 +4,5 @@ interface CommentReplyInputProps {
     replyCount: number;
     isCollaborationEnabled: boolean;
 }
-export declare const CommentReplyInput: ({ commentId, replyCount, isCollaborationEnabled, }: CommentReplyInputProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CommentReplyInput: ({ commentId, replyCount, isCollaborationEnabled, commentUsername, }: CommentReplyInputProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/package/components/inline-comment/context/types.d.ts

@@ -26,7 +26,15 @@ export interface CommentFloatingThreadCard extends CommentFloatingBaseCard {
     type: 'thread';
     commentId: string;
 }
-export type CommentFloatingCard = CommentFloatingDraftCard | CommentFloatingThreadCard;
+export interface SuggestionFloatingDraftCard extends CommentFloatingBaseCard {
+    type: 'suggestion-draft';
+    suggestionId: string;
+    /** Accumulated inserted text from the live suggestion context. */
+    insertedText: string;
+    /** Pasted link href for link suggestions. */
+    linkHref?: string;
+}
+export type CommentFloatingCard = CommentFloatingDraftCard | CommentFloatingThreadCard | SuggestionFloatingDraftCard;
 export interface InlineCommentData {
     highlightedTextContent?: string;
     inlineCommentText: string;

package/dist/package/components/inline-comment/floating-comment/suggestion-draft-floating-card.d.ts

@@ -0,0 +1,17 @@
+import { SuggestionDraftFloatingCardProps } from './types';
+
+/**
+ * SuggestionDraftFloatingCard
+ *
+ * Shown while a viewer is composing a suggestion (in suggestion mode).
+ * Uses the same one-line diff format as the submitted thread card
+ * (Add: "X" / Delete: "X" / Replace: "X" with "Y") plus a Submit action
+ * and a Discard (X) button.
+ *
+ * When the viewer hasn't joined yet (no username / wallet), the card
+ * renders FloatingAuthPrompt inside — same pattern as the inline-comment
+ * draft card. The first keystroke that triggered this card is preserved
+ * as the draft's first character; once the viewer joins, the card
+ * transitions to the normal diff/Submit UI without losing what they typed.
+ */
+export declare const SuggestionDraftFloatingCard: ({ card, isHidden, registerCardNode, }: SuggestionDraftFloatingCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/inline-comment/floating-comment/suggestion-thread-floating-card.d.ts

@@ -0,0 +1,15 @@
+import { ThreadFloatingCardProps } from './types';
+
+/**
+ * SuggestionThreadFloatingCard
+ *
+ * Shown in place of the generic ThreadFloatingCard for submitted suggestions
+ * (comments with `isSuggestion: true`). Renders the Figma-specified layout:
+ * author + timestamp header, Accept/Reject (owner) or Withdraw (author)
+ * actions, a one-line diff summary (Add/Delete/Replace), and a reply input.
+ *
+ * Renders from the underlying IComment — the same source ThreadFloatingCard
+ * uses — so once a draft is submitted, nothing else in the pipeline needs
+ * to change to show the suggestion here.
+ */
+export declare const SuggestionThreadFloatingCard: ({ thread, comment, isHidden, registerCardNode, isCollaborationEnabled, }: ThreadFloatingCardProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/package/components/inline-comment/floating-comment/types.d.ts

@@ -1,7 +1,7 @@
 import { Editor } from '@tiptap/react';
 import { ReactNode, RefObject } from 'react';
 import { IComment } from '../../../extensions/comment';
-import { CommentFloatingDraftCard, CommentFloatingThreadCard } from '../context/types';
+import { CommentFloatingDraftCard, CommentFloatingThreadCard, SuggestionFloatingDraftCard } from '../context/types';
 
 export type RegisterCardNode = (floatingCardId: string, node: HTMLDivElement | null) => void;
 export interface CommentFloatingContainerProps {
@@ -32,3 +32,8 @@ export interface ThreadFloatingCardProps {
     registerCardNode: RegisterCardNode;
     isCollaborationEnabled?: boolean;
 }
+export interface SuggestionDraftFloatingCardProps {
+    card: SuggestionFloatingDraftCard;
+    isHidden: boolean;
+    registerCardNode: RegisterCardNode;
+}

package/dist/package/components/inline-comment/floating-comment-layout-utils.d.ts

@@ -2,7 +2,7 @@ import { Editor } from '@tiptap/react';
 import { FloatingLayoutInvalidationFlag, FloatingCardLayoutInput } from './comment-floating-layout';
 import { CommentFloatingCard } from './context/types';
 
-export type AnchorType = 'draft' | 'thread';
+export type AnchorType = 'draft' | 'thread' | 'suggestion-draft';
 export interface CachedAnchorRect {
     top: number;
     height: number;
@@ -40,6 +40,9 @@ export declare const FLOATING_VIEWPORT_BUFFER_MULTIPLIER = 1;
 export declare const getAnchorIdentity: (floatingCard: CommentFloatingCard) => {
     anchorId: string;
     anchorType: "draft";
+} | {
+    anchorId: string;
+    anchorType: "suggestion-draft";
 } | {
     anchorId: string;
     anchorType: "thread";
@@ -65,7 +68,11 @@ export declare const getRect: ({ elements, viewportTop, viewportBottom, }: {
     elements: HTMLElement[];
     viewportTop: number;
     viewportBottom: number;
-}) => DOMRect | null;
+}) => {
+    top: number;
+    height: number;
+    intersectsViewport: boolean;
+} | null;
 export declare const reconcileOrderedFloatingCardIds: ({ previousOrderedFloatingCardIds, nextFloatingCards, getPos, }: {
     previousOrderedFloatingCardIds: string[];
     nextFloatingCards: CommentFloatingCard[];

package/dist/package/components/inline-comment/mobile-inline-comment-sheet.d.ts

@@ -0,0 +1,15 @@
+import { InlineCommentDraft } from './context/types';
+
+interface MobileInlineCommentProps {
+    activeDraft: InlineCommentDraft | null;
+    activeDraftId: string | null;
+    isDiscardCommentOverlayVisible: boolean;
+    mobileDraftRef: React.RefObject<HTMLDivElement>;
+    onAttemptClose: () => void;
+    onCancelDiscard: () => void;
+    onConfirmDiscard: () => void;
+    onSubmit: () => void;
+    onUpdateDraftText: (draftId: string, text: string) => void;
+}
+export declare const MobileInlineComment: ({ activeDraft, activeDraftId, isDiscardCommentOverlayVisible, mobileDraftRef, onAttemptClose, onCancelDiscard, onConfirmDiscard, onSubmit, onUpdateDraftText, }: MobileInlineCommentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/inline-comment/mobile-suggestion-draft-sheet.d.ts

@@ -0,0 +1,15 @@
+import { SuggestionFloatingDraftCard } from './context/types';
+
+interface MobileSuggestionDraftProps {
+    activeSuggestionDraftCard: SuggestionFloatingDraftCard;
+    isConnected: boolean;
+    isDiscardSuggestionOverlayVisible: boolean;
+    username: string | null;
+    onAttemptClose: () => void;
+    onCancelDiscard: () => void;
+    onConfirmDiscard: () => void;
+    onFocusSuggestionText: () => void;
+    onSubmit: () => void;
+}
+export declare const MobileSuggestionDraft: ({ activeSuggestionDraftCard, isConnected, isDiscardSuggestionOverlayVisible, username, onAttemptClose, onCancelDiscard, onConfirmDiscard, onFocusSuggestionText, onSubmit, }: MobileSuggestionDraftProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/inline-comment/suggestion-diff-summary.d.ts

@@ -0,0 +1,11 @@
+import { SuggestionType } from '../../types';
+
+interface SuggestionDiffSummaryProps {
+    suggestionType?: SuggestionType | null;
+    originalContent?: string;
+    suggestedContent?: string;
+    emptyText?: string;
+    className?: string;
+}
+export declare const SuggestionDiffSummary: ({ suggestionType, originalContent, suggestedContent, emptyText, className, }: SuggestionDiffSummaryProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/package/components/inline-comment/types.d.ts

@@ -50,6 +50,7 @@ export interface CommentCardProps extends IComment {
     activeCommentId?: string;
     isDisabled?: boolean;
     isCommentOwner?: boolean;
+    canResolveComment?: boolean;
     version?: string;
     emptyComment?: boolean;
     isFocused?: boolean;

package/dist/package/components/inline-comment/use-comment-drawer-drafts.d.ts

@@ -0,0 +1,22 @@
+import { SuggestionFloatingDraftCard } from './context/types';
+
+interface UseCommentDrawerDraftsProps {
+    selectedCommentTabId: string;
+    setOpenReplyId: (commentId: string | null) => void;
+}
+export declare const useCommentDrawerDrafts: ({ selectedCommentTabId, setOpenReplyId, }: UseCommentDrawerDraftsProps) => {
+    activeDraft: import('./context/types').InlineCommentDraft | null;
+    activeDraftId: string | null;
+    activeSuggestionDraftCard: SuggestionFloatingDraftCard | null;
+    handleCreateComment: () => void;
+    handleDiscardSuggestionDraft: () => void;
+    handleStartNewMobileComment: () => void;
+    handleSubmitSuggestionDraft: () => void;
+    isDiscardCommentOverlayVisible: boolean;
+    isDiscardSuggestionOverlayVisible: boolean;
+    isInlineDraftOpen: boolean;
+    setIsDiscardCommentOverlayVisible: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    setIsDiscardSuggestionOverlayVisible: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    updateInlineDraftText: (draftId: string, value: string) => void;
+};
+export {};

package/dist/package/components/inline-comment/use-comment-drawer-filters.d.ts

@@ -0,0 +1,40 @@
+import { IComment } from '../../extensions/comment';
+import { Tab } from '../tabs/utils/tab-utils';
+
+export declare const commentTypeOptions: {
+    id: string;
+    label: string;
+}[];
+interface UseCommentDrawerFiltersProps {
+    activeTabId: string;
+    comments: IComment[];
+    tabs: Tab[];
+}
+export declare const useCommentDrawerFilters: ({ activeTabId, comments, tabs, }: UseCommentDrawerFiltersProps) => {
+    closeFilterSelects: () => void;
+    commentType: string;
+    commentTypeOptions: {
+        id: string;
+        label: string;
+    }[];
+    filteredComments: IComment[];
+    handleCommentTypeSelectOpenChange: (open: boolean) => void;
+    handleTabSelectOpenChange: (open: boolean) => void;
+    isCommentTypeSelectOpen: boolean;
+    isTabSelectOpen: boolean;
+    resetFilters: () => void;
+    sectionLabel: string;
+    selectedCommentTabId: string;
+    selectedTab: string;
+    selectedTabLabel: string;
+    setCommentType: import('react').Dispatch<import('react').SetStateAction<string>>;
+    setTab: import('react').Dispatch<import('react').SetStateAction<string>>;
+    tabList: {
+        id: string;
+        label: string;
+    }[];
+    tabNameById: {
+        [k: string]: string;
+    };
+};
+export {};

package/dist/package/components/inline-comment/use-comment-drawer-focus.d.ts

@@ -0,0 +1,17 @@
+import { IComment } from '../../extensions/comment';
+
+interface UseCommentDrawerFocusProps {
+    activeTabId: string;
+    comments: IComment[];
+    focusCommentInEditor: (commentId: string, options?: {
+        source?: 'explicit-ui';
+    }) => void;
+    isBelow1280px: boolean;
+    onTabChange?: (tabId: string) => void;
+    setOpenReplyId: (commentId: string | null) => void;
+}
+export declare const useCommentDrawerFocus: ({ activeTabId, comments, focusCommentInEditor, isBelow1280px, onTabChange, setOpenReplyId, }: UseCommentDrawerFocusProps) => {
+    clearPendingCommentFocus: () => void;
+    handleCommentFocus: (commentId: string, commentTabId?: string) => void;
+};
+export {};

package/dist/package/components/inline-comment/use-comment-drawer-lifecycle.d.ts

@@ -0,0 +1,13 @@
+interface UseCommentDrawerLifecycleProps {
+    activeSuggestionDraftCard: unknown;
+    closeFilterSelects: () => void;
+    isBelow1280px: boolean;
+    isCommentMobileFocused: boolean;
+    isInlineDraftOpen: boolean;
+    isOpen: boolean;
+    onClose: () => void;
+    setIsDiscardCommentOverlayVisible: (visible: boolean) => void;
+    setIsDiscardSuggestionOverlayVisible: (visible: boolean) => void;
+}
+export declare const useCommentDrawerLifecycle: ({ activeSuggestionDraftCard, closeFilterSelects, isBelow1280px, isCommentMobileFocused, isInlineDraftOpen, isOpen, onClose, setIsDiscardCommentOverlayVisible, setIsDiscardSuggestionOverlayVisible, }: UseCommentDrawerLifecycleProps) => void;
+export {};

package/dist/package/components/inline-comment/use-is-selected-content-deleted.d.ts

@@ -1 +1 @@
-export declare function useIsSelectedContentDeleted(commentId: string | undefined, selectedContent: string | undefined, commentTabId: string | undefined): boolean;
+export declare function useIsSelectedContentDeleted(commentId: string | undefined, selectedContent: string | undefined, commentTabId: string | undefined, isSuggestion?: boolean): boolean;

package/dist/package/components/inline-comment/use-mobile-comment-navigation.d.ts

@@ -0,0 +1,20 @@
+import { RefObject } from 'react';
+import { IComment } from '../../extensions/comment';
+
+interface UseMobileCommentNavigationProps {
+    comments: IComment[];
+    mobileDrawerRef: RefObject<HTMLDivElement>;
+    onCommentFocus: (commentId: string, tabId?: string) => void;
+    openReplyId: string | null;
+    setOpenReplyId: (commentId: string | null) => void;
+}
+export declare const useMobileCommentNavigation: ({ comments, mobileDrawerRef, onCommentFocus, openReplyId, setOpenReplyId, }: UseMobileCommentNavigationProps) => {
+    canGoToNextMobileComment: boolean;
+    canGoToPreviousMobileComment: boolean;
+    handleNextMobileComment: () => void;
+    handlePreviousMobileComment: () => void;
+    handleViewAllComments: () => void;
+    mobileActiveCommentsCount: number;
+    mobileFocusedCommentIndex: number;
+};
+export {};

package/dist/package/extensions/comment/comment-decoration-plugin.d.ts

@@ -2,6 +2,7 @@ import { Extension, Editor } from '@tiptap/core';
 import { EditorState, PluginKey } from '@tiptap/pm/state';
 import { Transform } from '@tiptap/pm/transform';
 import { DecorationSet } from '@tiptap/pm/view';
+import { SuggestionType } from '../../types';
 
 import * as Y from 'yjs';
 export interface CommentAnchor {
@@ -10,6 +11,10 @@ export interface CommentAnchor {
     anchorTo: Y.RelativePosition;
     resolved: boolean;
     deleted: boolean;
+    isSuggestion?: boolean;
+    suggestionType?: SuggestionType;
+    originalContent?: string;
+    suggestedContent?: string;
 }
 interface CommentDecorationPluginState {
     decorations: DecorationSet;
@@ -34,7 +39,15 @@ export type CommentAnchorTransactionChange = {
 } & CommentAnchorRange & CommentAnchorRelativeRange);
 export declare const commentDecorationPluginKey: PluginKey<CommentDecorationPluginState>;
 export declare function resolveCommentAnchorRangeInState(anchor: Pick<CommentAnchor, 'anchorFrom' | 'anchorTo'>, state: EditorState): CommentAnchorRange | null;
+/**
+ * Resolve anchorFrom to a single absolute position.
+ * Used for 'add' suggestion anchors where anchorFrom === anchorTo (cursor,
+ * no initial selection) — resolveCommentAnchorRangeInState rejects from >= to,
+ * so we need a separate path that allows a point position.
+ */
+export declare function resolveCommentAnchorPointInState(anchor: Pick<CommentAnchor, 'anchorFrom'>, state: EditorState): number | null;
 export declare function resolveCommentAnchorRangeForAnalysis(anchor: Pick<CommentAnchor, 'id' | 'anchorFrom' | 'anchorTo'>, state: EditorState): CommentAnchorRange | null;
+export declare function resolveCommentAnchorPointForAnalysis(anchor: Pick<CommentAnchor, 'id' | 'anchorFrom'>, state: EditorState): number | null;
 /**
  * Analyze transaction changes to classify each active anchor's mutation status.
  *
@@ -42,15 +55,16 @@ export declare function resolveCommentAnchorRangeForAnalysis(anchor: Pick<Commen
  * whether each anchor remains unchanged, gets edited, or is deleted.
  *
  * Classification rules (in order):
- * 1. Skip deleted or resolved anchors → 'unchanged'
- * 2. If anchor has no old position → 'unchanged'
- * 3. If no changed ranges touch the anchor → 'unchanged'
- * 4. If any changed range fully covers the anchor → 'deleted' (full-span replacement)
- * 5. If combined changed ranges fully cover the anchor → 'deleted' (multi-step removal)
- * 6. If anchor maps through transform → check if position or content changed:
+ * 1. If the transform preserves positions → 'unchanged'
+ * 2. Skip deleted or resolved anchors → 'unchanged'
+ * 3. If anchor has no old position → 'unchanged'
+ * 4. If no changed ranges touch the anchor → 'unchanged'
+ * 5. If any changed range fully covers the anchor → 'deleted' (full-span replacement)
+ * 6. If combined changed ranges fully cover the anchor → 'deleted' (multi-step removal)
+ * 7. If anchor maps through transform → check if position or content changed:
  *    a. If both unchanged → 'unchanged'
  *    b. Otherwise → 'edited' (return new position and relative anchor)
- * 7. If mapping fails → 'deleted'
+ * 8. If mapping fails → 'deleted'
  */
 export declare function analyzeCommentAnchorTransactionChanges(anchors: CommentAnchor[], oldState: EditorState, newState: EditorState, transform: Transform): CommentAnchorTransactionChange[];
 export interface CommentDecorationOptions {
@@ -63,8 +77,21 @@ export declare const CommentDecorationExtension: Extension<CommentDecorationOpti
  * These are consumed by the draft-creation flow and transaction-analysis layer.
  */
 export declare function createCommentAnchorFromEditor(editor: Editor, from: number, to: number): CommentAnchorRelativeRange | null;
+/**
+ * Create a point anchor (anchorFrom === anchorTo) at a single doc position.
+ * Used by the suggestion-mode draft flow when the viewer places a cursor
+ * without selecting text — createCommentAnchorFromEditor rejects from >= to
+ * since an empty range is invalid for regular comments.
+ */
+export declare function createCommentAnchorPointFromEditor(editor: Editor, pos: number): CommentAnchorRelativeRange | null;
 export declare function createCommentAnchorFromSelection(editor: Editor): CommentAnchorRelativeRange | null;
 export declare function triggerDecorationRebuild(editor: Editor): void;
 export declare function getCommentAtPosition(editor: Editor, pos: number, getAnchors: () => CommentAnchor[]): CommentAnchor | null;
 export declare function getCommentAnchorRange(editor: Editor, commentId: string, getAnchors: () => CommentAnchor[]): CommentAnchorRange | null;
+/**
+ * Apply the accepted suggestion's change to the document.
+ * Called by the store's acceptSuggestion action before resolving on-chain.
+ * Returns false if the anchor can't be resolved or the suggestion type is unknown.
+ */
+export declare function applyAcceptedSuggestion(editor: Editor, anchor: CommentAnchor): boolean;
 export {};

package/dist/package/extensions/comment/comment.d.ts

@@ -2,6 +2,7 @@ import { Mark, Range } from '@tiptap/core';
 import { Mark as PMMark } from '@tiptap/pm/model';
 import { PluginKey, EditorState } from '@tiptap/pm/state';
 import { DecorationSet } from '@tiptap/pm/view';
+import { SuggestionType } from '../../types';
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -93,6 +94,10 @@ export interface IComment {
     deleted?: boolean;
     commentIndex?: number;
     version?: string;
+    isSuggestion?: boolean;
+    suggestionType?: SuggestionType;
+    originalContent?: string;
+    suggestedContent?: string;
 }
 export declare const CommentExtension: Mark<CommentOptions, CommentStorage>;
 export {};

package/dist/package/extensions/suggestion/suggestion-tracking-extension.d.ts

@@ -0,0 +1,45 @@
+import { Extension } from '@tiptap/core';
+import { PluginKey } from '@tiptap/pm/state';
+import { SuggestionType } from '../../types';
+import { CommentAnchor } from '../comment/comment-decoration-plugin';
+
+import * as Y from 'yjs';
+export interface SuggestionReadyData {
+    suggestionId: string;
+    anchorFrom: Y.RelativePosition;
+    anchorTo: Y.RelativePosition;
+    suggestionType: SuggestionType;
+    originalContent: string;
+    suggestedContent: string;
+}
+export interface SuggestionTrackingOptions {
+    /** Returns true when the editor is in suggestion mode. */
+    getIsSuggestionMode: () => boolean;
+    /** Viewer types text with a collapsed cursor (Add gesture). */
+    onTextInput: (text: string) => void;
+    /** Viewer types text over a non-empty selection (Replace gesture). */
+    onReplaceTyping: (from: number, to: number, text: string) => void;
+    /** Viewer presses Backspace/Delete with a non-empty selection. */
+    onDeleteSelection: (from: number, to: number) => void;
+    /** Viewer pastes a link over selected text. */
+    onPasteLink: (from: number, to: number, href: string) => void;
+    /**
+     * Viewer presses Backspace/Delete with a collapsed cursor.
+     * The consumer decides whether this should shrink an active draft or create
+     * a new one-character delete suggestion at the caret.
+     */
+    onDeleteAtCursor: (direction: 'backward' | 'forward') => void;
+    /**
+     * Browser attempted to delete a concrete range without an explicit
+     * user selection (for example, a beforeinput/IME path that bypassed
+     * keydown). Lets the consumer preserve "undo active draft" semantics
+     * while still creating delete drafts for normal text.
+     */
+    onDeleteRangeWithoutSelection: (from: number, to: number) => void;
+    /** Viewer presses Cmd+Z (or Ctrl+Z). Shrinks the active draft by one keystroke. */
+    onUndo: () => void;
+    onLiveSuggestion?: ((anchor: CommentAnchor) => void) | null;
+    onSuggestionReady?: ((data: SuggestionReadyData) => void) | null;
+}
+export declare const suggestionTrackingPluginKey: PluginKey<null>;
+export declare const SuggestionTrackingExtension: Extension<SuggestionTrackingOptions, any>;

package/dist/package/hooks/use-editing-context.d.ts

@@ -4,6 +4,7 @@ type EditingContextType = {
     isPreviewMode: boolean;
     isPresentationMode?: boolean;
     isCollaboratorsDoc?: boolean;
+    isSuggestionMode?: boolean;
 };
 export declare const useEditingContext: () => EditingContextType;
 type EditingProviderProps = {
@@ -12,6 +13,7 @@ type EditingProviderProps = {
     isPresentationMode?: boolean;
     isCollaboratorsDoc?: boolean;
     isPreviewEditor?: boolean;
+    isSuggestionMode?: boolean;
 };
 export declare const EditingProvider: React.FC<EditingProviderProps>;
 export {};

package/dist/package/hooks/use-tab-editor.d.ts

@@ -12,6 +12,7 @@ interface UseTabEditorArgs {
     hasTabState?: boolean;
     versionId?: string;
     isPreviewMode?: boolean;
+    viewerMode?: DdocProps['viewerMode'];
     initialContent: DdocProps['initialContent'];
     collaboration?: CollaborationProps;
     isReady?: boolean;
@@ -51,7 +52,7 @@ interface UseTabEditorArgs {
     editorRef?: MutableRefObject<Editor | null>;
     initialCommentAnchors?: SerializedCommentAnchor[];
 }
-export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, initialContent, collaboration, isReady, isSyncing, awareness, disableInlineComment, isFocusMode, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setPageCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, initialCommentAnchors, }: UseTabEditorArgs) => {
+export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, viewerMode, initialContent, collaboration, isReady, isSyncing, awareness, disableInlineComment, isFocusMode, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setPageCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, initialCommentAnchors, }: UseTabEditorArgs) => {
     editor: Editor | null;
     ref: import('react').RefObject<HTMLDivElement>;
     slides: string[];
@@ -63,5 +64,7 @@ export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionI
     focusCommentWithActiveId: (id: string) => void;
     isContentLoading: boolean | undefined;
     commentAnchorsRef: MutableRefObject<CommentAnchor[]>;
+    draftAnchorsRef: MutableRefObject<CommentAnchor[]>;
+    storeApiRef: MutableRefObject<import('zustand').StoreApi<import('../stores/comment-store').CommentStoreState> | null>;
 };
 export {};

package/dist/package/stores/comment-store-provider.d.ts

@@ -46,7 +46,7 @@ export interface CommentStoreProviderProps {
     isDDocOwner?: boolean;
     setUsername?: React.Dispatch<React.SetStateAction<string>>;
 }
-export declare const CommentStoreProvider: ({ children, editor, ydoc, isFocusMode, setActiveCommentId, focusCommentWithActiveId, setInitialComments, onNewComment, onEditComment, onEditReply, onCommentReply, onResolveComment, onUnresolveComment, onDeleteComment, onDeleteReply, onInlineComment, onComment, setCommentDrawerOpen, connectViaWallet, connectViaUsername, ensResolutionUrl, commentAnchorsRef, initialCommentAnchors, setUsername: setUsernameProp, initialComments, username, activeCommentId, activeTabId, isConnected, isLoading, isDDocOwner, }: CommentStoreProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CommentStoreProvider: ({ children, editor, ydoc, isFocusMode, setActiveCommentId, focusCommentWithActiveId, setInitialComments, onNewComment, onEditComment, onEditReply, onCommentReply, onResolveComment, onUnresolveComment, onDeleteComment, onDeleteReply, onInlineComment, onComment, setCommentDrawerOpen, connectViaWallet, connectViaUsername, ensResolutionUrl, commentAnchorsRef, draftAnchorsRef, storeApiRef, initialCommentAnchors, setUsername: setUsernameProp, initialComments, username, activeCommentId, activeTabId, isConnected, isLoading, isDDocOwner, }: CommentStoreProviderProps) => import("react/jsx-runtime").JSX.Element;
 interface CommentRefsContextType {
     commentsSectionRef: React.RefObject<HTMLDivElement>;
     replySectionRef: React.RefObject<HTMLDivElement>;