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

package/dist/components/documents/documentDiff.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Aligns git-store diff hunks against the two versions' documents.
+ *
+ * GET /v1/documents/{docId}/diff/{from}/{to} returns structural hunks only —
+ * `{op, lineNo, oldId?, newId?}` where the ids are line-node SHA256s. The
+ * server never sends text, and the FE has no way to resolve a line-node hash,
+ * so rendering a diff means fetching BOTH versions (GET .../versions/{id}) and
+ * aligning the hunks against their `doc.content` arrays.
+ *
+ * The lineNo is NOT on a single side of the diff (internal/git-store/lib/diff
+ * diff.go `Refine`):
+ *
+ *   INSERT  → lineNo indexes the NEW document (newNode.LineNo)
+ *   DELETE  → lineNo indexes the OLD document (oldNode.LineNo)
+ *   REPLACE → lineNo indexes the OLD document (oldNode.LineNo); the matching
+ *             new line is NOT addressed at all, which is why a two-pointer
+ *             walk is needed rather than a lookup.
+ *
+ * Repeated lines make lineNo ambiguous — several hunks can report the SAME
+ * lineNo because the server addresses lines by content hash. See the surplus
+ * handling in `alignDiff`; contract boilerplate hits this routinely.
+ *
+ * Walk order is INSERT-first at each position. A Myers edit script can emit an
+ * insert BEFORE the delete that a later REPLACE was folded from; consuming the
+ * new-side insert first keeps the REPLACE paired with the correct new line.
+ * (Draining old-side first would pair a REPLACE with a line that belonged to
+ * the standalone insert, silently showing the wrong "after" text.)
+ */
+import type { DiffHunk, ProseMirrorDocument, ProseMirrorNode } from "@/api/documentVersions";
+export type DiffRowKind = "equal" | "insert" | "delete" | "replace";
+export interface DiffRow {
+    kind: DiffRowKind;
+    /** 1-based line number in the `from` version, or null for a pure insert. */
+    oldLineNo: number | null;
+    /** 1-based line number in the `to` version, or null for a pure delete. */
+    newLineNo: number | null;
+    oldText: string | null;
+    newText: string | null;
+}
+export interface DiffCounts {
+    inserted: number;
+    deleted: number;
+    replaced: number;
+    unchanged: number;
+}
+export interface AlignedDiff {
+    rows: DiffRow[];
+    counts: DiffCounts;
+    /**
+     * False when the hunks could not be reconciled with the two documents —
+     * every hunk consumed and both sides walked to the end. Callers must not
+     * present an unaligned diff as an accurate account of the change.
+     */
+    aligned: boolean;
+}
+/** Flattens a top-level node to its text, the way a reviewer reads the line. */
+export declare const nodeText: (node: ProseMirrorNode | undefined | null) => string;
+/** A short human label for a line that carries no text (image, rule, …). */
+export declare const lineLabel: (node: ProseMirrorNode | undefined | null) => string;
+/**
+ * Produces renderable diff rows for `from` → `to`.
+ *
+ * `hunks` must be the server's diff for exactly that commit pair; passing a
+ * mismatched pair is what `aligned: false` is there to catch.
+ */
+export declare const alignDiff: (fromDoc: ProseMirrorDocument | null | undefined, toDoc: ProseMirrorDocument | null | undefined, hunks: DiffHunk[]) => AlignedDiff;
+/** One-line summary of a change set, e.g. "1 replaced, 1 added". */
+export declare const summarizeCounts: (counts: DiffCounts) => string;

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

@@ -0,0 +1,4 @@
+export { DocumentVersionHistory } from "./DocumentVersionHistory";
+export type { DocumentVersionHistoryProps } from "./DocumentVersionHistory";
+export { alignDiff, summarizeCounts } from "./documentDiff";
+export type { AlignedDiff, DiffRow, DiffRowKind, DiffCounts } from "./documentDiff";

package/dist/components/flowdown/FlowdownPanel.d.ts

@@ -0,0 +1,28 @@
+import { type PlaybookApiConfig } from "@/api/playbook";
+import { type FlowdownFlagInput, type FlowdownInsertionInput } from "./flowdownModel";
+export interface FlowdownPanelProps {
+    /** `rulebook` flag events with baseline rule ids, from the review stream. */
+    flags: FlowdownFlagInput[];
+    /** `rulebook_insertion` events with baseline rule ids. */
+    insertions: FlowdownInsertionInput[];
+    /** Enables disposition re-hydration (GET /api/redlines?document_id=). */
+    documentId?: string;
+    /** Host user's display name → X-Actor (localStorage `lax.flowdownActor` overrides). */
+    actorName?: string;
+    /** Apply an accepted insertion's text into the editor doc (host owns the editor). */
+    onApplyInsertion?: (insertion: FlowdownInsertionInput) => void;
+    /** Strike a previously-applied insertion (deletion redline mark on its text). */
+    onStrikeInsertion?: (insertion: FlowdownInsertionInput) => void;
+    /** Latest editor doc JSON, for the matrix export body. */
+    getDoc?: () => Record<string, unknown> | null;
+    /**
+     * The completed review this panel's findings came from, off the stream's
+     * `summary` frame (`review_id`). Enables the CPSR audit-packet export, which
+     * is keyed by review — not by document. Absent ⇒ the export is offered but
+     * disabled with the reason shown, rather than 404-ing on click.
+     */
+    reviewId?: string | null;
+    /** API endpoint config (base URL / workspace), shared with the playbook client. */
+    api?: PlaybookApiConfig;
+}
+export declare const FlowdownPanel: ({ flags, insertions, documentId, actorName, onApplyInsertion, onStrikeInsertion, getDoc, reviewId, api, }: FlowdownPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/flowdown/FlowdownRowCard.d.ts

@@ -0,0 +1,27 @@
+import type { Rule } from "@/api/playbook";
+import { type FlowdownRow } from "./flowdownModel";
+export type RuleLookupState = {
+    state: "loading";
+} | {
+    state: "error";
+} | {
+    state: "ok";
+    rule: Rule;
+};
+interface FlowdownRowCardProps {
+    row: FlowdownRow;
+    /** Lazy enrichment cache entry for this row's rule id. */
+    ruleLookup?: RuleLookupState;
+    /** First expand → parent fetches GET /v1/rules/{id}. */
+    onExpand?: (ruleId: string) => void;
+    /** Accept: disposition + apply the insertion text. `teach` = scope "playbook". */
+    onAccept?: (row: FlowdownRow, teach: boolean) => void;
+    /** Not applicable: reject with the REQUIRED note. */
+    onReject?: (row: FlowdownRow, note: string) => void;
+    /** Strike a previously-applied insertion (deletion mark + reject disposition). */
+    onStrike?: (row: FlowdownRow, note: string) => void;
+    /** An action for this row is in flight. */
+    busy?: boolean;
+}
+export declare const FlowdownRowCard: ({ row, ruleLookup, onExpand, onAccept, onReject, onStrike, busy, }: FlowdownRowCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flowdown/flowdownModel.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Flowdown determination model — pure logic for the Flowdown tab.
+ *
+ * The gov baseline lane emits per-clause `rulebook` flags ("Required clause
+ * FAR 52.204-21 is absent … (rule baseline:gov:cyber-safeguarding)") plus at
+ * most one `rulebook_insertion` per rule carrying ready-to-insert
+ * incorporation text. The flag's top-level `rule_id` and the insertion's
+ * `citation.rule_id` share the same `baseline:gov:<topic>` value — that id is
+ * the join key, and its third segment is the topic.
+ *
+ * One RULE is one determination unit (the insertion covers the rule's whole
+ * clause set); its clauses render as lines within the row. No React in here —
+ * everything is unit-testable with plain objects.
+ */
+export interface FlowdownFlagInput {
+    id: string;
+    /** `baseline:gov:<topic>` on the rulecheck lane; absent on other lanes. */
+    rule_id?: string;
+    rationale: string;
+    severity: string;
+}
+export interface FlowdownInsertionInput {
+    id: string;
+    rationale: string;
+    severity: string;
+    /** Ready-to-insert incorporation-by-reference text. */
+    text: string;
+    /** Anchor node, e.g. "[41]". */
+    position_path: string;
+    /** "before" | "after" | "child" relative to the anchor. */
+    placement?: string;
+    /** ProseMirror node type to insert, e.g. "paragraph". */
+    node_type?: string;
+    citation: {
+        rule_id: string;
+    };
+}
+export interface FlowdownClause {
+    flagId: string;
+    /** "FAR 52.204-21" — parsed from the flag rationale; null when unparsable. */
+    clause: string | null;
+    rationale: string;
+}
+export interface FlowdownDetermination {
+    status: "accepted" | "rejected";
+    note?: string;
+    scope?: string;
+    /** The persisted record the disposition landed on (insertion or flag id). */
+    recordId?: string;
+}
+/** One rule = one determination unit; its clauses list within the row. */
+export interface FlowdownRow {
+    ruleId: string;
+    topic: string;
+    severity: string;
+    clauses: FlowdownClause[];
+    insertion?: FlowdownInsertionInput;
+    determination?: FlowdownDetermination;
+    /** The insertion's proposed text was applied into the editor doc. */
+    applied?: boolean;
+}
+export interface FlowdownGroup {
+    topic: string;
+    rows: FlowdownRow[];
+}
+export type FlowdownRowStatus = "missing" | "insert_proposed" | "determined";
+export declare const isBaselineRuleId: (id: string | undefined) => id is string;
+/** "baseline:gov:cyber-safeguarding" → "cyber-safeguarding". */
+export declare const topicOfRuleId: (ruleId: string) => string;
+/** "cyber-safeguarding" → "Cyber safeguarding". */
+export declare const topicLabel: (topic: string) => string;
+/**
+ * "Required clause FAR 52.204-21 is absent …" → "FAR 52.204-21".
+ * The rulecheck lane's canonical citation form is "PREFIX N.NNN(-N)".
+ */
+export declare const parseClauseRef: (rationale: string) => string | null;
+/** "[41]" or "41,0" → [41, 0] — same encoding useRedlineReview parses. */
+export declare const parseInsertionNodePath: (path: string) => number[];
+/**
+ * Pair the baseline flags with their sibling insertions by shared rule id and
+ * group the rows by topic. Non-baseline events are ignored. Topic order and
+ * row order follow first appearance in the stream (document/severity order is
+ * the backend's choice; we preserve it).
+ */
+export declare const buildFlowdownGroups: (flags: readonly FlowdownFlagInput[], insertions: readonly FlowdownInsertionInput[]) => FlowdownGroup[];
+/**
+ * Total determination rows buildFlowdownGroups yields for these stream
+ * inputs — one row per baseline rule, the unit the Flowdown tab renders.
+ * Used for the tab badge so it can never disagree with the tab body.
+ */
+export declare const flowdownRowCount: (flags: readonly FlowdownFlagInput[], insertions: readonly FlowdownInsertionInput[]) => number;
+export declare const rowStatus: (row: FlowdownRow) => FlowdownRowStatus;
+/** The note is REQUIRED before a not-applicable rejection can be submitted. */
+export declare const canSubmitRejection: (note: string) => boolean;
+/** Structural subset of api/redlines' DispositionRecord. */
+export interface FlowdownDispositionRecord {
+    ID: string;
+    State: string;
+    RejectScope?: string;
+    RejectNote?: string;
+    Lane?: string;
+    Suggestion?: {
+        rationale?: string;
+        severity?: string;
+        text?: string;
+        position_path?: string;
+        placement?: string;
+        node_type?: string;
+        citation?: {
+            rule_id?: string;
+        };
+    };
+}
+/**
+ * Rebuild row inputs from persisted records so the tab is populated on a
+ * fresh page load (or after any live-stream state loss) — persistence, not
+ * the stream, is the source of truth for what needs determining. Records
+ * written before Citation.RuleID was persisted on flags fall back to parsing
+ * the rule id out of the rationale's "(rule baseline:gov:<topic>)" tail.
+ */
+export declare const recordsToInputs: (records: readonly FlowdownDispositionRecord[]) => {
+    flags: FlowdownFlagInput[];
+    insertions: FlowdownInsertionInput[];
+};
+/**
+ * Overlay persisted dispositions onto rows. A record matches a row when its
+ * id is the row's insertion id or one of its flag ids; the insertion id wins
+ * when both were disposed (it is the disposition the accept path writes).
+ * Rows without a matching non-proposed record keep their current
+ * determination (a merge, not a reset), so in-session decisions survive a
+ * fetch that raced them.
+ */
+export declare const mergeDispositions: (groups: readonly FlowdownGroup[], records: readonly FlowdownDispositionRecord[]) => FlowdownGroup[];
+export interface FlowdownProgress {
+    total: number;
+    determined: number;
+    inserted: number;
+    rejected: number;
+}
+export declare const flowdownProgress: (groups: readonly FlowdownGroup[]) => FlowdownProgress;
+/**
+ * Project rows onto the flowdown-matrix export's entries: one entry per
+ * parsed clause. `clause` is the bare number (the backend's contract),
+ * `source` the full FAR/DFARS citation; the whole baseline is `required`.
+ */
+export declare const matrixEntriesFromGroups: (groups: readonly FlowdownGroup[]) => {
+    clause: string;
+    source: string;
+    classification: string;
+}[];

package/dist/components/history/PlaybookVersionHistory.d.ts

@@ -0,0 +1,10 @@
+import { type VersionsApiConfig } from "@/api/versions";
+export interface PlaybookVersionHistoryProps {
+    /** The playbook whose history to show. */
+    playbookId: string;
+    /** Display name for the header (falls back to the id). */
+    playbookName?: string;
+    /** API endpoint config (base URL / workspace). */
+    api?: VersionsApiConfig;
+}
+export declare const PlaybookVersionHistory: ({ playbookId, playbookName, api, }: PlaybookVersionHistoryProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/history/versionDiff.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Rule-id diff between two playbook versions' /rules payloads (client-side —
+ * the backend serves each version's rules, never a diff).
+ */
+import type { VersionRule } from "@/api/versions";
+export interface RuleDiff {
+    /** Rule ids present in `current` but not `previous`. */
+    added: string[];
+    /** Rule ids present in `previous` but not `current`. */
+    removed: string[];
+    /** Rule ids present in both whose rule payload differs. */
+    changed: string[];
+}
+export declare const diffRules: (previous: VersionRule[], current: VersionRule[]) => RuleDiff;

package/dist/components/playbook/AllPlaybooksView.d.ts

@@ -0,0 +1,41 @@
+import { type Playbook, type Rule } from "@/api/playbook";
+import type { PlaybookFilter } from "@/constants/playbook";
+import { type CdtsScope } from "@/utils/cdts";
+import { type FetchState } from "./usePlaybookData";
+export interface AllPlaybooksViewProps {
+    docScope: CdtsScope;
+    playbooksState: FetchState<Playbook[]>;
+    onRetry: () => void;
+    search: string;
+    onSearchChange: (query: string) => void;
+    filter: PlaybookFilter;
+    onFilterChange: (filter: PlaybookFilter) => void;
+    firedCounts: ReadonlyMap<string, number> | null;
+    justSavedRuleIds: ReadonlySet<string>;
+    onEditRule: (rule: Rule) => void;
+    onDuplicateRule: (rule: Rule, bundled: boolean) => void;
+    onShowSuggestions?: (ruleId: string) => void;
+    onNewPlaybook?: () => void;
+    onImport?: () => void;
+    /**
+     * Drill-in state lifted to the panel: while a playbook is open the drill-in
+     * renders its own footer, so the panel must hide the list-level one rather
+     * than stacking two footers.
+     */
+    onDrillChange?: (playbook: Playbook | null) => void;
+    onNewRule?: (playbook: Playbook) => void;
+    onDeleteRule?: (rule: Rule) => void;
+    /** Opens the full-page playbook surface (⤢ in the drill-in footer). */
+    onOpenFullPage?: (playbook: Playbook) => void;
+    /**
+     * Duplicates a whole bundled playbook into the workspace. Omitted → the
+     * built-in flow runs (duplicatePlaybookToWorkspace: POST /v1/playbooks +
+     * one rule copy per rule).
+     */
+    onDuplicatePlaybook?: (playbook: Playbook) => void;
+    /** Rules ignored workspace-wide (durable rule-overrides). */
+    ignoredRuleIds?: ReadonlySet<string>;
+    onIgnoreRule?: (rule: Rule) => void;
+    onUnignoreRule?: (ruleId: string) => void;
+}
+export declare const AllPlaybooksView: (props: AllPlaybooksViewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/DerivedRulebookView.d.ts

@@ -0,0 +1,9 @@
+export interface DerivedRulebookViewProps {
+    /** Prime contract id — the rulebook key. */
+    primeContractId: string;
+    /** Shown in the header above the coordinate line. */
+    title?: string;
+    onClose?: () => void;
+    className?: string;
+}
+export declare const DerivedRulebookView: (props: DerivedRulebookViewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/DraftedRulePreview.d.ts

@@ -0,0 +1,17 @@
+/**
+ * DraftedRulePreview — the single way a drafted (uncommitted) rule renders:
+ * category hue dot + display category + severity chip, the caller-supplied
+ * rule-text body, then the one-line predicate summary. Shared by
+ * AddAsRuleModal and PromotionSuggestions so the two preview surfaces cannot
+ * drift.
+ */
+import type { ReactNode } from "react";
+import type { PredicateNode } from "@/api/ruleBuilder";
+export interface DraftedRulePreviewProps {
+    category: string;
+    severity: string;
+    predicate?: PredicateNode;
+    /** The rule-text body, rendered between the chip row and the predicate. */
+    children?: ReactNode;
+}
+export declare const DraftedRulePreview: ({ category, severity, predicate, children, }: DraftedRulePreviewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/EffectiveRulesView.d.ts

@@ -0,0 +1,11 @@
+import { type PlaybookApiConfig } from "@/api/playbook";
+import { type CdtsScope } from "@/utils/cdts";
+export interface EffectiveRulesViewProps {
+    /** Resolves the attached prime (`lax.primeContract.{documentId}`) so this
+     *  prime's derived rulebook joins the union, exactly as a run would. */
+    documentId?: string;
+    /** CDTS coordinate for the walk. Omitted ⇒ the workspace's full union. */
+    scope?: CdtsScope;
+    api?: PlaybookApiConfig;
+}
+export declare const EffectiveRulesView: ({ documentId, scope, api }: EffectiveRulesViewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/NewRuleDrawer.d.ts

@@ -0,0 +1,11 @@
+import { type Playbook, type Rule } from "@/api/playbook";
+export interface NewRuleDrawerProps {
+    playbook: Playbook;
+    /** Documents currently using this playbook — costs the re-review offer. */
+    affectedDocumentCount?: number;
+    onClose: () => void;
+    onSaved: (rule: Rule) => void;
+    /** Called after save when the author opted into re-reviewing open documents. */
+    onRunAgainstOpenDocuments?: () => void;
+}
+export declare const NewRuleDrawer: (props: NewRuleDrawerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/PlaybookCard.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PlaybookCard — REQ-P4: CDTS-hue icon tile (REQ-T6) · name (one line,
+ * ellipsis) · CDTS coordinate (one line, ellipsis) · green "active" chip when
+ * on this document's walk-up chain · rule count · chevron (drills in).
+ */
+import type { Playbook } from "@/api/playbook";
+export interface PlaybookCardProps {
+    playbook: Playbook;
+    active: boolean;
+    ruleCount?: number;
+    onOpen: (playbook: Playbook) => void;
+}
+export declare const PlaybookCard: ({ playbook, active, ruleCount, onOpen }: PlaybookCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/PlaybookPage.d.ts

@@ -0,0 +1,29 @@
+import { type Playbook, type Rule } from "@/api/playbook";
+export interface PlaybookPageProps {
+    playbook: Playbook;
+    /** rule_id → times fired in the currently-open document. */
+    firedCounts?: ReadonlyMap<string, number> | null;
+    /**
+     * Dismisses the modal (✕, Esc, or scrim click). Aliased by
+     * `onBackToDocument` for callers written against the full-page version.
+     */
+    onClose?: () => void;
+    /** @deprecated Use `onClose`. Kept so existing call sites keep working. */
+    onBackToDocument?: () => void;
+    /** Breadcrumb root, e.g. the workspace name. */
+    workspaceName?: string;
+    /** Header meta line, e.g. "Edited 3 days ago · A. Reyes". */
+    editedLabel?: string;
+    /** Documents this playbook is active on (header chip + drawer cost line). */
+    activeDocumentCount?: number;
+    onEditRule?: (rule: Rule) => void;
+    onDuplicatePlaybook?: (playbook: Playbook) => void;
+    onOpenSettings?: (playbook: Playbook) => void;
+    /**
+     * Version history. No backend endpoint exists for this yet, so the link is
+     * only rendered when the host supplies a handler.
+     */
+    onOpenVersionHistory?: (playbook: Playbook) => void;
+    className?: string;
+}
+export declare const PlaybookPage: (props: PlaybookPageProps) => import("react").ReactPortal;

package/dist/components/playbook/PlaybookPanel.d.ts

@@ -0,0 +1,73 @@
+import { type Playbook, type PlaybookApiConfig } from "@/api/playbook";
+import { type CdtsScope } from "@/utils/cdts";
+import { type ReviewResponseLike } from "@/utils/groundingAdapter";
+export interface SaveAsRulePrefill {
+    name?: string;
+    text?: string;
+    category?: string;
+    sourceRuleId?: string;
+    section?: string;
+    clauseQuote?: string;
+}
+/** Dismissals the host persists across documents, keyed by rule id. */
+export interface RuleDismissalRecord {
+    ruleId: string;
+    documentCount: number;
+}
+export interface PlaybookPanelProps {
+    /** Document CDTS coordinate — drives the this-document walk-up chain. */
+    documentScope: CdtsScope;
+    documentId?: string;
+    workspaceId?: string;
+    workspaceName?: string;
+    /** Regime chips on the scope card, e.g. ["FAR / DFARS", "gov"]. */
+    regimeLabels?: string[];
+    /** Latest review response (grounding[] sidecar) — null before any run. */
+    reviewResponse?: ReviewResponseLike | null;
+    onClose?: () => void;
+    /** Cross-link: rule detail → AI tab filtered to the rule (REQ-B3). */
+    onShowSuggestionsForRule?: (ruleId: string) => void;
+    /**
+     * Optional one-click re-run offer after a save (REQ-B2). Never auto-runs.
+     * Receives the rules the reviewer suppressed, so the next run can pass them
+     * as `disabled_rule_ids` — per-run only, no playbook mutation.
+     */
+    onRunReview?: (options?: {
+        disabledRuleIds: string[];
+    }) => void;
+    /**
+     * Rules the server reports the reviewer keeps rejecting (`rule_fatigue`).
+     * Server-side and durable per (workspace, rule), so it survives reloads and
+     * counts real rejections rather than this session's dismissals.
+     */
+    ruleFatigue?: readonly {
+        rule_id: string;
+        rejections: number;
+    }[];
+    /** Cross-link target: suggestion grounding → "View rule ⚖" (REQ-B3). */
+    focusedRuleId?: string | null;
+    /** Dismiss + save-as-rule trigger: opens the editor pre-filled (REQ-M1). */
+    saveAsRulePrefill?: SaveAsRulePrefill | null;
+    onNewPlaybook?: () => void;
+    onImportPlaybook?: () => void;
+    onOpenSettings?: () => void;
+    /** Auth/baseUrl pass-through for src/api/playbook.ts (REQ-D1). */
+    api?: PlaybookApiConfig;
+    /**
+     * Opens the full-page playbook surface. This library ships no router, so the
+     * host decides how to route/mount `PlaybookPage`; omitted → no ⤢ affordance.
+     */
+    onOpenPlaybookPage?: (playbook: Playbook) => void;
+    /**
+     * Prior dismissals of a rule across other documents. Dismissal itself is
+     * client-side, but the *count* that drives the escalation nudge only means
+     * anything if the host persists it; omitted → the nudge never fires.
+     */
+    priorDismissals?: readonly RuleDismissalRecord[];
+    /** Fired when the reviewer asks the owner to remove a repeatedly-dismissed rule. */
+    onSuggestRuleRemoval?: (ruleId: string) => void;
+    /** Name shown on the escalation nudge ("goes to <owner>"). */
+    playbookOwnerName?: string;
+    className?: string;
+}
+export declare const PlaybookPanel: (props: PlaybookPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/PromotionSuggestions.d.ts

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

package/dist/components/playbook/ReprioritizeDialog.d.ts

@@ -0,0 +1,16 @@
+import { type V6Severity } from "@/constants/playbook";
+export type ReprioritizeDirection = "demote" | "escalate";
+/** One rung on the ladder; undefined when already at the end. */
+export declare const steppedSeverity: (current: V6Severity, direction: ReprioritizeDirection) => V6Severity | undefined;
+export interface ReprioritizeDialogProps {
+    direction: ReprioritizeDirection;
+    ruleName: string;
+    currentSeverity: V6Severity;
+    nextSeverity: V6Severity;
+    busy: boolean;
+    /** Inline error under the textarea; null when none. */
+    error: string | null;
+    onCancel: () => void;
+    onConfirm: (note: string) => void;
+}
+export declare const ReprioritizeDialog: (props: ReprioritizeDialogProps) => import("react").ReactPortal;

package/dist/components/playbook/RuleDetail.d.ts

@@ -0,0 +1,27 @@
+/**
+ * RuleDetail — REQ-R3 inline accordion body: full rule text in an inset well
+ * → meta chips → actions row. REQ-R4 bundled/workspace asymmetry: bundled
+ * rules NEVER get an Edit affordance that would 403 — only "Duplicate to
+ * workspace". Rule text renders as text, never HTML.
+ */
+import { type Rule } from "@/api/playbook";
+import { type FiredState } from "./primitives";
+export interface RuleDetailProps {
+    rule: Rule;
+    bundled: boolean;
+    fired: FiredState;
+    onEdit?: (rule: Rule) => void;
+    onDuplicate?: (rule: Rule) => void;
+    onShowSuggestions?: (ruleId: string) => void;
+    /** Dismissed for this document only (client-side, reversible). */
+    dismissed?: boolean;
+    onDismiss?: (rule: Rule) => void;
+    onRestore?: (ruleId: string) => void;
+    /** Permanent removal (DELETE /v1/rules/{id}). Omitted → not offered. */
+    onDelete?: (rule: Rule) => void;
+    /** Workspace-wide ignore (PUT/DELETE /v1/rule-overrides/{family}). */
+    ignored?: boolean;
+    onIgnore?: (rule: Rule) => void;
+    onUnignore?: (ruleId: string) => void;
+}
+export declare const RuleDetail: ({ rule, bundled, fired, onEdit, onDuplicate, onShowSuggestions, dismissed, onDismiss, onRestore, onDelete, ignored, onIgnore, onUnignore, }: RuleDetailProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/RuleEditorFields.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Rule editor form fields — REQ-M2. Field-level validation renders inline
+ * (never a toast, §5). All text renders as text, never HTML.
+ */
+import { type DisplayCategory, type NegotiationTier } from "@/constants/playbook";
+export interface RuleEditorProvenance {
+    sourceRuleId?: string;
+    section?: string;
+    clauseQuote?: string;
+}
+export interface RuleFieldErrors {
+    name?: string;
+    category?: string;
+    text?: string;
+    scope?: string;
+}
+export interface ScopeOption {
+    id: string;
+    label: string;
+}
+export interface RuleEditorFieldsProps {
+    disabled: boolean;
+    name: string;
+    onNameChange: (value: string) => void;
+    category: DisplayCategory | null;
+    onCategoryChange: (value: DisplayCategory) => void;
+    tier: NegotiationTier;
+    onTierChange: (value: NegotiationTier) => void;
+    text: string;
+    onTextChange: (value: string) => void;
+    scope: "document" | "playbook";
+    onScopeChange: (value: "document" | "playbook") => void;
+    playbookOptions: ScopeOption[];
+    selectedPlaybookId: string | null;
+    onPlaybookChange: (id: string) => void;
+    documentScopeAvailable: boolean;
+    errors: RuleFieldErrors;
+    provenance?: RuleEditorProvenance;
+    /** Stack the scope cards vertically (<640px sheet, REQ-V3). */
+    stacked: boolean;
+}
+export declare const RuleEditorFields: (props: RuleEditorFieldsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/playbook/RuleEditorModal.d.ts

@@ -0,0 +1,27 @@
+import { type CdtsScope, type Rule } from "@/api/playbook";
+import { type RuleEditorProvenance, type ScopeOption } from "./RuleEditorFields";
+export interface RuleEditorSession {
+    mode: "create" | "edit";
+    /** Existing rule (edit mode). */
+    rule?: Rule;
+    /** Prefill for create mode (duplicate / dismiss + save-as-rule). */
+    prefill?: {
+        name?: string;
+        text?: string;
+        category?: string;
+    };
+    /** Blue provenance strip for the save-as-rule path (REQ-M1). */
+    provenance?: RuleEditorProvenance;
+    title?: string;
+}
+export interface RuleEditorModalProps {
+    session: RuleEditorSession;
+    documentId?: string;
+    /** The document's CDTS scope — carried onto the auto-created doc playbook. */
+    documentScope?: CdtsScope;
+    playbookOptions: ScopeOption[];
+    defaultPlaybookId?: string;
+    onClose: () => void;
+    onSaved: (rule: Rule) => void;
+}
+export declare const RuleEditorModal: (props: RuleEditorModalProps) => import("react").ReactPortal;

package/dist/components/playbook/RulePerformancePanel.d.ts

@@ -0,0 +1,4 @@
+export interface RulePerformancePanelProps {
+    onClose?: () => void;
+}
+export declare const RulePerformancePanel: (props: RulePerformancePanelProps) => import("react/jsx-runtime").JSX.Element;