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

package/dist/api/ruleOverrides.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Workspace rule-override ("ignore rule everywhere") API module.
+ *
+ * Backend contract (internal/redlining/api/ruleoverrides.go):
+ *   GET    /v1/rule-overrides           → 200 {"disabled": ["<family>", ...]}
+ *   PUT    /v1/rule-overrides/{family}  → 204 (idempotent add)
+ *   DELETE /v1/rule-overrides/{family}  → 204 (idempotent remove)
+ *
+ * A family is a playbook rule id, or "grammar:<rule>" for grammar lanes
+ * ("grammar:lt:<ID>" for LanguageTool). Overrides are durable per workspace
+ * and the server unions them into every review run's disabled set — unlike
+ * the panel's per-document dismissal, which stays client-side and per-run.
+ *
+ * Reuses playbook.ts's request core so auth headers, the error envelope and
+ * zod validation follow one path (same pattern as derivedRulebook.ts).
+ */
+import { z } from "zod";
+export declare const ruleOverridesSchema: z.ZodObject<{
+    disabled: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    disabled: string[];
+}, {
+    disabled: string[];
+}>;
+export type RuleOverrides = z.infer<typeof ruleOverridesSchema>;
+/** Lists the workspace's durably ignored rule families (sorted server-side). */
+export declare const listRuleOverrides: () => Promise<string[]>;
+/** Durably ignores a rule family for the whole workspace (idempotent 204). */
+export declare const ignoreRule: (family: string) => Promise<void>;
+/** Removes a workspace ignore so the rule fires again (idempotent 204). */
+export declare const unignoreRule: (family: string) => Promise<void>;

package/dist/api/ruleStats.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Rule disposition stats + reprioritize — the Rule Performance screen's wire.
+ *
+ *   GET  /v1/rules/stats?playbook_id=<id>   {rules: [{rule_id, accepts,
+ *        rejects, acceptance_rate, candidate}]}
+ *   POST /v1/rules/{id}/reprioritize        {severity?, action?, note}
+ *        → 200 updated rule | 400 {"code":"invalid_reprioritize"} | 404
+ *
+ * Both routes are behind RULE_ESCALATION_ENABLED (default off): a 404 is the
+ * flag being off, mapped via `capabilityFromError`, never an error state.
+ *
+ * Semantics the UI must respect:
+ * - `acceptance_rate` is computed SERVER-side from the post-deploy pair
+ *   accepts/(accepts+rejects_new). Never recompute a rate client-side.
+ * - `rejects` is the ALL-TIME total. It carries pre-deploy legacy skew and is
+ *   display-only — never a rate denominator.
+ * - `candidate: null` means the warm-up gate (≥5 post-deploy dispositions) is
+ *   not met; render neutrally, never as "healthy" or 0%.
+ */
+import { z } from "zod";
+export declare const ruleStatSchema: z.ZodObject<{
+    rule_id: z.ZodString;
+    accepts: z.ZodNumber;
+    rejects: z.ZodNumber;
+    acceptance_rate: z.ZodNumber;
+    candidate: z.ZodNullable<z.ZodEnum<["demote", "escalate"]>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    rule_id: z.ZodString;
+    accepts: z.ZodNumber;
+    rejects: z.ZodNumber;
+    acceptance_rate: z.ZodNumber;
+    candidate: z.ZodNullable<z.ZodEnum<["demote", "escalate"]>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    rule_id: z.ZodString;
+    accepts: z.ZodNumber;
+    rejects: z.ZodNumber;
+    acceptance_rate: z.ZodNumber;
+    candidate: z.ZodNullable<z.ZodEnum<["demote", "escalate"]>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type RuleStat = z.infer<typeof ruleStatSchema>;
+export declare const listRuleStats: (playbookId: string) => Promise<RuleStat[]>;
+export interface ReprioritizeInput {
+    severity?: string;
+    action?: string;
+    note: string;
+}
+/** 200 body is the updated rule (contracts.PlaybookRule). */
+export declare const reprioritizeRule: (ruleId: string, input: ReprioritizeInput) => Promise<z.objectOutputType<{
+    id: z.ZodString;
+    playbook_id: z.ZodString;
+    workspace_id: z.ZodOptional<z.ZodString>;
+    predicate: z.ZodOptional<z.ZodType<import("./ruleBuilder").PredicateNode, z.ZodTypeDef, import("./ruleBuilder").PredicateNode>>;
+    action: z.ZodOptional<z.ZodString>;
+    default_severity: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    semantic_intent: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    read_only: z.ZodOptional<z.ZodBoolean>;
+    mandatory: z.ZodOptional<z.ZodBoolean>;
+    authority: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    standard_position: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">>>>;
+    fallback_condition: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">>>>;
+    walkaway_condition: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">>>>;
+}, z.ZodTypeAny, "passthrough">>;

package/dist/api/rulesCatalog.d.ts

@@ -0,0 +1,234 @@
+/**
+ * Workspace rule catalog — `GET /v1/rules`.
+ *
+ * The backend walks every playbook the workspace can see and concatenates
+ * their rules (internal/playbook-engine/api/rules.go ListRules), answering
+ * `{"rules": [...], "count": n}`.
+ *
+ * WHY THIS EXISTS when the FE already fetches rules per playbook: the
+ * per-playbook path needs the playbook id up front. Reg-sync hands back
+ * `affected_rules` as (rule_id, playbook_id, authority) triples spread across
+ * an arbitrary set of playbooks, and the panel has to render a rule NAME for
+ * each one. Per-playbook that is N round trips whose N is dictated by the
+ * server's answer; here it is one. That — resolving an id set the caller did
+ * not choose — is the only case where this endpoint beats the per-playbook
+ * fetch, and it is the case it is used for.
+ *
+ * The row shape is `contracts.PlaybookRule`, identical to the per-playbook
+ * fetch, so this module reuses `ruleSchema`/`Rule` from ./playbook rather than
+ * describing the same wire shape twice.
+ */
+import { z } from "zod";
+import { type Rule } from "./playbook";
+export declare const rulesCatalogSchema: z.ZodObject<{
+    rules: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    rules: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    rules: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        playbook_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodString;
+        default_severity: z.ZodString;
+        verbatim_excerpt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        standard_position: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        rationale: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suggested_text: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodString>;
+        mandatory: z.ZodOptional<z.ZodBoolean>;
+        read_only: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+export interface ListAllRulesOptions {
+    signal?: AbortSignal;
+}
+/**
+ * Every rule across every playbook visible to the configured workspace.
+ *
+ * Note the server's own failure posture: a playbook whose rule read errors is
+ * SKIPPED silently (`continue`), so `count` is a floor, not a guarantee. Do
+ * not treat a missing rule id as proof the rule does not exist.
+ */
+export declare const listAllRules: (opts?: ListAllRulesOptions) => Promise<Rule[]>;
+/** Index a rule list by id, for resolving the ids another endpoint handed us. */
+export declare const indexRulesById: (rules: Rule[]) => Map<string, Rule>;

package/dist/api/versions.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Playbook version-history API module (sprint-2 story 1).
+ *
+ *   GET /v1/playbooks/{id}/versions            version list
+ *   GET /v1/playbooks/{id}/versions/{n}/rules  that version's rules
+ *
+ * Response shapes verified against the playbook-engine handlers
+ * (internal/playbook-engine/api/versions.go / playbooks.go):
+ *
+ *   versions → {"versions":[{version, effective_from?, bundle_hash?,
+ *               source:"registry"|"bundle"|"store", active,
+ *               changed_by?, changed_at?}]}
+ *   rules    → {"rules":[{id, ...}], "source":"cache"|"store"}
+ *
+ * Mirrors `redlines.ts`'s conventions: module-level mutable config merged
+ * with Vite env defaults, zod + `.passthrough()` at the boundary.
+ */
+import { z } from "zod";
+export interface VersionsApiConfig {
+    baseUrl?: string;
+    workspaceId?: string;
+}
+/** Configure once from the consumer (App.tsx / lax-web-portal). */
+export declare const configureVersionsApi: (next: VersionsApiConfig) => void;
+export declare class VersionsApiError extends Error {
+    readonly status?: number;
+    constructor(message: string, status?: number);
+}
+declare const versionEntrySchema: z.ZodObject<{
+    version: z.ZodNumber;
+    /** Omitted (omitzero) when the source never stamped one. */
+    effective_from: z.ZodOptional<z.ZodString>;
+    bundle_hash: z.ZodOptional<z.ZodString>;
+    /** "registry" (S3 version object) | "bundle" (seeded) | "store". */
+    source: z.ZodString;
+    active: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** Reserved — no current source records an actor, so usually absent. */
+    changed_by: z.ZodOptional<z.ZodString>;
+    changed_at: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    version: z.ZodNumber;
+    /** Omitted (omitzero) when the source never stamped one. */
+    effective_from: z.ZodOptional<z.ZodString>;
+    bundle_hash: z.ZodOptional<z.ZodString>;
+    /** "registry" (S3 version object) | "bundle" (seeded) | "store". */
+    source: z.ZodString;
+    active: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** Reserved — no current source records an actor, so usually absent. */
+    changed_by: z.ZodOptional<z.ZodString>;
+    changed_at: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    version: z.ZodNumber;
+    /** Omitted (omitzero) when the source never stamped one. */
+    effective_from: z.ZodOptional<z.ZodString>;
+    bundle_hash: z.ZodOptional<z.ZodString>;
+    /** "registry" (S3 version object) | "bundle" (seeded) | "store". */
+    source: z.ZodString;
+    active: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** Reserved — no current source records an actor, so usually absent. */
+    changed_by: z.ZodOptional<z.ZodString>;
+    changed_at: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export type PlaybookVersionEntry = z.infer<typeof versionEntrySchema>;
+/** Every recorded version of a playbook, sorted newest (highest) first. */
+export declare const listPlaybookVersions: (playbookId: string) => Promise<PlaybookVersionEntry[]>;
+declare const versionRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+export type VersionRule = z.infer<typeof versionRuleSchema>;
+/** The rules of a playbook at version `n`. */
+export declare const getVersionRules: (playbookId: string, version: number) => Promise<VersionRule[]>;
+export {};

package/dist/api/workspace.d.ts

@@ -0,0 +1,41 @@
+/** Why a persist attempt did not take effect. */
+export type WorkspacePersistFailure = 
+/** 400 — the id is not `[A-Za-z0-9_.-]{1,64}`; a configuration bug. */
+"invalid_id"
+/** 401 — no authenticated principal reached the server. */
+ | "unauthorized"
+/** 403 — the id exists but belongs to another account. */
+ | "forbidden"
+/** 404 — never registered, or already swept. Nothing left to keep. */
+ | "not_found"
+/** 500 — the server failed to record it; retrying is reasonable. */
+ | "internal"
+/** The request never reached the server. */
+ | "network"
+/** A status the contract does not describe. */
+ | "unknown";
+export type WorkspacePersistResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: WorkspacePersistFailure;
+    /** The server's `message`, or a fallback when there was no envelope. */
+    message: string;
+    /** Absent for `network`. */
+    status?: number;
+};
+/**
+ * Exempts a workspace from inactivity expiry. Idempotent — persisting an
+ * already-persisted workspace is another 204.
+ *
+ * TWO DIFFERENT WORKSPACES ARE IN PLAY, and keeping them separate is what
+ * makes this endpoint's errors mean anything. `X-Workspace-Id` — supplied by
+ * request()'s configured workspaceId, as in every sibling client — names the
+ * CALLER's workspace; the path names the TARGET. Do not "simplify" this by
+ * overriding the header per call: the auth middleware resolves the header
+ * workspace BEFORE the handler runs, and that resolver *creates* an unknown id
+ * on first sight and collapses malformed/foreign ids into a single
+ * `403 no_workspace`. Naming the target in the header therefore makes the
+ * handler's own 400/403/404 unreachable — measured, not theorised.
+ */
+export declare const persistWorkspace: (workspaceId: string) => Promise<WorkspacePersistResult>;

package/dist/components/EditorSidebar.d.ts

@@ -2,6 +2,9 @@ import type { TEditorMode } from "@/constants/Toolbar";
 interface EditorSidebarProps {
     position?: 'left' | 'right';
     currentMode: TEditorMode;
+    /** When set, the AI review cards render in the dedicated "Redlines" tool,
+     * and the sidebar defaults to that tool expanded. */
+    aiReviewContent?: React.ReactNode;
 }
-export declare const EditorSidebar: ({ position, currentMode }: EditorSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EditorSidebar: ({ position, currentMode, aiReviewContent }: EditorSidebarProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/audit/AuditView.d.ts

@@ -0,0 +1,8 @@
+import { type AuditEvent, type AuditApiConfig } from "@/api/audit";
+export interface AuditViewProps {
+    /** API endpoint config (base URL / workspace). */
+    api?: AuditApiConfig;
+}
+/** The most specific id the event is about. */
+export declare const subjectId: (e: AuditEvent) => string;
+export declare const AuditView: ({ api }: AuditViewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/capturededits/AddAsRuleModal.d.ts

@@ -0,0 +1,8 @@
+import type { CapturedEdit } from "@/contexts/CapturedEditsContext";
+export interface AddAsRuleModalProps {
+    edit: CapturedEdit;
+    onClose: () => void;
+    /** Called with the persisted rule id; the caller flips the card to resolved. */
+    onAdded: (ruleId: string) => void;
+}
+export declare const AddAsRuleModal: (props: AddAsRuleModalProps) => import("react").ReactPortal;

package/dist/components/capturededits/CapturedEditCard.d.ts

@@ -0,0 +1,15 @@
+import type { CapturedEdit } from "@/contexts/CapturedEditsContext";
+export declare const DiffBox: ({ before, after, clampLines, }: {
+    before: string;
+    after: string;
+    /** 6 on tray cards, 3 in the modal's compact context block. */
+    clampLines: 3 | 6;
+}) => import("react/jsx-runtime").JSX.Element;
+export interface CapturedEditCardProps {
+    edit: CapturedEdit;
+    /** Non-null = rule drafting unavailable; the reason disables Add-as-rule. */
+    addDisabledReason: string | null;
+    onDismiss: () => void;
+    onAddAsRule: () => void;
+}
+export declare const CapturedEditCard: (props: CapturedEditCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/capturededits/CapturedEditsTray.d.ts

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

package/dist/components/capturededits/capturedEditIntent.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The FROZEN captured-edit → from-text intent template (WS-B handoff).
+ *
+ * The backend's from-text prompt scaffold is proven against EXACTLY this
+ * template (mirrored test-side in `capturedEditIntent()`,
+ * `rules_author_capturededit_test.go`). Do not reword it — the FE test pins
+ * it byte-exact.
+ *
+ * Slot rules:
+ * - clause_context: clause heading / type + section ref if known.
+ * - before_text: clause text at doc-open (the card's "before"), trimmed to
+ *   the edited clause.
+ * - after_text: coalesced current clause text after the human edit.
+ * - before/after are truncated to MAX_SLOT_CHARS with a trailing ellipsis so
+ *   the intent stays within a few KB.
+ */
+export declare const MAX_SLOT_CHARS = 1500;
+export interface CapturedEditIntentInput {
+    clauseLabel: string;
+    before: string;
+    after: string;
+}
+export declare const capturedEditIntentText: (input: CapturedEditIntentInput) => string;

package/dist/components/common/EscDropdown.d.ts

@@ -0,0 +1,2 @@
+import type { DropdownProps } from "antd";
+export declare const Dropdown: ({ open: controlledOpen, onOpenChange, ...rest }: DropdownProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/compliance/MethodologyPanel.d.ts

@@ -0,0 +1,14 @@
+import { type MethodologyApiConfig } from "@/api/methodology";
+export interface MethodologyPanelProps {
+    /**
+     * Pre-seed the filter — typically the category or severity of the finding
+     * the reviewer opened help from.
+     */
+    focusTerm?: string;
+    /** Fetch immediately rather than on the first expand. */
+    openByDefault?: boolean;
+    /** Auth/baseUrl pass-through for src/api/methodology.ts (the PlaybookPanel idiom). */
+    api?: MethodologyApiConfig;
+}
+export declare const MethodologyPanel: ({ focusTerm, openByDefault, api, }: MethodologyPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default MethodologyPanel;

package/dist/components/compliance/RegSyncPanel.d.ts

@@ -0,0 +1,18 @@
+import { type PlaybookApiConfig } from "@/api/playbook";
+export interface RegSyncPanelProps {
+    /**
+     * Navigate to a rule (the playbook panel's rule detail). Omitted → the rule
+     * rows render as static text rather than fake links.
+     */
+    onOpenRule?: (ruleId: string, playbookId: string) => void;
+    /** Run the check on mount instead of waiting for the button. */
+    autoCheck?: boolean;
+    /**
+     * Auth/baseUrl pass-through (the PlaybookPanel idiom). Both API modules this
+     * panel calls — regsync and the rule catalog — ride src/api/playbook.ts's
+     * shared fetch core, so one PlaybookApiConfig configures them both.
+     */
+    api?: PlaybookApiConfig;
+}
+export declare const RegSyncPanel: ({ onOpenRule, autoCheck, api }: RegSyncPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default RegSyncPanel;

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

@@ -0,0 +1,8 @@
+/**
+ * Compliance surfaces: the FAR/DFARS regulation-change alert and the
+ * "why was this flagged?" methodology reference.
+ */
+export { RegSyncPanel } from "./RegSyncPanel";
+export type { RegSyncPanelProps } from "./RegSyncPanel";
+export { MethodologyPanel } from "./MethodologyPanel";
+export type { MethodologyPanelProps } from "./MethodologyPanel";

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

@@ -0,0 +1,41 @@
+/**
+ * Shared presentational pieces for the compliance surfaces (reg-sync,
+ * methodology). Token-only styling per the lax design system — no hardcoded
+ * hex, both themes handled by the tokens themselves.
+ *
+ * Deliberately a local copy rather than an import from components/r1 or
+ * components/playbook: those primitives belong to their own screens and are
+ * moving under other workstreams. The overlap is ~40 lines of CSS.
+ */
+import type { ReactNode } from "react";
+export declare const COMPLIANCE_CSS = "\n.cmp-root{box-sizing:border-box;font-family:var(--font-ui);color:var(--pb-text-primary)}\n.cmp-root *{box-sizing:border-box}\n.cmp-btn{font-family:var(--font-ui);border-radius:var(--radius-control);cursor:pointer;font-weight:600;font-size:12px;padding:6px 13px;transition:background .15s ease, border-color .15s ease}\n.cmp-btn:disabled{opacity:.55;cursor:default}\n.cmp-primary{background:var(--action);color:var(--action-on);border:none}\n.cmp-primary:hover:not(:disabled){background:var(--action-hover)}\n.cmp-secondary{background:var(--pb-panel);color:var(--pb-text-secondary);border:1px solid var(--pb-border-strong)}\n.cmp-secondary:hover:not(:disabled){background:var(--pb-card)}\n.cmp-link{background:none;border:none;padding:0;cursor:pointer;font-family:var(--font-ui);font-size:12px;color:var(--action-link);font-weight:600;text-align:left}\n.cmp-link:hover{text-decoration:underline}\n.cmp-card{background:var(--pb-panel);border:1px solid var(--pb-border-strong);border-radius:var(--radius-control)}\n.cmp-input{width:100%;font-family:var(--font-ui);font-size:12.5px;color:var(--pb-text-body);background:var(--pb-panel);border:1px solid var(--pb-border-strong);border-radius:var(--radius-control);padding:7px 10px}\n.cmp-input:focus{outline:none;border-color:var(--action);box-shadow:0 0 0 2px var(--action-tint)}\n.cmp-scroll{scrollbar-width:thin;overflow-y:auto}\n.cmp-body{font-family:var(--font-document);font-size:12.5px;line-height:1.55;color:var(--pb-text-body);white-space:pre-wrap;word-break:break-word}\n";
+/** Panel section heading — 14px/600, the design system's `--text-label`. */
+export declare const SectionLabel: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/** Muted explanatory line under a heading. */
+export declare const Caption: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/** Failure strip. `tone="warning"` for a degraded-but-usable state. */
+export declare const NoticeStrip: ({ message, tone, action, }: {
+    message: ReactNode;
+    tone?: "error" | "warning" | "info";
+    action?: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/** Monospace clause / rule identifier chip. */
+export declare const RefChip: ({ children, title }: {
+    children: ReactNode;
+    title?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Severity chip on the 3-tier ramp (REQ-R1). Reg-sync maps change kinds onto
+ * the ramp by what the change costs a reviewer who relies on the clause:
+ *   removed → T1  a rule cites a clause that no longer exists
+ *   revised → T2  the rule's premise moved; re-read it
+ *   added   → T3  new clause in the family; nothing is wrong yet
+ */
+export declare const TierChip: ({ tier, label }: {
+    tier: 1 | 2 | 3;
+    label: string;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { type DocumentVersionsApiConfig } from "@/api/documentVersions";
+export interface DocumentVersionHistoryProps {
+    /** The git-store document whose history to show. */
+    docId: string;
+    /** Display name for the header (falls back to the id). */
+    documentName?: string;
+    /** API endpoint config (base URL / workspace). */
+    api?: DocumentVersionsApiConfig;
+    /** Called after a successful rollback, with the new head commit id. */
+    onRestored?: (newCommitId: string) => void;
+}
+export declare const DocumentVersionHistory: ({ docId, documentName, api, onRestored, }: DocumentVersionHistoryProps) => import("react/jsx-runtime").JSX.Element;