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

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

@@ -0,0 +1,26 @@
+import { type Rule } from "@/api/playbook";
+import { type FiredState } from "./primitives";
+export interface RuleRowProps {
+    rule: Rule;
+    /** Owning playbook is a bundled (read-only) library playbook (REQ-R4). */
+    bundled: boolean;
+    fired: FiredState;
+    expanded: boolean;
+    onToggle: () => void;
+    /** Cross-link + edit affordances forwarded to RuleDetail (REQ-R3/R4). */
+    onEdit?: (rule: Rule) => void;
+    onDuplicate?: (rule: Rule) => void;
+    onShowSuggestions?: (ruleId: string) => void;
+    /** Extra highlight for a just-saved / cross-link-focused rule. */
+    highlighted?: boolean;
+    /** Dismissed for this document only — dims the row, swaps the meta chip. */
+    dismissed?: boolean;
+    onDismiss?: (rule: Rule) => void;
+    onRestore?: (ruleId: string) => void;
+    onDelete?: (rule: Rule) => void;
+    /** Ignored workspace-wide (rule-overrides) — dims the row, "Ignored" badge. */
+    ignored?: boolean;
+    onIgnore?: (rule: Rule) => void;
+    onUnignore?: (ruleId: string) => void;
+}
+export declare const RuleRow: import("react").ForwardRefExoticComponent<RuleRowProps & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,45 @@
+import { type Rule } from "@/api/playbook";
+import { type RuleFilter } from "@/constants/playbook";
+import { type CdtsScope } from "@/utils/cdts";
+import type { FetchState, RuleGroup } from "./usePlaybookData";
+export interface ThisDocumentViewProps {
+    docScope: CdtsScope;
+    workspaceName?: string;
+    regimeLabels?: string[];
+    groupsState: FetchState<RuleGroup[]>;
+    onRetry: () => void;
+    search: string;
+    onSearchChange: (query: string) => void;
+    filter: RuleFilter;
+    onFilterChange: (filter: RuleFilter) => void;
+    firedCounts: ReadonlyMap<string, number> | null;
+    justSavedRuleIds: ReadonlySet<string>;
+    expandedRuleId: string | null;
+    onToggleRule: (ruleId: string) => void;
+    focusedRuleId?: string | null;
+    onEditRule: (rule: Rule) => void;
+    onDuplicateRule: (rule: Rule, group: RuleGroup) => void;
+    onShowSuggestions?: (ruleId: string) => void;
+    onNewRule: () => void;
+    registerRowRef: (ruleId: string, el: HTMLButtonElement | null) => void;
+    /** Rules dismissed for this document only (client-side, reversible). */
+    dismissedRuleIds: ReadonlySet<string>;
+    onDismissRule: (rule: Rule) => void;
+    onRestoreRule: (ruleId: string) => void;
+    onDeleteRule?: (rule: Rule) => void;
+    /** Rules ignored workspace-wide (durable rule-overrides). */
+    ignoredRuleIds?: ReadonlySet<string>;
+    onIgnoreRule?: (rule: Rule) => void;
+    onUnignoreRule?: (ruleId: string) => void;
+    /** Rule the escalation nudge is currently offered for (3rd dismissal). */
+    nudgeRuleId?: string | null;
+    onNudgeSuggestRemoval?: (ruleId: string) => void;
+    onNudgeDismiss?: (ruleId: string) => void;
+    /** How many documents the nudged rule has been dismissed on. */
+    nudgeCount?: number;
+    playbookOwnerName?: string;
+    /** Playbooks deselected for this session/run (client-side, per-run only). */
+    mutedPlaybookIds: ReadonlySet<string>;
+    onTogglePlaybook: (playbookId: string, ruleIds: string[]) => void;
+}
+export declare const ThisDocumentView: (props: ThisDocumentViewProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+export type PlaybookView = "this-document" | "all-playbooks";
+export interface ViewTabsProps {
+    active: PlaybookView;
+    onChange: (view: PlaybookView) => void;
+    thisDocumentCount: number | null;
+    allPlaybooksCount: number | null;
+}
+export declare const ViewTabs: ({ active, onChange, thisDocumentCount, allPlaybooksCount, }: ViewTabsProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,14 @@
+export { PlaybookPanel } from "./PlaybookPanel";
+export type { PlaybookPanelProps, RuleDismissalRecord, SaveAsRulePrefill, } from "./PlaybookPanel";
+export type { RuleEditorSession } from "./RuleEditorModal";
+export { PlaybookPage } from "./PlaybookPage";
+export type { PlaybookPageProps } from "./PlaybookPage";
+export { NewRuleDrawer } from "./NewRuleDrawer";
+export type { NewRuleDrawerProps } from "./NewRuleDrawer";
+export { DerivedRulebookView } from "./DerivedRulebookView";
+export type { DerivedRulebookViewProps } from "./DerivedRulebookView";
+export { EffectiveRulesView } from "./EffectiveRulesView";
+export type { EffectiveRulesViewProps } from "./EffectiveRulesView";
+export { PromotionSuggestions } from "./PromotionSuggestions";
+export { RulePerformancePanel } from "./RulePerformancePanel";
+export type { RulePerformancePanelProps } from "./RulePerformancePanel";

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

@@ -0,0 +1,10 @@
+/**
+ * One-line predicate summary for drafted-rule previews (Captured Edits modal,
+ * Candidate Rules queue): kind plus the one or two salient params, recursing
+ * one level into composites.
+ *
+ *   semantic_similarity_above · threshold 0.62
+ *   all(semantic_similarity_above, contains_phrase)
+ */
+import type { PredicateNode } from "@/api/ruleBuilder";
+export declare const predicateSummary: (predicate: PredicateNode | undefined) => string;

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

@@ -0,0 +1,82 @@
+/**
+ * Small shared presentational pieces for the playbook panel.
+ * Tokens + Tailwind only (REQ-S3); all text renders as text, never HTML.
+ */
+import type { ReactNode } from "react";
+export declare const Chip: ({ className, children, title, }: {
+    className?: string;
+    children: ReactNode;
+    title?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * The one severity chip (REQ-R1: tinted bg, no border). Renders the canonical
+ * critical/high/medium/low vocabulary; unknown wire values fall back to medium.
+ */
+export declare const SeverityChip: ({ severity, className, }: {
+    severity: string;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export type FiredState = {
+    kind: "pre-run";
+} | {
+    kind: "count";
+    count: number;
+} | {
+    kind: "applies-next-run";
+};
+export declare const FiredBadge: ({ state }: {
+    state: FiredState;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const CountBadge: ({ count }: {
+    count: number;
+}) => import("react/jsx-runtime").JSX.Element;
+/** 3 shimmer rule rows under real group headers — never a full-panel spinner. */
+export declare const SkeletonRuleRows: () => import("react/jsx-runtime").JSX.Element;
+export declare const SkeletonPlaybookCards: () => import("react/jsx-runtime").JSX.Element;
+/** Inline error strip + Retry — never a blocking dialog (§5). */
+export declare const InlineErrorStrip: ({ message, onRetry, }: {
+    message: string;
+    onRetry?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+/** EmptyState anatomy: illustration + title + one reassurance line (§5). */
+export declare const EmptyState: ({ title, reassurance, children, }: {
+    title: string;
+    reassurance: string;
+    children?: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Zero-results row with a one-tap reset chip (§5).
+ *
+ * `reason` distinguishes an empty search from an empty *filter* — filtering to
+ * a set with no members used to render `No matches for “”`, a dead end that
+ * named neither the cause nor the control that would undo it.
+ */
+export declare const ZeroResults: ({ query, onClear, reason, message, }: {
+    query: string;
+    onClear: () => void;
+    reason?: "search" | "filter";
+    /** Overrides the default line; use to name the active filter. */
+    message?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export interface FilterOption<T extends string> {
+    id: T;
+    label: string;
+    count: number;
+}
+/**
+ * Single-select filter chip row. Sits under SearchField on both list views;
+ * filtering is client-side over already-fetched data, so switching chips never
+ * refetches and needs no loading state of its own.
+ */
+export declare const FilterChips: <T extends string>({ options, active, onChange, label, }: {
+    options: readonly FilterOption<T>[];
+    active: T;
+    onChange: (id: T) => void;
+    label: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const SearchField: ({ value, onChange, placeholder, label, }: {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder: string;
+    label: string;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,6 @@
+/**
+ * WAI-ARIA Dialog focus management (REQ-A1): traps Tab inside the container,
+ * focuses the first focusable on open, and restores focus to the invoking
+ * element on close.
+ */
+export declare const useFocusTrap: <T extends HTMLElement>() => import("react").MutableRefObject<T | null>;

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

@@ -0,0 +1,161 @@
+import { type Playbook, type Rule } from "@/api/playbook";
+import { type CdtsScope } from "@/utils/cdts";
+export type FetchState<T> = {
+    status: "loading";
+} | {
+    status: "error";
+    message: string;
+} | {
+    status: "ready";
+    data: T;
+};
+export interface RuleGroup {
+    playbook: Playbook;
+    rules: Rule[];
+    bundled: boolean;
+}
+/**
+ * This-document view: one `?cdts=` round-trip (REQ-D2) whose response carries
+ * each chain playbook's rules inline; playbooks arriving without inline rules
+ * (the degraded client-filter path) lazy-fetch via listRules. Groups sort in
+ * CDTS walk-up order — specific → generic (REQ-P3).
+ */
+export declare const useThisDocumentRules: (docScope: CdtsScope) => {
+    state: FetchState<RuleGroup[]>;
+    retry: () => void;
+    ruleCount: number | null;
+};
+/** All-playbooks view: unfiltered list (REQ-D3). */
+export declare const useAllPlaybooks: () => {
+    state: FetchState<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        workspace_id: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+        regime: import("zod").ZodOptional<import("zod").ZodString>;
+        kind: import("zod").ZodOptional<import("zod").ZodString>;
+        scope: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodObject<{
+            category: import("zod").ZodOptional<import("zod").ZodString>;
+            domain: import("zod").ZodOptional<import("zod").ZodString>;
+            type: import("zod").ZodOptional<import("zod").ZodString>;
+            subtype: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            category: import("zod").ZodOptional<import("zod").ZodString>;
+            domain: import("zod").ZodOptional<import("zod").ZodString>;
+            type: import("zod").ZodOptional<import("zod").ZodString>;
+            subtype: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            category: import("zod").ZodOptional<import("zod").ZodString>;
+            domain: import("zod").ZodOptional<import("zod").ZodString>;
+            type: import("zod").ZodOptional<import("zod").ZodString>;
+            subtype: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">>>>;
+        version: import("zod").ZodOptional<import("zod").ZodNumber>;
+        effective_from: import("zod").ZodOptional<import("zod").ZodString>;
+        read_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        bundled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        rules: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            playbook_id: import("zod").ZodString;
+            workspace_id: import("zod").ZodOptional<import("zod").ZodString>;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            category: import("zod").ZodString;
+            default_severity: import("zod").ZodString;
+            verbatim_excerpt: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+            standard_position: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod").ZodTypeAny, "passthrough">>>;
+            rationale: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+            suggested_text: import("zod").ZodOptional<import("zod").ZodString>;
+            authority: import("zod").ZodOptional<import("zod").ZodString>;
+            mandatory: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            read_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            source: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            id: import("zod").ZodString;
+            playbook_id: import("zod").ZodString;
+            workspace_id: import("zod").ZodOptional<import("zod").ZodString>;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            category: import("zod").ZodString;
+            default_severity: import("zod").ZodString;
+            verbatim_excerpt: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+            standard_position: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod").ZodTypeAny, "passthrough">>>;
+            rationale: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+            suggested_text: import("zod").ZodOptional<import("zod").ZodString>;
+            authority: import("zod").ZodOptional<import("zod").ZodString>;
+            mandatory: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            read_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            source: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodString;
+            playbook_id: import("zod").ZodString;
+            workspace_id: import("zod").ZodOptional<import("zod").ZodString>;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            category: import("zod").ZodString;
+            default_severity: import("zod").ZodString;
+            verbatim_excerpt: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+            standard_position: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                text: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod").ZodTypeAny, "passthrough">>>;
+            rationale: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+            suggested_text: import("zod").ZodOptional<import("zod").ZodString>;
+            authority: import("zod").ZodOptional<import("zod").ZodString>;
+            mandatory: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            read_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            source: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">>, "many">>;
+    }, import("zod").ZodTypeAny, "passthrough">[]>;
+    retry: () => void;
+    count: number | null;
+};
+/**
+ * Workspace rule overrides ("ignore rule everywhere"). The list is durable
+ * server state (GET /v1/rule-overrides); ignore/unignore write through and
+ * update the local set on success, so no refetch per toggle.
+ */
+export declare const useRuleOverrides: () => {
+    state: FetchState<string[]>;
+    ignored: ReadonlySet<string>;
+    ignore: (family: string) => Promise<void>;
+    unignore: (family: string) => Promise<void>;
+    retry: () => void;
+};
+/** Per-playbook rule list, lazy-loaded on drill-in (REQ-D3). */
+export declare const usePlaybookRules: (playbook: Playbook | null) => {
+    state: FetchState<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        playbook_id: import("zod").ZodString;
+        workspace_id: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        category: import("zod").ZodString;
+        default_severity: import("zod").ZodString;
+        verbatim_excerpt: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        standard_position: import("zod").ZodOptional<import("zod").ZodObject<{
+            text: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            text: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            text: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">>>;
+        rationale: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        suggested_text: import("zod").ZodOptional<import("zod").ZodString>;
+        authority: import("zod").ZodOptional<import("zod").ZodString>;
+        mandatory: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        read_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        source: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">[]>;
+    retry: () => void;
+};

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

@@ -0,0 +1,18 @@
+import { type Playbook, type PlaybookApiConfig } from "@/api/playbook";
+import { type CdtsScope } from "@/utils/cdts";
+export interface ReviewedPlaybookInfo {
+    id: string;
+    name: string;
+    scopeLabel: string;
+    ruleCount?: number;
+    bundled: boolean;
+    /** The full playbook, for handing to PlaybookPage. */
+    playbook: Playbook;
+}
+export interface PlaybookLabelResult {
+    /** "Cost Accounting … +17 more", or `fallback` before/without data. */
+    label: string | undefined;
+    /** Chain in walk-up order (most specific first); empty until loaded. */
+    playbooks: ReviewedPlaybookInfo[];
+}
+export declare const usePlaybookLabel: (scope: CdtsScope | undefined, fallback: string | undefined, api?: PlaybookApiConfig) => PlaybookLabelResult;

package/dist/components/r1/ApprovalPanel.d.ts

@@ -0,0 +1,10 @@
+import { type RulebookStatus } from "@/api/r1";
+export interface ApprovalPanelProps {
+    /** The derived playbook whose candidates are being disposed. */
+    playbookId: string;
+    /** Approver identity to display; defaults to the client-config approver. */
+    approver?: string;
+    /** Notified whenever the rulebook status changes (e.g. becomes active). */
+    onStatusChange?: (status: RulebookStatus) => void;
+}
+export declare const ApprovalPanel: ({ playbookId, approver, onStatusChange }: ApprovalPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/r1/CandidateRuleCard.d.ts

@@ -0,0 +1,8 @@
+import type { CandidateRule } from "@/api/r1";
+export interface CandidateRuleCardProps {
+    rule: CandidateRule;
+    busy?: boolean;
+    onApprove: (id: string, editedText?: string) => void;
+    onReject: (id: string) => void;
+}
+export declare const CandidateRuleCard: ({ rule, busy, onApprove, onReject }: CandidateRuleCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/r1/ExecSummaryPanel.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ExecSummaryPanel — post-review executive summary: finding counts by
+ * provenance (Prime vs CDTS), severity mix, missing-flowdown count,
+ * escalations, and suppressed minor deviations. Purely presentational; the
+ * parent fetches the summary via src/api/r1.ts getReviewSummary().
+ */
+import type { ReviewSummary } from "@/api/r1";
+export interface ExecSummaryPanelProps {
+    summary?: ReviewSummary | null;
+    loading?: boolean;
+    error?: string | null;
+    onRetry?: () => void;
+    /**
+     * The review stream ended without both a `summary` and a `done` frame. The
+     * backend cannot currently distinguish truncation from completion, so any
+     * counts below are a floor, not a total — say so rather than presenting
+     * them as a finished review.
+     */
+    incomplete?: boolean;
+    /** Label for the retry/refresh action (default "Retry"). */
+    retryLabel?: string;
+}
+export declare const ExecSummaryPanel: ({ summary, loading, error, onRetry, incomplete, retryLabel, }: ExecSummaryPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/r1/PrimeUploadPanel.d.ts

@@ -0,0 +1,8 @@
+import { type DerivationJob } from "@/api/r1";
+export interface PrimeUploadPanelProps {
+    /** Called when a derivation completes with candidates to review. */
+    onDerived?: (job: DerivationJob) => void;
+    /** Poll interval for job status (ms). */
+    pollIntervalMs?: number;
+}
+export declare const PrimeUploadPanel: ({ onDerived, pollIntervalMs }: PrimeUploadPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/r1/ReviewStartControls.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Review-start + workspace-settings controls for GovCon mode:
+ *
+ * - GovConToggle — the simple workspace-settings flag that enables
+ *   prime-flowdown behavior.
+ * - CounterpartyTypeSelector — segmented selector shown on review start
+ *   (commercial sub / noncommercial / unknown), feeding
+ *   R1EvaluateExtras.counterparty_type.
+ *
+ * Both are controlled, presentational components.
+ */
+import type { CounterpartyType } from "@/api/r1";
+export interface GovConToggleProps {
+    enabled: boolean;
+    onChange: (enabled: boolean) => void;
+    disabled?: boolean;
+}
+export declare const GovConToggle: ({ enabled, onChange, disabled }: GovConToggleProps) => import("react/jsx-runtime").JSX.Element;
+export interface CounterpartyTypeSelectorProps {
+    value: CounterpartyType;
+    onChange: (value: CounterpartyType) => void;
+    disabled?: boolean;
+}
+export declare const CounterpartyTypeSelector: ({ value, onChange, disabled }: CounterpartyTypeSelectorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/r1/ReviewSummaryTab.d.ts

@@ -0,0 +1,38 @@
+/** The counters ReviewSummary is derived from — the stream's `summary` frame. */
+export interface StreamSummaryCounters {
+    /**
+     * The run's own id, carried by every `summary` frame. Not used to derive any
+     * count — it is how a host keys review-scoped exports (the CPSR packet) off
+     * a run it has just watched, without holding a separate re-hydration id.
+     */
+    review_id?: string;
+    severity_mix?: Record<string, number>;
+    finding_provenance?: Record<string, number>;
+    missing_flowdowns?: number;
+    escalations?: number;
+    suppressed?: number;
+}
+export interface ReviewSummaryTabProps {
+    /** The last run's `summary` frame; null/undefined before any run. */
+    payload?: StreamSummaryCounters | null;
+    /** Both `summary` and `done` arrived — only then is the run finished. */
+    complete?: boolean;
+    /** The run was cancelled by the reviewer — not a truncated review. */
+    cancelled?: boolean;
+    /** A review is streaming right now. */
+    running?: boolean;
+    /**
+     * The last run raised a mid-stream `error` frame (which is also how a close
+     * without `done` reaches the host). Covers the truncation that cuts the
+     * stream off BEFORE the `summary` frame — there are no counts to show, but
+     * the tab must still not read as "no review has run".
+     */
+    streamErrored?: boolean;
+    /**
+     * Re-hydration only: a completed review's id whose stream this session did
+     * not see. Fetched through GET /v1/reviews/{id}/summary. Omit it (the
+     * default) and no request is ever made.
+     */
+    reviewId?: string | null;
+}
+export declare const ReviewSummaryTab: ({ payload, complete, cancelled, running, streamErrored, reviewId, }: ReviewSummaryTabProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,13 @@
+export { PrimeUploadPanel } from "./PrimeUploadPanel";
+export type { PrimeUploadPanelProps } from "./PrimeUploadPanel";
+export { ApprovalPanel } from "./ApprovalPanel";
+export type { ApprovalPanelProps } from "./ApprovalPanel";
+export { CandidateRuleCard } from "./CandidateRuleCard";
+export type { CandidateRuleCardProps } from "./CandidateRuleCard";
+export { ExecSummaryPanel } from "./ExecSummaryPanel";
+export type { ExecSummaryPanelProps } from "./ExecSummaryPanel";
+export { ReviewSummaryTab } from "./ReviewSummaryTab";
+export type { ReviewSummaryTabProps } from "./ReviewSummaryTab";
+export { GovConToggle, CounterpartyTypeSelector } from "./ReviewStartControls";
+export type { GovConToggleProps, CounterpartyTypeSelectorProps } from "./ReviewStartControls";
+export { ProvenanceBadge, ProvenanceBlock, ClassificationBadge, PositionsBlock } from "./primitives";

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

@@ -0,0 +1,59 @@
+/**
+ * Shared presentational pieces for the R1 (prime flowdown) screens.
+ *
+ * Skinned entirely via src/styles/tokens.css design tokens (no hardcoded
+ * colors), same idiom as components/redline/ReviewCard.tsx: inline styles on
+ * CSS custom properties plus one shared CSS string.
+ */
+import { type ReactNode } from "react";
+import type { CandidateClassification, R1Provenance, SuggestionPositions } from "@/api/r1";
+export declare const R1_CSS = "\n.r1-root{box-sizing:border-box;font-family:var(--font-ui);color:var(--pb-text-primary)}\n.r1-root *{box-sizing:border-box}\n.r1-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.r1-btn:disabled{opacity:.55;cursor:default}\n.r1-primary{background:var(--action);color:var(--action-on);border:none;box-shadow:0 1px 2px 0 rgba(0,0,0,.05)}\n.r1-primary:hover:not(:disabled){background:var(--action-hover)}\n.r1-secondary{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.r1-secondary:hover:not(:disabled){background:var(--pb-card)}\n.dark .r1-primary,.dark .r1-secondary{box-shadow:0 1px 3px rgba(0,0,0,.4)}\n.r1-link{background:none;border:none;padding:0;cursor:pointer;font-family:var(--font-ui);color:var(--action-link);font-weight:600}\n.r1-link:hover{text-decoration:underline}\n.r1-card{transition:border-color .15s ease, box-shadow .15s ease, background .15s ease}\n.r1-prov{cursor:pointer;border:none}\n.r1-prov:hover{text-decoration:underline}\n.r1-scroll{scrollbar-width:thin}\n.r1-textarea{width:100%;font-family:var(--font-document);font-size:12.5px;line-height:1.5;color:var(--pb-text-body);background:var(--pb-panel);border:1px solid var(--pb-border-strong);border-radius:var(--radius-control);padding:8px 10px;resize:vertical;min-height:72px}\n.r1-textarea:focus{outline:none;border-color:var(--action);box-shadow:0 0 0 2px var(--action-tint)}\n";
+export declare const CLASSIFICATION: {
+    readonly mandatory: {
+        readonly label: "MANDATORY";
+        readonly text: "var(--sev-t1-text)";
+        readonly bg: "var(--sev-t1-bg)";
+    };
+    readonly conditionally_mandatory: {
+        readonly label: "CONDITIONAL";
+        readonly text: "var(--sev-t2-text)";
+        readonly bg: "var(--sev-t2-bg)";
+    };
+    readonly discretionary: {
+        readonly label: "DISCRETIONARY";
+        readonly text: "var(--sev-t3-text)";
+        readonly bg: "var(--sev-t3-bg)";
+    };
+};
+export declare const ClassificationBadge: ({ classification, }: {
+    classification: CandidateClassification;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const CitationChip: ({ citation }: {
+    citation: string;
+}) => import("react/jsx-runtime").JSX.Element;
+/** The badge alone (no click-through) — "Prime §X" blue ref vs "CDTS" gray. */
+export declare const ProvenanceBadge: ({ provenance, onClick, }: {
+    provenance: R1Provenance;
+    onClick?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Badge + expandable provenance detail: click-through to the verbatim source
+ * excerpt, plus the superseded-by-regulatory note when the rule fired but is
+ * ignored.
+ */
+export declare const ProvenanceBlock: ({ provenance }: {
+    provenance: R1Provenance;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const PositionsBlock: ({ positions }: {
+    positions: SuggestionPositions;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ErrorStrip: ({ message, action, }: {
+    message: string;
+    action?: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ProgressBar: ({ pct }: {
+    pct: number;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const SectionLabel: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;