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

package/dist/components/redline/AiReviewPanel.d.ts

@@ -0,0 +1,194 @@
+/**
+ * AiReviewPanel — a minimal, neat AI redline-review side rail.
+ *
+ * Layout follows the "NDA Redline Review" reference (severity chip · clause ref ·
+ * title · rationale · playbook § ref · from→to diff · Accept/Reject · resolved
+ * states) but is skinned entirely in the editor's own design system
+ * (src/styles/tokens.css): Inter (--font-ui), --action blue, T1/T2/T3 severity
+ * tokens, --font-mono-rule for refs, --radius-* corners, cool neutrals. Purely
+ * presentational — the parent owns the decision state — except US-B7
+ * persistence: with `persist` set, decisions also PATCH the suggestion store
+ * (best-effort) and prior-session dispositions re-hydrate on mount.
+ */
+import { type ReactNode } from "react";
+import { type RedlinesApiConfig } from "@/api/redlines";
+import type { R1Provenance, SuggestionPositions } from "@/api/r1";
+import type { ScopeWarningPayload } from "@/api/redlineStream";
+export type ReviewSeverity = "high" | "medium" | "low";
+export type ReviewStatus = "pending" | "accepted" | "rejected";
+export type ReviewCategory = "legal" | "operational" | "financial" | "grammar" | "policy";
+export interface ReviewItem {
+    id: string;
+    /** e.g. "§2 · Obligations" */
+    clause: string;
+    /** V6 category — drives the category tag hue (mapped to the design-system category hues). */
+    category: ReviewCategory;
+    severity: ReviewSeverity;
+    title: string;
+    rationale: string;
+    /** e.g. "Playbook 3.2 — Term limits" */
+    playbookRef?: string;
+    /**
+     * `citation.playbook_id` — the playbook that produced this item. Drives the
+     * playbook filter buckets; absent on lanes that carry no citation.
+     */
+    playbookId?: string;
+    /**
+     * Exact source text the finding points at, quoted neutrally. Distinct from
+     * `from`: an excerpt is being flagged, not removed, so it must never render
+     * struck through.
+     */
+    excerpt?: string;
+    /** prior text (struck through) — omit for pure insertions */
+    from?: string;
+    /** proposed text — omit for pure deletions */
+    to?: string;
+    status: ReviewStatus;
+    /** R1: where the rule came from — "Prime §X" vs CDTS badge + click-through excerpt. */
+    provenance?: R1Provenance;
+    /** R1: preferred / fallback / walkaway position texts for suggestions. */
+    positions?: SuggestionPositions;
+    /** C2: which stream lane produced this finding — drives the lane identity chip. */
+    lane?: "panel" | "chronology" | "insertion";
+    /** C2 panel lane: personas that reviewed the section (attribution badges). */
+    personas?: string[];
+    /** C2 panel lane: the panel escalated this finding to a human. */
+    escalated?: boolean;
+    /** C2 insertions: human-readable placement, e.g. "Insert after node [10] · paragraph". */
+    placement?: string;
+    /** C2: how the suggestion text was produced — "drafted" | "template_fallback". */
+    textProvenance?: string;
+    /**
+     * US-B7: the suggestion store's record id (the SSE event's own id — the
+     * store preserves stream ids) — the PATCH target for persisted
+     * dispositions. Findings already carry the stream id as `id`; materialized
+     * redlines carry the editor MARK id there, so the host supplies the mark's
+     * groupId here. Persistence falls back to `id` when absent.
+     */
+    streamId?: string;
+}
+/** One playbook this review ran against, as listed under "Reviewed against". */
+export interface ReviewedPlaybook {
+    id: string;
+    name: string;
+    /** e.g. "Gov › Services › MSA" — shown under the name. */
+    scopeLabel?: string;
+    ruleCount?: number;
+    /** Bundled/read-only library playbook. */
+    bundled?: boolean;
+}
+interface AiReviewPanelProps {
+    items: ReviewItem[];
+    /** Advisory findings (grammar/rulebook/irregularity lanes) — no decision bar. Rendered below `items`. */
+    findings?: ReviewItem[];
+    /** R1: minor deviations hidden behind an "N suppressed (show)" affordance below findings. */
+    suppressedFindings?: ReviewItem[];
+    selectedId?: string | null;
+    playbookName?: string;
+    /**
+     * The playbooks this review actually ran against. When supplied, the
+     * "Reviewed against …" line becomes a disclosure that lists them, and each
+     * name opens that playbook's rules. Without it the line stays a plain label.
+     */
+    reviewedAgainst?: readonly ReviewedPlaybook[];
+    /** Opens the rules modal for one playbook (PlaybookPage). */
+    onOpenPlaybook?: (playbook: ReviewedPlaybook) => void;
+    /**
+     * Workspace-controls §4: opens the attached prime's derived-rulebook view
+     * ("View derived rules" in the Parent contract section). Without it the
+     * link doesn't render.
+     */
+    onViewDerivedRules?: (primeContractId: string) => void;
+    onSelect?: (id: string) => void;
+    onAccept?: (id: string) => void;
+    onReject?: (id: string) => void;
+    onUndo?: (id: string) => void;
+    /**
+     * The one resolved item that can still be undone (the most recent decision).
+     * Undo restores a document snapshot taken just before that decision, so only
+     * the latest is reversible — offering it on older cards would silently revert
+     * every decision made after them.
+     */
+    undoableId?: string | null;
+    /** Dismiss every pending redline sharing this item's rule. */
+    onIgnoreRule?: (item: ReviewItem) => void;
+    onAcceptAll?: () => void;
+    /**
+     * US-B7: persist Accept/Reject dispositions to the suggestion store
+     * (PATCH /api/redlines/{id}/accept|reject, X-Actor) and re-hydrate prior
+     * decisions on mount (GET /api/redlines?document_id=). Best-effort: a
+     * failed PATCH shows an inline error but never blocks or reverts the local
+     * decision. Also gives advisory findings a decision bar — grammar/rulebook/
+     * advisory findings are dispositionable records too, they just never touch
+     * the document.
+     */
+    persist?: {
+        documentId: string;
+        /** Host user's display name → X-Actor (localStorage `lax.flowdownActor` overrides). */
+        actorName?: string;
+        /** API endpoint config (base URL / workspace), shared with the flowdown tab. */
+        api?: RedlinesApiConfig;
+    };
+    /**
+     * A2: lanes the backend reported as degraded (summary.lanes_degraded).
+     * Non-empty renders a prominent banner (not dismissable until acknowledged)
+     * and marks the review header as partial.
+     */
+    degradedLanes?: readonly string[];
+    /** A2: mid-stream `event: error` frames arrived — also marks the review partial. */
+    hadStreamErrors?: boolean;
+    /**
+     * Scope warnings (`scope_warning` stream events / summary.scope_warnings).
+     * The review's substantive scope collapsed — gov indicia without the gov
+     * regime, low coverage ratios, or an empty rulebook. Non-empty renders a
+     * prominent, NON-dismissable banner: unlike the degraded-lane banner there
+     * is no acknowledge affordance, because a silently under-scoped review is
+     * exactly the failure the banner exists to keep loud.
+     */
+    scopeWarnings?: readonly ScopeWarningPayload[];
+    /**
+     * C1: regime selector rendered above the run button. `available` is the full
+     * regime vocabulary; `selected` (defaulted by the host to the regimes
+     * applicable to the document's scope) is what the next run sends.
+     */
+    regimeSelector?: {
+        available: readonly string[];
+        selected: readonly string[];
+        onChange: (next: string[]) => void;
+    };
+    /**
+     * Flowdown tab (gov-baseline determinations). When set, a minimal two-tab
+     * bar renders at the top of the panel — "Review" (the existing list) and
+     * "Flowdown" (this node). Absent ⇒ the panel is unchanged.
+     */
+    flowdownContent?: ReactNode;
+    /** Optional extra sidebar tabs (Sprint-2): playbook version history / audit trail. */
+    historyContent?: ReactNode;
+    auditContent?: ReactNode;
+    /** Post-review executive summary tab (r1/ReviewSummaryTab). */
+    summaryContent?: ReactNode;
+    /**
+     * Resolved-rulebook preview tab (playbook/EffectiveRulesView) — what WILL
+     * fire here after the precedence ladder, and what was superseded. Config,
+     * not results, but it belongs beside the review it predicts.
+     */
+    effectiveContent?: ReactNode;
+    /** Row count badge for the Flowdown tab label. */
+    flowdownCount?: number;
+    /** Optional "Run AI Redline" action; when set, a primary button renders in the header. */
+    onRun?: () => void;
+    /** Disables the run button and shows a progress label while a review is in flight. */
+    running?: boolean;
+    /** Label for the run button (default "Run AI Redline"). */
+    runLabel?: string;
+    /** width in px (default 392, matching the reference rail) */
+    width?: number;
+    /**
+     * Render without the fixed-width <aside> chrome so the panel fills its
+     * container (e.g. the editor sidebar's expanded content slot). The header +
+     * scrollable card list are identical; only the outer wrapper differs.
+     */
+    embedded?: boolean;
+}
+export declare const AiReviewPanel: ({ items, findings, suppressedFindings, selectedId, playbookName, reviewedAgainst, onOpenPlaybook, onViewDerivedRules, onSelect, onAccept, onReject, onUndo, undoableId, onIgnoreRule, onAcceptAll, persist, degradedLanes, hadStreamErrors, scopeWarnings, regimeSelector, flowdownContent, flowdownCount, historyContent, auditContent, summaryContent, effectiveContent, onRun, running, runLabel, width, embedded, }: AiReviewPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/redline/RedlineHoverCard.d.ts

@@ -0,0 +1,13 @@
+import type { ReviewItem } from "./AiReviewPanel";
+export interface RedlineHoverCardProps {
+    item: ReviewItem;
+    /** bounding rect of the hovered mark (already first-line-clamped by caller) */
+    anchorRect: DOMRect;
+    onAccept: (id: string) => void;
+    onReject: (id: string) => void;
+    /** caller cancels the close timer */
+    onMouseEnter: () => void;
+    /** caller starts the close timer */
+    onMouseLeave: () => void;
+}
+export declare const RedlineHoverCard: ({ item, anchorRect, onAccept, onReject, onMouseEnter, onMouseLeave, }: RedlineHoverCardProps) => import("react").ReactPortal;

package/dist/components/redline/RedlineItem.d.ts

@@ -10,8 +10,20 @@ export interface RedlineComment {
 export interface RedlineChange {
     id: string;
     markIds?: string[];
+    /** Mark groupId when set (e.g. the AI/backend suggestion id from applyRedline).
+     *  Lets onRedlineDecision consumers map a decision back to its source suggestion. */
+    groupId?: string;
     type: RedlineChangeType;
     content: string;
+    /**
+     * Replace halves kept apart. `content` concatenates every marked node in the
+     * group, so on a `*-replace` it mixes the struck text with the proposed text
+     * and neither can be recovered from it. These two preserve the before/after
+     * the review card needs. Set on every change, not just replaces, so a
+     * consumer never has to branch on type to read them.
+     */
+    deletedContent?: string;
+    insertedContent?: string;
     userId: string;
     userName: string;
     userProfilePic?: string;

package/dist/components/redline/ReviewCard.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ReviewCard — the shared inner card body for AI redline-review cards.
+ *
+ * Single source of truth for the card content rendered by both the
+ * right-rail AiReviewPanel and the floating RedlineHoverCard: severity chip ·
+ * category · clause ref · title · rationale · playbook § ref · from→to diff ·
+ * Accept/Reject (pending) or Undo (resolved). Skinned entirely via
+ * src/styles/tokens.css design tokens — no hardcoded colors.
+ */
+import type { ReviewItem } from "./AiReviewPanel";
+export declare const CAT: {
+    readonly legal: {
+        readonly label: "Legal";
+        readonly dot: "var(--cat-legal)";
+        readonly text: "var(--cat-legal-caption)";
+    };
+    readonly financial: {
+        readonly label: "Financial";
+        readonly dot: "var(--cat-commercial)";
+        readonly text: "var(--cat-commercial-text)";
+    };
+    readonly operational: {
+        readonly label: "Operational";
+        readonly dot: "var(--cdts-ops)";
+        readonly text: "var(--cdts-ops-text)";
+    };
+    readonly grammar: {
+        readonly label: "Grammar";
+        readonly dot: "var(--cat-language)";
+        readonly text: "var(--cat-language-text)";
+    };
+    readonly policy: {
+        readonly label: "Policy";
+        readonly dot: "var(--cat-compliance)";
+        readonly text: "var(--cat-compliance-text)";
+    };
+};
+export declare const REVIEW_CARD_CSS = "\n.arp-root{--arp-mono:var(--font-mono-rule);box-sizing:border-box}\n.arp-root *{box-sizing:border-box}\n.arp-link{background:none;border:none;padding:0;cursor:pointer;font-family:var(--font-ui);color:var(--action-link);font-weight:600}\n.arp-link:hover{text-decoration:underline}\n.arp-card{transition:border-color .15s ease, box-shadow .15s ease, background .15s ease}\n.arp-card:hover{border-color:var(--action)!important}\n.arp-btn{font-family:var(--font-ui);border-radius:var(--radius-control);cursor:pointer;font-weight:600;font-size:12px;transition:background .15s ease, border-color .15s ease}\n/* Transparent border, not `none`: Reject carries a 1px border, and under\n   `flex:1` the border sits outside the flex base size, so a borderless Accept\n   renders 2px narrower than its sibling. Matching the box metrics keeps the\n   pair symmetric. */\n.arp-accept{background:var(--action);color:var(--action-on);border:1px solid transparent;box-shadow:0 1px 2px 0 rgba(0,0,0,.05)}\n.arp-accept:hover{background:var(--action-hover)}\n.arp-reject{background:var(--pb-panel);color:var(--pb-text-secondary);border:1px solid var(--pb-border-strong);box-shadow:0 1px 2px 0 rgba(0,0,0,.05)}\n.arp-reject:hover{background:var(--pb-card)}\n.dark .arp-accept,.dark .arp-reject{box-shadow:0 1px 3px rgba(0,0,0,.4)}\n.arp-undo{background:none;border:none;padding:0;cursor:pointer;font-family:var(--font-ui);color:var(--pb-text-muted);font-weight:500;font-size:11.5px;align-self:flex-start}\n.arp-undo:hover{color:var(--pb-text-primary);text-decoration:underline}\n.arp-ignore{background:none;border:none;padding:0;cursor:pointer;font-family:var(--font-ui);color:var(--pb-text-muted);font-weight:500;font-size:11px;white-space:nowrap;flex:none}\n.arp-ignore:hover{color:var(--st-error);text-decoration:underline}\n.arp-scroll{scrollbar-width:thin}\n";
+export interface ReviewCardBodyProps {
+    item: ReviewItem;
+    onAccept?: (id: string) => void;
+    onReject?: (id: string) => void;
+    onUndo?: (id: string) => void;
+    /** Dismiss every pending redline produced by this card's rule. */
+    onIgnoreRule?: (item: ReviewItem) => void;
+    /** Advisory findings have no decision bar (no Accept/Reject, no Undo) regardless of status. */
+    advisory?: boolean;
+}
+export declare const ReviewCardBody: ({ item, onAccept, onReject, onUndo, onIgnoreRule, advisory }: ReviewCardBodyProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,3 +1,9 @@
 export { RedlinePanel } from './RedlinePanel';
 export { RedlineItem } from './RedlineItem';
 export type { RedlineChange, RedlineChangeType, RedlineComment } from './RedlineItem';
+export { AiReviewPanel } from './AiReviewPanel';
+export type { ReviewItem, ReviewSeverity, ReviewCategory, ReviewStatus } from './AiReviewPanel';
+export { changesToReviewItems } from './reviewItems';
+export type { ReviewMeta } from './reviewItems';
+export { RedlineHoverCard } from './RedlineHoverCard';
+export { ReviewCardBody, REVIEW_CARD_CSS } from './ReviewCard';

package/dist/components/redline/reviewItems.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Maps the editor's live redline `changes` (from useRedline) into AiReviewPanel
+ * ReviewItem[]. Category / severity / rationale / playbook ref come from a
+ * grounding `meta` map keyed by the change's groupId (the backend suggestion id
+ * that applyRedline stamps onto the mark). Without meta, sensible defaults keep
+ * the panel functional. Accepted/rejected changes leave `changes`, so everything
+ * here is `pending`.
+ */
+import type { RedlineChange } from "./RedlineItem";
+import type { ReviewItem, ReviewCategory, ReviewSeverity } from "./AiReviewPanel";
+export interface ReviewMeta {
+    category?: ReviewCategory;
+    severity?: ReviewSeverity;
+    title?: string;
+    rationale?: string;
+    playbookRef?: string;
+    /** `citation.playbook_id` — which playbook produced this suggestion. */
+    playbookId?: string;
+    clause?: string;
+}
+/**
+ * Filter bucket for a review item. Real playbook ids pass through (including
+ * the backend's synthetic lane playbooks `grammar:style-guide` and
+ * `chronology:date-order`); the panel lane has no citation and gets its own
+ * bucket; everything else without a playbook id falls into `lane:other`.
+ */
+export declare const bucketOf: (it: Pick<ReviewItem, "lane" | "playbookId">) => string;
+/** Display names for the non-playbook buckets; unknown ids render raw. */
+export declare const BUCKET_LABELS: Record<string, string>;
+/**
+ * Rule id → suppression key.
+ *
+ * An emitted rule id carries a per-finding hash as its last segment
+ * ("grammar:and_or:3f2a91c48b0e7d15"), so it is unique to that one finding and
+ * can never suppress a rule. The family — everything before the hash — is the
+ * key the backend's `disabled_rule_ids` matches on. Ids without a trailing hash
+ * (e.g. "GOV-PAY-004") are already families and pass through unchanged.
+ */
+export declare const ruleFamily: (ruleId: string) => string;
+export declare const SEV_RANK: Record<ReviewSeverity, number>;
+/**
+ * Findings-wall ordering: severity first (high > medium > low, stable within a
+ * severity), then identical findings — same rule (playbookRef) and title at the
+ * same severity — collapse into one group so 125 copies of "Defined term
+ * capitalization" render as a single card with a ×125 badge instead of burying
+ * the high findings. Groups keep first-appearance order within their severity.
+ */
+export declare function groupFindings(findings: ReviewItem[]): ReviewItem[][];
+export declare function changesToReviewItems(changes: RedlineChange[], meta?: Record<string, ReviewMeta>): ReviewItem[];

package/dist/components/redline/reviewPrefs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Per-document review preferences, persisted in localStorage (same pattern as
+ * `lax.flowdownActor` in api/redlines.ts). Server-side persistence is a noted
+ * TODO (doc-rules store); localStorage first.
+ *
+ *   lax.reviewExclusions.{documentId}  JSON string[] of playbook ids the
+ *                                      reviewer removed from the review set —
+ *                                      sent as `disabled_playbook_ids` on runs.
+ *   lax.primeContract.{documentId}     the attached parent-contract id —
+ *                                      sent as `prime_contract_id` on runs.
+ *
+ * All helpers fail soft (SSR / privacy mode): reads return the empty state,
+ * writes are best-effort.
+ */
+export declare const loadReviewExclusions: (documentId: string) => string[];
+export declare const saveReviewExclusions: (documentId: string, ids: readonly string[]) => void;
+export declare const loadPrimeContract: (documentId: string) => string | null;
+export declare const savePrimeContract: (documentId: string, primeId: string | null) => void;

package/dist/components/redline/useRunScopedCards.d.ts

@@ -0,0 +1,16 @@
+import type { JSONContent } from "@tiptap/core";
+import type { ReviewItem, ReviewStatus } from "./AiReviewPanel";
+export declare function useRunScopedCards(reviewItems: ReviewItem[], running: boolean): {
+    decisions: Record<string, ReviewStatus>;
+    setDecisions: import("react").Dispatch<import("react").SetStateAction<Record<string, ReviewStatus>>>;
+    knownItems: ReviewItem[];
+    displayItems: ReviewItem[];
+    undoable: {
+        id: string;
+        doc: JSONContent;
+    } | null;
+    setUndoable: import("react").Dispatch<import("react").SetStateAction<{
+        id: string;
+        doc: JSONContent;
+    } | null>>;
+};

package/dist/components/rulebuilder/AuthorForms.d.ts

@@ -0,0 +1,28 @@
+import { type AuthorExample } from "@/api/ruleAuthoring";
+import { type CapabilityStatus } from "@/api/ruleBuilder";
+export declare const DescribeForm: ({ authoring, text, onTextChange, onDraft, busy, disabled, onRecheck, }: {
+    authoring: CapabilityStatus;
+    text: string;
+    onTextChange: (next: string) => void;
+    onDraft: () => void;
+    busy: boolean;
+    disabled: boolean;
+    onRecheck: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ExamplesForm: ({ authoring, examples, onExamplesChange, guidance, onGuidanceChange, onDraft, busy, disabled, onRecheck, }: {
+    authoring: CapabilityStatus;
+    examples: AuthorExample[];
+    onExamplesChange: (next: AuthorExample[]) => void;
+    guidance: string;
+    onGuidanceChange: (next: string) => void;
+    onDraft: () => void;
+    busy: boolean;
+    disabled: boolean;
+    onRecheck: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ImportForm: ({ onImport, busy, disabled, error, }: {
+    onImport: (file: File) => void;
+    busy: boolean;
+    disabled: boolean;
+    error: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/rulebuilder/CandidateQueue.d.ts

@@ -0,0 +1,21 @@
+/**
+ * CandidateQueue — the reviewer UI `POST /v1/playbooks/ingest` was written
+ * for and never got.
+ *
+ * The handler is explicit: "Rules are NOT auto-persisted. The no-code builder
+ * UI is expected to let a human review every candidate before writing into
+ * the store." So accept is per-candidate and explicit, reject is local (the
+ * candidate never existed server-side, so there is nothing to delete), and
+ * the paragraphs that FAILED to parse are shown next to the ones that
+ * succeeded — a silent 3-of-8 import is how a playbook quietly loses rules.
+ */
+import type { IngestParseError, PredicateInfo } from "@/api/ruleBuilder";
+import type { CandidateReview } from "./useRuleBuilder";
+export declare const CandidateQueue: ({ candidates, parseErrors, catalog, onAccept, onReject, onOpen, }: {
+    candidates: CandidateReview[];
+    parseErrors: IngestParseError[];
+    catalog: PredicateInfo[];
+    onAccept: (index: number) => void;
+    onReject: (index: number) => void;
+    onOpen: (index: number) => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/rulebuilder/DraftPane.d.ts

@@ -0,0 +1,12 @@
+import type { PredicateInfo } from "@/api/ruleBuilder";
+import type { Draft } from "./useRuleBuilder";
+export declare const DraftPane: ({ draft, catalog, busy, error, canRevise, onRevise, onCommit, onDiscard, }: {
+    draft: Draft;
+    catalog: PredicateInfo[];
+    busy: boolean;
+    error: string;
+    canRevise: boolean;
+    onRevise: (instruction: string) => void;
+    onCommit: () => void;
+    onDiscard: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/rulebuilder/RuleBuilderPanel.d.ts

@@ -0,0 +1,6 @@
+export interface RuleBuilderPanelProps {
+    /** Preselects a playbook; otherwise the first one in the workspace. */
+    playbookId?: string;
+    className?: string;
+}
+export declare const RuleBuilderPanel: ({ playbookId, className }: RuleBuilderPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/rulebuilder/RuleCard.d.ts

@@ -0,0 +1,16 @@
+/**
+ * RuleCard — one rule rendered the way a lawyer reads it, not the way the
+ * store holds it: what the rule looks for, then the negotiation ladder
+ * (standard position → fallback → walkaway), then the machinery.
+ *
+ * The predicate is the one genuinely technical part, so it is rendered as a
+ * sentence built from the live `/v1/playbooks/predicates` catalog rather than
+ * as raw JSON — the catalog is exactly the vocabulary the drafting model was
+ * given, so the description shown is the description it authored against.
+ */
+import type { BuilderRule, PredicateInfo } from "@/api/ruleBuilder";
+export declare const RuleCard: ({ rule, catalog, warnings, }: {
+    rule: BuilderRule;
+    catalog: PredicateInfo[];
+    warnings?: string[];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/rulebuilder/TestBench.d.ts

@@ -0,0 +1,10 @@
+import type { EvaluateResult } from "@/api/ruleBuilder";
+export declare const TestBench: ({ playbookName, result, busy, error, onRun, highlightRuleId, }: {
+    playbookName: string;
+    result: EvaluateResult | null;
+    busy: boolean;
+    error: string;
+    onRun: (clauseText: string) => void;
+    /** When set, the row for this rule is called out — "did MY rule fire?". */
+    highlightRuleId?: string | null;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/rulebuilder/VocabularyPanel.d.ts

@@ -0,0 +1,26 @@
+/**
+ * VocabularyPanel — "what can I write a rule about?", answered by the three
+ * discovery endpoints.
+ *
+ *   predicates  always on   — the kinds of test a rule can make.
+ *   fields      flag-gated  — the named header fields `expr`/`one_of` can read.
+ *   taxonomy    flag-gated  — the CDTS tree that says where a playbook applies.
+ *
+ * The two gated ones share a flag but fail differently, so each renders its
+ * own capability notice. This is the part of the surface that decays
+ * gracefully: without fields, a lawyer can still write clause-text rules, and
+ * the panel says exactly that rather than showing an empty list that reads as
+ * "there are no fields".
+ */
+import { type CapabilityStatus, type FieldCatalogEntry, type PredicateInfo, type TaxonomyNode } from "@/api/ruleBuilder";
+export declare const VocabularyPanel: ({ predicates, predicatesError, onReloadPredicates, fields, fieldsStatus, onReloadFields, taxonomy, taxonomyStatus, onReloadTaxonomy, }: {
+    predicates: PredicateInfo[];
+    predicatesError: string;
+    onReloadPredicates: () => void;
+    fields: FieldCatalogEntry[];
+    fieldsStatus: CapabilityStatus;
+    onReloadFields: () => void;
+    taxonomy: TaxonomyNode[];
+    taxonomyStatus: CapabilityStatus;
+    onReloadTaxonomy: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,13 @@
+/**
+ * The no-code rule builder: one screen over the eight P2 authoring endpoints.
+ * `RuleBuilderPanel` is the whole surface; everything else is exported for
+ * tests and for hosts that want to place a piece of the flow themselves.
+ */
+export { RuleBuilderPanel } from "./RuleBuilderPanel";
+export type { RuleBuilderPanelProps } from "./RuleBuilderPanel";
+export { useRuleBuilder } from "./useRuleBuilder";
+export type { BuilderMode, CandidateReview, Draft, RuleBuilderState } from "./useRuleBuilder";
+export { RuleCard } from "./RuleCard";
+export { CandidateQueue } from "./CandidateQueue";
+export { TestBench } from "./TestBench";
+export { VocabularyPanel } from "./VocabularyPanel";

package/dist/components/rulebuilder/primitives.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared presentational pieces for the rule builder. Playbook design tokens
+ * + Tailwind only, matching `components/playbook/primitives.tsx`; every value
+ * renders as text, never HTML.
+ */
+import type { ReactNode } from "react";
+import type { CapabilityStatus } from "@/api/ruleBuilder";
+export declare const Chip: ({ tone, title, children, }: {
+    tone?: "neutral" | "accent" | "warn" | "danger" | "ok";
+    title?: string;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const Section: ({ title, hint, actions, children, }: {
+    title: string;
+    hint?: ReactNode;
+    actions?: ReactNode;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const Button: ({ variant, disabled, busy, onClick, type, children, }: {
+    variant?: "primary" | "secondary" | "ghost" | "danger";
+    disabled?: boolean;
+    busy?: boolean;
+    onClick?: () => void;
+    type?: "button" | "submit";
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TextArea: ({ label, value, onChange, placeholder, rows, disabled, }: {
+    label: string;
+    value: string;
+    onChange: (next: string) => void;
+    placeholder?: string;
+    rows?: number;
+    disabled?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+/** Inline, non-blocking failure strip. Errors never take the screen away. */
+export declare const ErrorStrip: ({ message, onRetry }: {
+    message: string;
+    onRetry?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * The honest degradation surface. A capability that is off server-side is
+ * NOT an error and NOT a hidden control: the user is told the capability
+ * exists, is disabled on this deployment, and which flag turns it on — so
+ * "why can't I do this" has an answer that does not require reading Go.
+ */
+export declare const CapabilityNotice: ({ status, capability, flag, onRetry, }: {
+    status: CapabilityStatus;
+    capability: string;
+    flag?: string;
+    onRetry?: () => void;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export declare const EmptyHint: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;