@lax-wp/editor 0.4.15 → 0.4.16

package/dist/components/sidebar/content/TrackChangesContent.d.ts

@@ -0,0 +1,8 @@
+export interface TrackChangesContentProps {
+    onClose?: () => void;
+}
+/**
+ * M8 — review sidebar: pending suggestions grouped by id and author with
+ * accept / reject / bulk actions, all driven by the M4 command façade.
+ */
+export declare const TrackChangesContent: ({ onClose }: TrackChangesContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/sidebar/content/anonymization-page/anonymizationUtils.d.ts

@@ -13,6 +13,7 @@ export declare function setShowValue(editor: Editor, showValue: boolean, filter?
  */
 export declare function revertAnonymizedLinksToLinks(editor: Editor, filter?: Set<string>): void;
 export declare function revertToPlainText(editor: Editor, filter?: Set<string>): void;
+export declare function revertVariablePii(editor: Editor, filter?: Set<string>): void;
 export declare function buildTagsFromEditor(editor: Editor): Record<string, ApiTagEntry[]>;
 export type AnonymizedVariableRevealState = 'placeholder' | 'revealed';
 /**

package/dist/components/trackChanges/TrackChangesCards.d.ts

@@ -0,0 +1 @@
+export declare const TrackChangesCards: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/trackChanges/index.d.ts

@@ -0,0 +1,2 @@
+export { TrackChangesCards } from './TrackChangesCards';
+export { relativeTime, TRACK_CHANGES_CARDS_WIDTH } from './utils';

package/dist/components/trackChanges/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const TRACK_CHANGES_CARD_WIDTH = 300;
+export declare const TRACK_CHANGES_CARD_GUTTER = 16;
+export declare const TRACK_CHANGES_CARDS_WIDTH: number;
+/** "just now" / "5m ago" / "3h ago", falling back to a short date. */
+export declare function relativeTime(createdAt: number | null): string;

package/dist/config/EditorConfig.d.ts

@@ -63,7 +63,7 @@ export interface ScanDocumentResult {
  *   rewritten to the standard `link` mark (using the original URL stored in
  *   `anonymizedData[0].value`) so it behaves identically to a default link.
  */
-export declare function normalizeAnonymizationApiResponse(jsonContent: Record<string, unknown>, placeholderFormat?: string): Record<string, unknown>;
+export declare function normalizeAnonymizationApiResponse(jsonContent: Record<string, unknown>, placeholderFormat?: string, highlightChanges?: boolean): Record<string, unknown>;
 /** Payload for Save Changes (PII anonymization settings). Passed to onSaveAnonymizationSettings. */
 export interface AnonymizationSavePayload {
     document_id: string;

package/dist/constants/Extensions.d.ts

@@ -18,6 +18,18 @@ export declare const PAGE_BREAK_LINE_CLASS_NAME = "editor-page-break-line";
 export declare const VARIABLE_TEXT_DATA_VARIABLE_NAME = "data-variable-name";
 export declare const VARIABLE_TEXT_DATA_VALUE = "data-value";
 export declare const VARIABLE_TEXT_CLASS_NAME = "variable-text";
+export declare const VARIABLE_TEXT_DATA_IS_PII = "data-pii";
+export declare const VARIABLE_TEXT_DATA_PII_CATEGORY = "data-pii-category";
+export declare const VARIABLE_TEXT_DATA_PII_PLACEHOLDER = "data-pii-placeholder";
+export declare const VARIABLE_TEXT_DATA_PII_SHOW_VALUE = "data-pii-show-value";
+export declare const VARIABLE_TEXT_DATA_PII_HIGHLIGHT = "data-pii-highlight";
+export declare const VARIABLE_TEXT_DATA_PII_FORMAT = "data-pii-format";
+/**
+ * Also worn by a `variableText` node while its PII is masked, so a masked
+ * variable renders as a plain anonymized chip instead of keeping the boxed
+ * `.variable-text` look.
+ */
+export declare const ANONYMIZED_TEXT_CLASS_NAME = "anonymized-text";
 export declare const VARIABLE_TABLE_TYPE = "data-table-type";
 export declare const VARIABLE_TABLE_ID = "data-table-id";
 export declare const VARIABLE_TABLE_NAME = "data-table-name";

package/dist/extensions/AnonymizedText.d.ts

@@ -14,7 +14,17 @@ export declare const ANON_CATEGORY_COLORS: Record<string, {
     darkColor: string;
 }>;
 export declare function extractCategory(anonymizedData: string): string;
-/** Apply per-category inline colors and chip spacing to a DOM element. */
+/**
+ * Apply per-category inline colors and chip spacing to a DOM element, given
+ * an already-known category key (e.g. "email"). Shared by `anonymizedText`
+ * (which derives the category from `anonymizedData`) and `variableText`
+ * (which already stores the category explicitly via `piiCategory`).
+ */
+export declare function applyCategoryColorStyle(dom: HTMLElement, category: string, opts?: {
+    placeholderFormat?: string;
+    highlightChanges?: boolean;
+}): void;
+/** Apply per-category inline colors and chip spacing to a DOM element, deriving the category from a JSON `anonymizedData` string. */
 export declare function applyCategoryStyle(dom: HTMLElement, anonymizedData: string, opts?: {
     placeholderFormat?: string;
     highlightChanges?: boolean;

package/dist/extensions/VariableText.d.ts

@@ -16,6 +16,26 @@ declare module '@tiptap/core' {
              * @param values - Record mapping variable names to their new values
              */
             updateVariableValues: (values: Record<string, string>) => ReturnType;
+            /**
+             * Flag every variable node matching `variableName` as containing PII.
+             * @param variableName - The name/key of the variable to flag
+             * @param pii - Category, display label, and initial reveal state.
+             *   `highlightChanges`/`placeholderFormat` are display settings normally
+             *   owned by the scan/normalize pipeline; when omitted here the node's
+             *   existing values are kept.
+             */
+            setVariablePii: (variableName: string, pii: {
+                piiCategory: string;
+                placeholder: string;
+                showValue?: boolean;
+                highlightChanges?: boolean;
+                placeholderFormat?: string;
+            }) => ReturnType;
+            /**
+             * Clear PII flags from variable nodes, restoring plain display of `value`.
+             * @param variableName - Limit to a specific variable; omit to revert all PII-flagged variables
+             */
+            revertVariablePii: (variableName?: string) => ReturnType;
         };
     }
 }

package/dist/extensions/index.d.ts

@@ -1,5 +1,5 @@
 import { type EditorConfig } from "@/config/EditorConfig";
-export declare const EditorExtensions: (config?: EditorConfig) => (import("@tiptap/core").Node<import("@tiptap/extension-list").OrderedListOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-list").TaskItemOptions, any> | import("@tiptap/core").Extension<import("@/extensions/AIAutoCompletion").AIAutocompletionOptions, any> | import("@tiptap/core").Extension<any, any> | import("@tiptap/core").Extension<import("./Indent").IndentOptions, any> | import("@tiptap/core").Node<import("./ListItemWithDepthLimit").ListItemOptions, any> | import("@tiptap/core").Extension<import("./Redline").RedlineOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-table").TableOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-table").TableRowOptions, any> | import("@tiptap/core").Node<import("./VariableText").VariableOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-horizontal-rule").HorizontalRuleOptions, any> | import("@tiptap/core").Node<import("./CodeBlockWithToolbar").CodeBlockWithToolbarOptions, any> | import("@tiptap/core").Extension<import("./PageMargin").PageMarginOptions, any> | import("@tiptap/core").Extension<import("./PageBackground").PageBackgroundOptions, any> | import("@tiptap/core").Node<import("./PageBreak").PageBreakOptions, any> | import("@tiptap/core").Node<any, any> | import("@tiptap/core").Node<import("./CustomImageExtension").CustomImageExtensionOptions, any> | import("@tiptap/core").Node<import("./Signature").SignatureOptions, any> | import("@tiptap/core").Node<import("./AnonymizedText").AnonymizedTextOptions, any> | import("@tiptap/core").Mark<import("./AnonymizedLink").AnonymizedLinkOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extensions").UndoRedoOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extensions").CharacterCountOptions, import("@tiptap/extensions").CharacterCountStorage> | import("@tiptap/core").Extension<import("@tiptap/extensions").PlaceholderOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-typography").TypographyOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-text-style").TextStyleOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-text-style").FontSizeOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-superscript").SuperscriptExtensionOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-highlight").HighlightOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-list").TaskListOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-text-align").TextAlignOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-heading").HeadingOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-link").LinkOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-hard-break").HardBreakOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extensions").TrailingNodeOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-collaboration").CollaborationOptions, import("@tiptap/extension-collaboration").CollaborationStorage> | import("@tiptap/core").Extension<import("@tiptap/extension-collaboration-caret").CollaborationCaretOptions, {
+export declare const EditorExtensions: (config?: EditorConfig) => (import("@tiptap/core").Node<import("@tiptap/extension-list").OrderedListOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-list").TaskItemOptions, any> | import("@tiptap/core").Extension<import("@/extensions/AIAutoCompletion").AIAutocompletionOptions, any> | import("@tiptap/core").Extension<any, any> | import("@tiptap/core").Extension<import("./Indent").IndentOptions, any> | import("@tiptap/core").Node<import("./ListItemWithDepthLimit").ListItemOptions, any> | import("@tiptap/core").Extension<import("./Redline").RedlineOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-table").TableOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-table").TableRowOptions, any> | import("@tiptap/core").Node<import("./AnonymizedText").AnonymizedTextOptions, any> | import("@tiptap/core").Node<import("./VariableText").VariableOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-horizontal-rule").HorizontalRuleOptions, any> | import("@tiptap/core").Node<import("./CodeBlockWithToolbar").CodeBlockWithToolbarOptions, any> | import("@tiptap/core").Extension<import("./PageMargin").PageMarginOptions, any> | import("@tiptap/core").Extension<import("./PageBackground").PageBackgroundOptions, any> | import("@tiptap/core").Node<import("./PageBreak").PageBreakOptions, any> | import("@tiptap/core").Node<any, any> | import("@tiptap/core").Node<import("./CustomImageExtension").CustomImageExtensionOptions, any> | import("@tiptap/core").Node<import("./Signature").SignatureOptions, any> | import("@tiptap/core").Mark<import("./AnonymizedLink").AnonymizedLinkOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extensions").UndoRedoOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extensions").CharacterCountOptions, import("@tiptap/extensions").CharacterCountStorage> | import("@tiptap/core").Extension<import("@tiptap/extensions").PlaceholderOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-typography").TypographyOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-text-style").TextStyleOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-text-style").FontSizeOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-superscript").SuperscriptExtensionOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-highlight").HighlightOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-list").TaskListOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-text-align").TextAlignOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-heading").HeadingOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-link").LinkOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-hard-break").HardBreakOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extensions").TrailingNodeOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-collaboration").CollaborationOptions, import("@tiptap/extension-collaboration").CollaborationStorage> | import("@tiptap/core").Extension<import("@tiptap/extension-collaboration-caret").CollaborationCaretOptions, {
     users: {
         clientId: number;
         [key: string]: any;

package/dist/extensions/redline/changeTypes.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The RedlineChange contract (change-tracking.md M4 — query API output).
+ *
+ * This is the shape the query module produces from a document scan and the
+ * shape the review engine (M3) and panel UI (M8) consume. It lives in the
+ * engine layer; the UI re-exports it from components/redline for backward
+ * compatibility.
+ */
+export type RedlineChangeType = 'user-insertion' | 'user-deletion' | 'ai-insertion' | 'ai-deletion' | 'user-replace' | 'ai-replace' | 'user-resize' | 'user-align' | 'ai-align' | 'user-style';
+export interface RedlineComment {
+    id: string;
+    userId: string;
+    userName: string;
+    userProfilePic?: string;
+    timestamp: string;
+    text: string;
+}
+export interface RedlineChange {
+    id: string;
+    markIds?: string[];
+    type: RedlineChangeType;
+    content: string;
+    userId: string;
+    userName: string;
+    userProfilePic?: string;
+    timestamp: string;
+    position: number;
+    nodeType?: 'text' | 'table' | 'tableRow' | 'tableColumn' | 'blockquote' | 'link' | 'signature' | 'variable' | 'image' | 'divider';
+    tableData?: string;
+    tableRowData?: {
+        action: 'add' | 'delete';
+        rowId: string;
+        content?: string;
+    };
+    tableColumnData?: {
+        action: 'add' | 'delete';
+        columnId: string;
+        content?: string;
+    };
+    signatureData?: {
+        action: 'add' | 'delete' | 'update';
+        fileName?: string | null;
+        recipientEmail?: string;
+    };
+    variableData?: {
+        action: 'add' | 'delete';
+        variableName: string;
+        value?: string;
+        previousValue?: string;
+    };
+    formatChanges?: string;
+    linkData?: {
+        url: string;
+        action: 'add' | 'remove' | 'change';
+        oldUrl?: string;
+    };
+    imageData?: {
+        src: string;
+        previousSrc?: string | null;
+        width?: number | null;
+        height?: number | null;
+        previousWidth?: number | null;
+        previousHeight?: number | null;
+        alignment?: string | null;
+        previousAlignment?: string | null;
+        action: 'insert' | 'delete' | 'replace' | 'resize' | 'align';
+    };
+    dividerAction?: 'insert' | 'delete';
+    comments?: RedlineComment[];
+}

package/dist/extensions/redline/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Redline constants — single source of truth for mark names, transaction
+ * meta keys, and node-attribute keys used by the tracking engine.
+ *
+ * Maps to change-tracking.md M0 (schema contract): every other module reads
+ * these names from here so the on-document encoding is defined in one place.
+ */
+/** Inline mark names, one insertion/deletion pair per authoring mode. */
+export declare const MARK_TYPES: {
+    readonly USER_INSERTION: "userInsertion";
+    readonly USER_DELETION: "userDeletion";
+    readonly AI_INSERTION: "aiInsertion";
+    readonly AI_DELETION: "aiDeletion";
+};
+export type RedlineMarkName = (typeof MARK_TYPES)[keyof typeof MARK_TYPES];
+/** Set on transactions that should not be processed by insertion-tracking plugins. */
+export declare const SKIP_REDLINE_INSERTION_TRACKING_META = "skipRedlineInsertionTracking";
+/** Set on transactions produced by handleTextInput so the appendTransaction
+ *  insertion tracker does not double-process the same edit. */
+export declare const REDLINE_HANDLED_TEXT_INPUT_META = "redlineHandledTextInput";
+/** Set on the transaction returned by RedlinePlugin for a paste batch, carrying the shared
+ *  groupId so that other tracking plugins (e.g. the divider tracker) can stamp the same
+ *  groupId on their tracked nodes and appear as one card in the redline panel. */
+export declare const PASTE_BATCH_GROUP_META = "pasteBatchGroupId";
+export declare function isRedlineMarkName(name: string): boolean;

package/dist/extensions/redline/engine/blockNodes.d.ts

@@ -0,0 +1,31 @@
+import type { Transaction } from '@tiptap/pm/state';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { RedlineEntity, RedlineMode } from '../types';
+/**
+ * Marks block-level nodes (tables, dividers, images, signatures, variables)
+ * inside a deleted selection as pending-delete (change-tracking.md M1 —
+ * block-node deletion semantics).
+ *
+ * All nodes use the same mark id/timestamp as the accompanying text deletion
+ * so the whole gesture appears as one card in the redline panel. When the
+ * node was a same-user pending insertion, the prior state is remembered
+ * (redlinePriorAction / data-redline-prior-type) so rejecting the deletion
+ * restores the "pending insert" state instead of clearing tracking entirely.
+ *
+ * Two attribute schemes exist for historical/persistence reasons:
+ * - `redline*` node attrs (horizontalRule, image, signature, variableText),
+ * - `data-redline-*` attrs (table).
+ * Both are preserved verbatim — they are part of the stored-document format.
+ */
+interface BlockDeletionContext {
+    mode: RedlineMode;
+    entity: RedlineEntity;
+    markId: string;
+    timestamp: string;
+}
+export declare function markBlockNodesPendingDelete(tr: Transaction, blockNodes: Array<{
+    pos: number;
+    node: ProseMirrorNode;
+    typeName: string;
+}>, ctx: BlockDeletionContext): void;
+export {};

package/dist/extensions/redline/engine/clipboard.d.ts

@@ -0,0 +1,16 @@
+import { Slice } from '@tiptap/pm/model';
+import type { EditorView } from '@tiptap/pm/view';
+import type { RedlineContext } from '../types';
+import type { RedlineSession } from '../session';
+export declare function sanitizeCopiedSlice(slice: Slice): Slice;
+interface EngineDeps {
+    getContext: () => RedlineContext;
+    session: RedlineSession;
+}
+/**
+ * handlePaste prop — see module docs. Always returns false so TipTap's
+ * default paste proceeds; this handler only prepares batch identity and the
+ * in-place deletion mark for selection replacement.
+ */
+export declare function createPasteHandler(deps: EngineDeps): (view: EditorView) => boolean;
+export {};

package/dist/extensions/redline/engine/deletion.d.ts

@@ -0,0 +1,34 @@
+import { EditorState, Transaction } from '@tiptap/pm/state';
+import type { RedlineContext } from '../types';
+import type { RedlineSession } from '../session';
+/**
+ * Keyboard deletion semantics (change-tracking.md M1 delete-rewriting +
+ * M2 input behavior).
+ *
+ * Instead of removing content, Backspace/Delete/Cut add a deletion mark over
+ * the affected range and move the caret so continued deleting feels natural.
+ * The exceptions, in order of evaluation:
+ *
+ * - code blocks are tracked as whole units → default behavior,
+ * - edits inside a pending-insertion ancestor are draft edits → default,
+ * - already-deletion-marked content is never re-marked (no-op / caret skip),
+ * - the author deleting their own pending insertion physically removes it
+ *   (cancellation) → default behavior.
+ *
+ * Backspace and forward-Delete share this implementation and differ only in
+ * range derivation, boundary checks, adjacency probing (merge direction for
+ * consecutive keystrokes), already-deleted skipping, and final caret
+ * placement.
+ */
+interface EngineDeps {
+    getContext: () => RedlineContext;
+    session: RedlineSession;
+}
+type KeyHandler = (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
+export declare function createDeletionKeyHandler(direction: 'backward' | 'forward', deps: EngineDeps): KeyHandler;
+/**
+ * Mod-x (cut) — writes the selection to the clipboard, then marks it as a
+ * pending deletion instead of removing it.
+ */
+export declare function createCutKeyHandler(deps: EngineDeps): KeyHandler;
+export {};

package/dist/extensions/redline/engine/formatSplit.d.ts

@@ -0,0 +1,16 @@
+import { EditorState, Transaction } from '@tiptap/pm/state';
+import type { MarkType } from '@tiptap/pm/model';
+/**
+ * Splits pending format-change marks that overlap a new deletion range
+ * (change-tracking.md M1.4 — normalization of overlapping suggestions).
+ *
+ * When a deletion lands in the middle of a format-change suggestion, the
+ * suggestion is split into independent before/after changes so each part can
+ * be reviewed on its own: the "before" part keeps its original timestamp, the
+ * "after" part gets a new one (= separate panel card). A deletion covering the
+ * whole format mark simply removes it.
+ *
+ * This logic previously existed as two identical inline copies in the
+ * Backspace and Delete key handlers.
+ */
+export declare function splitFormatChangeMarksOverlappingDeletion(state: EditorState, tr: Transaction, from: number, to: number, insertionMarkType: MarkType): void;

package/dist/extensions/redline/engine/insertion.d.ts

@@ -0,0 +1,26 @@
+import type { EditorState, Transaction } from '@tiptap/pm/state';
+import type { RedlineContext } from '../types';
+import type { RedlineSession } from '../session';
+/**
+ * Insertion tracking (change-tracking.md M1 insert-rewriting), implemented as
+ * an appendTransaction pass: any transaction that inserted content gets a
+ * follow-up transaction marking the new content with an insertion mark
+ * attributed to the current entity.
+ *
+ * Grouping rules (why consecutive typing is one card):
+ * - same-block adjacency: reuse the id of the neighboring insertion mark,
+ * - cross-block typing session: typing + Enter + typing stays one card until
+ *   the cursor navigates away (session state),
+ * - paste batch: everything inserted by one paste shares one id.
+ *
+ * Exemption guards (change-tracking.md M1.3) — transactions that must pass
+ * through untracked: remote Yjs sync, undo/redo history, other tracking
+ * plugins' own output (skip meta), highlight-decoration state changes, and
+ * addToHistory:false transactions (except paste/drop).
+ */
+interface EngineDeps {
+    getContext: () => RedlineContext;
+    session: RedlineSession;
+}
+export declare function createInsertionAppendTransaction(deps: EngineDeps): (transactions: readonly Transaction[], oldState: EditorState, newState: EditorState) => Transaction | null;
+export {};

package/dist/extensions/redline/engine/predicates.d.ts

@@ -0,0 +1,73 @@
+import { EditorState } from '@tiptap/pm/state';
+import type { Mark, MarkType, Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { RedlineMode } from '../types';
+/**
+ * Document predicates used by the tracking engine (change-tracking.md M1).
+ *
+ * These encode the engine's classification rules: what counts as pending
+ * insertion/deletion content, which contexts suppress tracking (code blocks,
+ * pending-insertion ancestors), and how adjacency to existing marks is
+ * detected. Pure functions over EditorState — no dispatching.
+ */
+/**
+ * Checks if a text range contains insertion marks (user or AI).
+ * Used to implement cancellation: deleting inserted text removes the insertion mark.
+ */
+export declare function hasInsertionMarks(state: EditorState, from: number, to: number): boolean;
+/**
+ * Checks if insertion marks are ONLY format changes (not actual text insertions).
+ * Format changes should be treated as existing text and get deletion marks.
+ */
+export declare function isFormatChangeOnly(state: EditorState, from: number, to: number): boolean;
+/**
+ * Checks if a position is inside a code block.
+ * Code blocks should be tracked as whole units, not their text content.
+ */
+export declare function isInsideCodeBlock(state: EditorState, from: number, to: number): boolean;
+/**
+ * Checks if a text range contains deletion marks (user or AI).
+ * Used to implement cancellation: typing over deleted text removes the deletion mark.
+ */
+export declare function hasDeletionMarks(state: EditorState, from: number, to: number): boolean;
+/**
+ * Returns true if every text character in [from, to) has an insertion mark.
+ * Used to decide whether to physically delete selected text rather than adding
+ * a deletion mark (pending insertions deleted by the author should just vanish).
+ */
+export declare function isEntirelyInsertionMarked(state: EditorState, from: number, to: number): boolean;
+/**
+ * Rule 2.4 — Returns true if the range is ENTIRELY covered by deletion marks.
+ * A second deletion on an already-pending-deletion range is a no-op.
+ */
+export declare function isEntirelyDeletionMarked(state: EditorState, from: number, to: number): boolean;
+/**
+ * Rules 5.1–5.2 — Returns true if the range is inside a node that is itself
+ * pending insertion or pending deletion (e.g. a table cell inside a table that
+ * has redlineType="user-insertion"). Text changes inside a pending-insertion
+ * node are edits to the draft, not new tracked changes.
+ */
+export declare function isInsidePendingNode(state: EditorState, from: number): boolean;
+/**
+ * Returns the deletion mark that contains `insertPos` in the given document
+ * state, or null if the position is not inside a deletion mark.
+ * Used to detect typing/pasting inside a pending deletion zone.
+ */
+export declare function getEnclosingDeletionMark(state: EditorState, insertPos: number, currentUserId: string, mode: RedlineMode): {
+    mark: Mark;
+    from: number;
+    to: number;
+    isSameUser: boolean;
+} | null;
+/**
+ * Returns trackable block nodes (tables, dividers) in a document range.
+ * Used to mark these nodes as pending-delete when a selection containing them is deleted.
+ */
+export declare function collectTrackableBlockNodes(state: EditorState, from: number, to: number): Array<{
+    pos: number;
+    node: ProseMirrorNode;
+    typeName: string;
+}>;
+/**
+ * Resolves the appropriate mark type based on mode and operation.
+ */
+export declare function getMarkType(state: EditorState, mode: RedlineMode, operation: 'insertion' | 'deletion'): MarkType | null;

package/dist/extensions/redline/engine/textReplace.d.ts

@@ -0,0 +1,19 @@
+import type { EditorView } from '@tiptap/pm/view';
+import type { RedlineContext } from '../types';
+/**
+ * handleTextInput — replacement semantics for typing over a selection
+ * (change-tracking.md M1 replace-rewriting: select + type).
+ *
+ * Existing text is never removed: it is marked deleted in place, and the
+ * typed text is inserted after it with an insertion mark (deletion +
+ * insertion form the visible "replace"). Typing over the author's own
+ * pending insertion simply replaces it — that content was never accepted,
+ * so no deletion record is needed.
+ *
+ * Plain cursor typing (from === to) is NOT handled here — it returns false
+ * so the default insert proceeds and the appendTransaction insertion tracker
+ * attributes it.
+ */
+export declare function createTextInputHandler(deps: {
+    getContext: () => RedlineContext;
+}): (view: EditorView, from: number, to: number, text: string) => boolean;

package/dist/extensions/redline/id.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Suggestion identity (change-tracking.md M0.5 — ID policy).
+ *
+ * Mark ids must be collision-free across concurrent clients: UUIDv4 when
+ * available, otherwise a time+random fallback. Never counters.
+ */
+export declare const createRedlineMarkId: () => string;

package/dist/extensions/redline/index.d.ts

@@ -0,0 +1,36 @@
+import { Extension } from '@tiptap/core';
+import type { RedlineOptions } from './types';
+/**
+ * Unified Redline Extension — track changes for collaborative editing.
+ *
+ * Structured after change-tracking.md's module architecture:
+ * - M0 schema:   schema/marks (inline marks), ImageRedline (image node attrs)
+ * - M1 engine:   plugin.ts + engine/* (keyboard/paste/typing interception)
+ * - M1 trackers: FormatChange/Link/Image/DividerTrackingPlugin
+ *                (appendTransaction diff trackers for non-text features)
+ * - M2 input:    engine/clipboard, engine/textReplace, session typing state
+ * - M8 UI glue:  MarkClickPlugin, MarkHighlightPlugin (decorations only)
+ * - M12 export:  ViewModeDocumentPreview (clean-preview projection)
+ *
+ * The review engine (M3, accept/reject) and query API (M4, document scan)
+ * live in ./review and ./query and are consumed by the useRedline hook.
+ *
+ * @example
+ * ```ts
+ * Redline.configure({
+ *   isActive: true,
+ *   mode: 'user',
+ *   currentEntity: {
+ *     id: 'u1',
+ *     name: 'Alice'
+ *   }
+ * })
+ * ```
+ */
+export declare const Redline: Extension<RedlineOptions, any>;
+export type { RedlineOptions, RedlineEntity, RedlineMode, RedlineContext } from './types';
+export { RedlinePlugin } from './plugin';
+export { MARK_TYPES, SKIP_REDLINE_INSERTION_TRACKING_META, REDLINE_HANDLED_TEXT_INPUT_META, PASTE_BATCH_GROUP_META, isRedlineMarkName, } from './constants';
+export { createRedlineMarkId } from './id';
+export { redlineSession, RedlineSession } from './session';
+export { UserInsertion, UserDeletion, AIInsertion, AIDeletion } from './schema/marks';

package/dist/extensions/redline/plugin.d.ts

@@ -0,0 +1,34 @@
+import { Extension } from '@tiptap/core';
+import type { RedlineMode, RedlineOptions } from './types';
+/**
+ * RedlinePlugin — the tracking engine assembly (change-tracking.md M1 + M2).
+ *
+ * Composes the engine modules into four ProseMirror plugins:
+ * 1. keymap            — Backspace/Delete/Mod-x rewritten as deletion marks
+ *                        (engine/deletion),
+ * 2. input props       — copy sanitizing, paste batching + selection-replace,
+ *                        select+type replacement (engine/clipboard,
+ *                        engine/textReplace),
+ * 3. appendTransaction — insertion attribution and grouping
+ *                        (engine/insertion),
+ * 4. view              — ends the cross-block typing session on pure cursor
+ *                        navigation.
+ *
+ * Mode/identity live in extension storage (live-toggled via
+ * `toggleRedlineMode`) and options (`currentEntity`, fixed at construction);
+ * the engine reads both through a single RedlineContext getter.
+ */
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        redline: {
+            /**
+             * Toggle redline tracking mode
+             * @param active - Whether to enable change tracking
+             * @param mode - Track changes for 'user' or 'ai'
+             */
+            toggleRedlineMode: (active: boolean, mode?: RedlineMode) => ReturnType;
+        };
+    }
+}
+export declare const RedlinePlugin: Extension<RedlineOptions, any>;
+export type { RedlineOptions };

package/dist/extensions/redline/query/scan.d.ts

@@ -0,0 +1,52 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { RedlineChange, RedlineChangeType } from '../changeTypes';
+/**
+ * Document query module (change-tracking.md M4 — findSuggestions).
+ *
+ * `scanRedlineChanges(doc)` is a pure function: one descendants pass collects
+ * every marked text range and tracked node into MarkedNode records, which are
+ * then filtered (nested-change suppression inside tracked tables/rows/columns/
+ * blockquotes), grouped by mark id / group id into RedlineChange cards, and
+ * post-processed for display (format-category splitting, adjacent-card
+ * consolidation, hiding insertions fully covered by deletions).
+ *
+ * Results are memoized on document identity: ProseMirror docs are immutable,
+ * so the same doc reference always yields the same scan. This removes the
+ * O(doc) rescan on selection-only updates that the legacy hook performed.
+ */
+export interface MarkedNode {
+    markId: string;
+    pos: number;
+    endPos: number;
+    text: string;
+    type: RedlineChangeType;
+    userId: string;
+    userName: string;
+    timestamp: string;
+    nodeType?: 'text' | 'table' | 'tableRow' | 'tableColumn' | 'blockquote' | 'link' | 'signature' | 'variable' | 'image' | 'divider';
+    /** Position of the enclosing tableCell/tableHeader, or null if not inside a cell.
+     *  Used to prevent marks from different cells from being merged into one card. */
+    cellId?: number | null;
+    tableData?: string;
+    tableRowData?: string;
+    tableColumnData?: string;
+    signatureData?: string;
+    variableData?: string;
+    formatChanges?: string;
+    groupId?: string;
+    linkData?: string;
+    imageData?: RedlineChange['imageData'];
+    dividerAction?: 'insert' | 'delete';
+    /** Overrides the group lookup key so several mark ids collapse into one card
+     *  (used to merge a contiguous deletion run regardless of per-gesture ids). */
+    groupKey?: string;
+}
+export declare const getFormatCategory: (formatKey: string) => string;
+export declare const isListItemCreation: (change: RedlineChange) => boolean;
+export interface RedlineScanResult {
+    /** Every change grouped by mark identity — the review engine operates on these. */
+    rawChanges: RedlineChange[];
+    /** Display list for the panel (insertions fully covered by deletions hidden). */
+    displayChanges: RedlineChange[];
+}
+export declare const scanRedlineChanges: (doc: ProseMirrorNode) => RedlineScanResult;

package/dist/extensions/redline/review/applyChange.d.ts

@@ -0,0 +1,25 @@
+import type { Editor } from '@tiptap/core';
+import type { RedlineChange } from '../changeTypes';
+/**
+ * Review engine entry points (change-tracking.md M3 — accept/reject as
+ * document transforms).
+ *
+ * `applyChangeOperation` builds ONE transaction per change: the resolver
+ * chain runs node-type resolvers first (falling through to the text path
+ * when a target node can't be located), and every mutation dispatches with
+ * the skip meta so the tracking engine never re-tracks a resolution
+ * (change-tracking.md M3.7). Selection is preserved and history is bypassed
+ * — resolutions are review actions, not edits.
+ *
+ * Bulk operations process changes bottom-up (descending position) so earlier
+ * positions stay valid across per-change transactions.
+ */
+export declare const applyChangeOperation: (editor: Editor, change: RedlineChange, operation: "accept" | "reject") => boolean;
+/**
+ * Accepts all changes (processes in reverse to avoid position shifts).
+ */
+export declare const acceptAllChanges: (editor: Editor, rawChanges: RedlineChange[]) => void;
+/**
+ * Rejects all changes (processes in reverse to avoid position shifts).
+ */
+export declare const rejectAllChanges: (editor: Editor, rawChanges: RedlineChange[]) => void;

package/dist/extensions/redline/review/index.d.ts

@@ -0,0 +1 @@
+export { applyChangeOperation, acceptAllChanges, rejectAllChanges } from './applyChange';