@lax-wp/editor 0.4.13 → 0.4.15-beta.0

package/dist/config/EditorConfig.d.ts

@@ -1,53 +1,40 @@
 import type { Editor } from "@tiptap/react";
 import { type TEditorMode } from "@/constants";
 import type { InsertTableUsingDataProps, TableColumn } from "@/types/extensions/Table";
-import type { PlaceholderFormat } from "@/constants/sidebar";
-import type { DetectionConfig as SidebarDetectionConfig } from "@/constants/sidebar";
-/** Single detection enable/disable (matches API response). */
-export interface PiiDetectionItem {
-    id: string;
-    enabled: boolean;
-}
-/** PII anonymization detection config (from parent / API). */
-export interface PiiDetectionConfig {
-    /** List of detection types (Names, Emails, etc.). Defaults to DETECTION_CONFIGS when not provided. */
-    detectionConfigs?: SidebarDetectionConfig[];
-    /** Which detection configs are enabled (id + enabled). Matches API shape. */
-    detections?: PiiDetectionItem[];
-    placeholderFormat?: PlaceholderFormat;
-    highlightChanges?: boolean;
-}
-/** One anonymization entry: the variable name + the original value it replaced. */
-export interface AnonymizedDataItem {
-    anonymizedVariable: string;
-    value: string;
-}
+import type { CdtsScope } from "@/utils/cdts";
+import type { ReviewResponseLike } from "@/utils/groundingAdapter";
+import type { PlaybookApiConfig } from "@/api/playbook";
+import type { ReviewItem } from "@/components/redline/AiReviewPanel";
+import type { FlowdownFlagInput, FlowdownInsertionInput } from "@/components/flowdown/flowdownModel";
+import type { ScopeWarningPayload } from "@/api/redlineStream";
+import type { StreamSummaryCounters as ReviewSummaryCounters } from "@/components/r1/ReviewSummaryTab";
 /**
- * A single entity row in the `tags` map returned by the scan API.
- * Every key except `"count"` is a placeholder → original-value pair.
- * e.g. { "[PERSON_A_NAME]": "Elon Reeve Musk", "count": 1 }
+ * Host-implemented PII API over the backend proxy:
+ *   anonymize → POST /v1/pii/anonymize {document_id, doc}
+ *   getTags   → GET  /v1/pii/tags/{document_id}   (vault recovery)
+ *
+ * Errors must reject with `{status?, code?}` (e.g. api/pii.ts's PiiApiError)
+ * so the panel can map 409 pii_already_anonymized / 422 pii_redaction_error /
+ * 503 pii_unavailable / 404 route-absent.
  */
-export type ApiTagEntry = Record<string, string | number>;
+export interface PiiAnonymizationApi {
+    anonymize(documentId: string, doc: Record<string, unknown>): Promise<{
+        doc: Record<string, unknown>;
+        tags: Record<string, string>;
+        entity_count: number;
+    }>;
+    getTags(documentId: string): Promise<{
+        tags: Record<string, string>;
+    }>;
+}
 /**
- * Typed shape of the JSON returned by the scan API.
- * Pass this as the resolved value of `onScanDocument`.
+ * PII panel host config. Absent (or missing `api` / `documentId`) → the
+ * panel renders its "unavailable" state. No other fields — placeholder
+ * format is hardcoded server-side and per-entity selection is gone.
  */
-export interface ScanDocumentResult {
-    document_id?: string;
-    /**
-     * Anonymised TipTap JSON (uses `"anonymizedText"` inline nodes and
-     * sometimes `"Text"` (capital-T) for plain text). Pass through
-     * {@link normalizeAnonymizationApiResponse} before calling `setContent`.
-     */
-    json_content?: Record<string, unknown>;
-    /**
-     * Detected entities grouped by category.
-     * `Record<categoryLabel, entity[]>` – e.g. `{ "Person": [...], "Date": [...] }`
-     */
-    tags?: Record<string, ApiTagEntry[]>;
-    placeholder_format?: string;
-    highlight_changes?: boolean;
-    isAnalyzed?: boolean;
+export interface PiiAnonymizationConfig {
+    documentId: string;
+    api: PiiAnonymizationApi;
 }
 /**
  * Convert the raw `json_content` returned by the scan API into a shape that
@@ -63,15 +50,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>;
-/** Payload for Save Changes (PII anonymization settings). Passed to onSaveAnonymizationSettings. */
-export interface AnonymizationSavePayload {
-    document_id: string;
-    tags: string[];
-    placeholder_format: PlaceholderFormat;
-    highlight_changes: boolean;
-    json_content: Record<string, unknown>;
-}
+export declare function normalizeAnonymizationApiResponse(jsonContent: Record<string, unknown>, placeholderFormat?: string, highlightChanges?: boolean): Record<string, unknown>;
 export interface AIAutocompletionConfig {
     /** Enable/disable AI autocompletion */
     enabled?: boolean;
@@ -82,8 +61,6 @@ export interface AIAutocompletionConfig {
     /** Required: Custom fetch function for API calls. AI autocompletion only works when this is provided. */
     fetchCompletion?: (text: string) => Promise<string>;
 }
-/** Pass scan/API JSON or an HTML string into the editor (used with {@link EditorConfig.onScanComplete}). */
-export type ApplyScanCompleteContent = (editorContent: string | Record<string, unknown>) => void;
 export type ScreenshotMimeType = 'image/png' | 'image/jpeg';
 /**
  * Screenshot options accepted by both config-driven and imperative capture APIs.
@@ -96,6 +73,65 @@ export interface ScreenshotCaptureOptions {
     /** JPEG quality from 0..1. Used only when `mimeType` is `image/jpeg`. Defaults to `0.92`. */
     quality?: number;
 }
+/**
+ * Target for {@link ApplyRedlineParams}. Either an absolute PM position range
+ * ({@link from}/{@link to}) for text-range redlines, or a `nodePath` (root → …
+ * → child index) resolved to the node's inner text range. The live backend
+ * stream emits single-level paths (e.g. `[302]`); nested paths are best-effort.
+ */
+export type RedlineTarget = {
+    from: number;
+    to: number;
+} | {
+    nodePath: number[];
+};
+/**
+ * Imperative redline injection (FE_requests.md ask A / gap G). Applies AI
+ * redlines using the editor's NATIVE representations — `aiInsertion` /
+ * `aiDeletion` marks for text ranges, existing redline node-attrs for
+ * structural nodes. Transacts through `@tiptap/extension-collaboration` so the
+ * change replicates over Yjs. Grounding does NOT ride here — it travels on the
+ * Channel-2 `grounding[]` sidecar (see `groundingAdapter`).
+ */
+export interface ApplyRedlineParams {
+    target: RedlineTarget;
+    kind: 'insert' | 'delete' | 'replace' | 'attr-change';
+    /** insert / replace: the proposed text carrying the aiInsertion mark. */
+    proposedText?: string;
+    /** attr-change / replace on structural nodes: prior attrs, for restore. */
+    previousAttrs?: Record<string, unknown>;
+    author: {
+        id: string;
+        name: string;
+    };
+    /** ISO-8601 → mark/attr timestamp. */
+    timestamp: string;
+    /** Shared id for multi-range / multi-node group accept-reject. */
+    groupId?: string;
+    /**
+     * Exact source text the redline concerns, used to narrow a `nodePath` target
+     * from the whole block down to that phrase. This is the backend's
+     * `citation.verbatim_excerpt`. Without it a `replace` addressed by nodePath
+     * strikes the entire block. Ignored when the target is already a range, and
+     * ignored when the text can't be found in the node.
+     */
+    matchText?: string;
+}
+/**
+ * Fired from the accept/reject path (FE_requests.md ask F / gap G) so the host
+ * can forward the decision to the audit loop. No HTTP inside the package.
+ */
+export interface RedlineDecision {
+    /** The redline change that was decided on (editor-internal change shape). */
+    change: unknown;
+    decision: 'accepted' | 'rejected';
+    actor: {
+        id: string;
+        name: string;
+    };
+    /** ISO-8601 timestamp of the decision. */
+    timestamp: string;
+}
 /**
  * Declarative screenshot request configuration.
  *
@@ -170,6 +206,107 @@ export interface EditorConfig {
         documentURL?: string;
         onExternalUserInvite?: (emails: string[], permission: 'view' | 'suggest') => void;
     };
+    /** Playbook & redlines side-panel configuration. Feeds the rail's Playbook
+     *  panel the document's CDTS scope, the latest review response (the
+     *  grounding[] sidecar from a redline run), and the playbook API config.
+     *  When omitted, the panel still mounts with an empty scope. */
+    playbookConfig?: {
+        documentScope?: CdtsScope;
+        documentId?: string;
+        workspaceId?: string;
+        workspaceName?: string;
+        regimeLabels?: string[];
+        reviewResponse?: ReviewResponseLike | null;
+        api?: PlaybookApiConfig;
+    };
+    /** AI review side-rail (redesigned redline panel). When enabled, replaces the
+     *  gutter redline cards with a fixed right-rail list of review cards
+     *  (severity + category + rationale + playbook ref + diff + accept/reject),
+     *  and clicking a card scrolls the document to that redline. `meta` supplies
+     *  grounding per change (keyed by the mark's groupId / backend suggestion id). */
+    aiReviewPanel?: {
+        enabled?: boolean;
+        playbookName?: string;
+        meta?: Record<string, {
+            category?: 'legal' | 'operational' | 'financial' | 'grammar' | 'policy';
+            severity?: 'high' | 'medium' | 'low';
+            title?: string;
+            rationale?: string;
+            playbookRef?: string;
+            clause?: string;
+        }>;
+        /** Advisory findings (grammar/rulebook/irregularity lanes from the redline
+         *  stream) — rendered below the main review list with no decision bar. */
+        findings?: ReviewItem[];
+        /** Optional "Run AI Redline" action rendered in the panel header. When
+         *  omitted, no run button appears. `running` disables it and shows a
+         *  progress label while a review is in flight. */
+        onRun?: () => void;
+        running?: boolean;
+        /**
+         * A2: lanes the backend reported degraded (summary.lanes_degraded). Any
+         * entry renders a prominent partial-review banner (dismissable only by
+         * acknowledging it) and a "Partial" marker in the panel header.
+         */
+        degradedLanes?: string[];
+        /** A2: mid-stream `event: error` frames arrived — also marks the review partial. */
+        hadStreamErrors?: boolean;
+        /**
+         * Scope warnings from the review stream (`scope_warning` events /
+         * summary.scope_warnings): the review's substantive scope collapsed.
+         * Any entry renders a prominent, non-dismissable banner in the panel.
+         */
+        scopeWarnings?: ScopeWarningPayload[];
+        /**
+         * C1: regime selector rendered above the run button. `selected` should
+         * default to every regime applicable to the document's scope; `onChange`
+         * feeds the next run's `regimes`.
+         */
+        regimeSelector?: {
+            available: string[];
+            selected: string[];
+            onChange: (next: string[]) => void;
+        };
+        /**
+         * "Ignore this rule" was used. `family` is the suppression key (the rule id
+         * with its per-finding hash stripped) — pass it in the next run's
+         * `disabled_rule_ids` to stop the rule firing at the source. `dismissedIds`
+         * are the cards dismissed right now. Without a handler the dismissal is
+         * session-only and the rule returns on the next run.
+         */
+        onIgnoreRule?: (family: string, dismissedIds: string[]) => void;
+        /**
+         * Flowdown determination tab (gov-baseline lane). When set, the AI review
+         * panel grows a "Flowdown" tab listing the review's `baseline:gov:*`
+         * rulebook flags paired with their sibling insertions, with per-rule
+         * Accept / Not-applicable determinations (PATCH /api/redlines
+         * dispositions). `documentId` enables re-hydration; `actorName` feeds the
+         * X-Actor header (localStorage `lax.flowdownActor` overrides, default
+         * "reviewer").
+         */
+        flowdown?: {
+            flags: FlowdownFlagInput[];
+            insertions: FlowdownInsertionInput[];
+            documentId?: string;
+            actorName?: string;
+        };
+        /**
+         * Executive-summary tab. When set, the AI review panel grows a "Summary"
+         * tab showing the run's provenance / severity / flowdown / escalation
+         * counts. `payload` is the stream's `summary` frame (the counters the
+         * panel derives from — no extra request); `complete` must be true ONLY
+         * when both `summary` and `done` arrived, otherwise the tab says the
+         * review did not complete instead of presenting partial counts as final.
+         * `reviewId` is re-hydration only: a completed review whose stream this
+         * session never saw, fetched via GET /v1/reviews/{id}/summary.
+         */
+        reviewSummary?: {
+            payload?: ReviewSummaryCounters | null;
+            complete?: boolean;
+            cancelled?: boolean;
+            reviewId?: string | null;
+        };
+    };
     /** Callback when content changes */
     onContentChange?: (editor: Editor) => void;
     /** Callback when editor is ready with helper methods */
@@ -190,7 +327,11 @@ export interface EditorConfig {
         }) => void;
         updateTableValues: () => void;
         captureScreenshot: (options?: ScreenshotCaptureOptions) => Promise<File>;
+        /** Inject an AI redline. See {@link ApplyRedlineParams}. */
+        applyRedline: (params: ApplyRedlineParams) => void;
     }) => void;
+    /** Fired when a redline is accepted or rejected. See {@link RedlineDecision}. */
+    onRedlineDecision?: (decision: RedlineDecision) => void;
     /**
      * Screenshot capture configuration.
      *
@@ -200,25 +341,8 @@ export interface EditorConfig {
     screenshot?: ScreenshotConfig;
     /** Parent container id for redline positioning */
     parentContainerId?: string;
-    /** PII Anonymization configuration */
-    piiAnonymization?: {
-        settings?: PiiDetectionConfig;
-        onSaveAnonymizationSettings?: (payload: AnonymizationSavePayload) => void;
-        onScanDocument?: (json: Record<string, unknown>) => Promise<ScanDocumentResult | void>;
-        /**
-         * Called once when the editor is ready. You receive {@link ApplyScanCompleteContent};
-         * call it after a scan/API returns to load new document JSON (normalized for anonymization) or HTML.
-         */
-        onScanComplete?: (applyScanCompleteContent: ApplyScanCompleteContent) => void;
-        onCancelScan?: () => void;
-        onRevertAnonymization?: () => void;
-        onAnonymizeDocument?: () => void;
-        isAnonymized?: boolean;
-        isScanningDocument?: boolean;
-        isAnalyzed?: boolean;
-        isTagsLoading?: boolean;
-        isRevertingAnonymization?: boolean;
-    };
+    /** PII Anonymization configuration (see {@link PiiAnonymizationConfig}). */
+    piiAnonymization?: PiiAnonymizationConfig;
     /**
      * Called when the user chooses "Insert row from agreement" in the table
      * bubble menu.  Receive the current row index (0-based, after the header)

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/constants/playbook.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Playbook category / hue mappings — DESIGN-REQUIREMENTS.md REQ-T5 + REQ-T6.
+ *
+ * ONE file owns both tables:
+ *   1. V6 backend category → display category → hue (REQ-T5)
+ *   2. CDTS top-level category → playbook icon-tile hue (REQ-T6)
+ *
+ * Hues are Tailwind classes backed by the CSS variables in
+ * src/styles/tokens.css — never hardcode hexes in components, and never
+ * rotate hues decoratively (color always encodes meaning).
+ */
+/** V6 backend categories (lax-ai-legal-editor internal/redlining/v6). */
+export type V6Category = "legal" | "financial" | "grammar" | "ops" | "policy";
+export declare const V6_CATEGORIES: readonly V6Category[];
+/** The five display categories (fig accent families). */
+export type DisplayCategory = "Language" | "Consistency & Clarity" | "Legal Terms" | "Compliance" | "Commercial Accuracy";
+export declare const DISPLAY_CATEGORIES: readonly DisplayCategory[];
+/** V6 category → display category (REQ-T5; the single mapping table). */
+export declare const V6_TO_DISPLAY_CATEGORY: Record<V6Category, DisplayCategory>;
+/** Reverse map (modal category chip-select → V6 write payloads). */
+export declare const DISPLAY_TO_V6_CATEGORY: Record<DisplayCategory, V6Category>;
+export interface CategoryHue {
+    /** Category dot / mark fill (family mid). */
+    dotClass: string;
+    /** Tinted chip background (fig 50s / dark alphas). */
+    tintClass: string;
+    /** Chip text (fig family 600s per REQ-T11). */
+    textClass: string;
+    /**
+     * Caption-size (<14px) text token. Differs from textClass only for
+     * Legal Terms: teal-600 fails the small-text floor on white (REQ-T11
+     * caveat), so captions use the darker --cat-legal-caption.
+     */
+    captionClass: string;
+}
+/** Display category → hue classes (REQ-T5: one hue = one meaning). */
+export declare const CATEGORY_HUES: Record<DisplayCategory, CategoryHue>;
+/** Hue lookup tolerant of unknown/extra backend categories. */
+export declare const hueForV6Category: (category: string) => CategoryHue;
+export declare const displayCategoryForV6: (category: string) => DisplayCategory;
+export type CdtsTopLevel = "Gov" | "Legal" | "Financial" | "Ops";
+export interface CdtsHue {
+    tileClass: string;
+    tintClass: string;
+    textClass: string;
+}
+export declare const CDTS_TOP_LEVEL_HUES: Record<CdtsTopLevel, CdtsHue>;
+/** Case-insensitive lookup; unknown top-levels fall back to neutral Ops. */
+export declare const cdtsHueForCategory: (topLevel: string | undefined) => CdtsHue;
+export type V6Severity = "critical" | "high" | "medium" | "low";
+export type NegotiationTier = 1 | 2 | 3;
+/**
+ * V6 (category, severity) → tier. Mirrors the backend judgment table:
+ * critical → T1; high → T1 for legal/financial else T2; medium → T2; low → T3.
+ */
+export declare const tierFor: (category: string, severity: string) => NegotiationTier;
+/** Modal segmented control → default severity for write payloads. */
+export declare const TIER_TO_SEVERITY: Record<NegotiationTier, V6Severity>;
+/**
+ * Write mapping for the 3-way tier control. Four severities flow through three
+ * tiers, so the mapping is deliberately NOT a bijection:
+ *  - If the selected tier equals the tier the rule's CURRENT severity already
+ *    maps to (per tierFor), the stored severity is preserved verbatim — editing
+ *    a rule without touching the tier control never rewrites its severity
+ *    (this is what makes "high" survive a round-trip).
+ *  - If the user actively changes the tier, the canonical severity for that
+ *    tier is written: 1→critical, 2→medium, 3→low.
+ * "high" is therefore never destroyed here, and is *set* via the Rule
+ * Performance screen's Escalate action (one rung on the 4-value ladder), not
+ * via this control.
+ */
+export declare const severityForTier: (tier: NegotiationTier, category: V6Category, current?: V6Severity) => V6Severity;
+/** 4-value severity ladder, ascending. Escalate = +1 rung, demote = −1 rung. */
+export declare const SEVERITY_LADDER: readonly V6Severity[];
+export interface TierMeta {
+    chip: string;
+    label: string;
+    chipTextClass: string;
+    chipBgClass: string;
+    /**
+     * Negotiation-posture verb for the tier. Present on TIER_META (every tier
+     * has a posture); absent on SEVERITY_META (severity alone doesn't pick one —
+     * high is "walk away" for legal/financial, "negotiate" elsewhere).
+     */
+    action?: "Walk away" | "Negotiate" | "Style";
+}
+/** Rule-list filter: all, one negotiation tier, or "fired in this document". */
+export type RuleFilter = "all" | "t1" | "t2" | "t3" | "fired";
+/** Playbook-list filter: all, on this doc's chain, editable, or bundled. */
+export type PlaybookFilter = "all" | "active" | "workspace" | "bundled";
+/**
+ * REQ-R1 tier chips: tinted bg, no border — T1 red-pink, T2 amber, T3 gray.
+ *
+ * `chip` speaks the ONE severity vocabulary (the wire's critical/high/medium/
+ * low ladder), using each tier's canonical severity per TIER_TO_SEVERITY. The
+ * underlying model is still a 1/2/3 negotiation tier (`NegotiationTier`,
+ * `tierFor`) and the `sev-t1/t2/t3` tokens keep their names. This and
+ * SEVERITY_META are the ONLY places these words are defined; render
+ * `TIER_META[tier].chip` / `SEVERITY_META[sev].chip` rather than hardcoding.
+ */
+export declare const TIER_META: Record<NegotiationTier, Required<TierMeta>>;
+/**
+ * The canonical severity vocabulary: the backend wire's 4-value ladder
+ * rendered onto the 3-tier chip tokens (critical and high share the T1 red —
+ * the rail stays 3 colors per REQ-R1). Review cards, playbook rule rows and
+ * flowdown chips all render from this table; no other severity words exist.
+ */
+export declare const SEVERITY_META: Record<V6Severity, TierMeta>;

package/dist/contexts/CapturedEditsContext.d.ts

@@ -0,0 +1,56 @@
+/**
+ * CapturedEditsContext — the in-memory store behind the Captured Edits tray.
+ *
+ * EPHEMERAL BY DESIGN: no localStorage, no server write, nothing survives the
+ * provider (plan: "Not doing … captured-edit persistence"). The tray states
+ * this in its permanent caption.
+ *
+ * Coalescing contract: `capture` upserts by `clauseKey` — repeat edits to one
+ * clause are ONE card; `before` is frozen at first capture; `after`,
+ * `editCount` and `lastEditedAt` update on every subsequent capture.
+ */
+import { type ReactNode } from "react";
+import { type CapturedEditEvent } from "@/extensions/plugins/CapturedEditsPlugin";
+export interface CapturedEdit {
+    /** Coalescing key: one card per clause. */
+    clauseKey: string;
+    /** Lawyer-readable context: nearest heading text + section ref when derivable. */
+    clauseLabel: string;
+    /** Clause text as of document open (the plugin's baseline). */
+    before: string;
+    /** Current clause text after the human's latest edit. */
+    after: string;
+    firstCapturedAt: number;
+    lastEditedAt: number;
+    /** How many distinct capture events coalesced into this card. */
+    editCount: number;
+    /** UI-only: set after a rule is persisted from this card. */
+    addedRuleId?: string;
+}
+export type CapturedEditsAction = {
+    type: "capture";
+    edit: CapturedEditEvent;
+    at: number;
+} | {
+    type: "markAdded";
+    clauseKey: string;
+    ruleId: string;
+} | {
+    type: "dismiss";
+    clauseKey: string;
+} | {
+    type: "clear";
+};
+/** Pure so the coalescing rules are unit-testable. */
+export declare const capturedEditsReducer: (state: CapturedEdit[], action: CapturedEditsAction) => CapturedEdit[];
+export interface CapturedEditsContextType {
+    edits: CapturedEdit[];
+    capture: (edit: CapturedEditEvent) => void;
+    markAdded: (clauseKey: string, ruleId: string) => void;
+    dismiss: (clauseKey: string) => void;
+    clear: () => void;
+}
+export declare const CapturedEditsProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useCapturedEdits: () => CapturedEditsContextType;

package/dist/contexts/EditorShellContext.d.ts

@@ -1,11 +1,14 @@
 import type { ReactNode } from "react";
 import type { Editor } from "@tiptap/react";
-import type { EditorConfig, ScreenshotCaptureOptions } from "@/config/EditorConfig";
+import type { ApplyRedlineParams, EditorConfig, ScreenshotCaptureOptions } from "@/config/EditorConfig";
 export interface EditorShellContextType {
     editor: Editor;
     editorConfig: EditorConfig;
     redlineItemWidth: number;
     setRedlineItemWidth: (width: number) => void;
+    /** Inject an AI redline (same method handed to onEditorReady) — lets shell
+     *  surfaces (e.g. the Flowdown tab) reuse the one apply path. */
+    applyRedline: (params: ApplyRedlineParams) => void;
 }
 interface EditorShellProviderProps {
     children: ReactNode;