@plures/praxis 1.4.0 → 1.4.4

package/dist/node/index.d.cts

@@ -789,6 +789,576 @@ declare class BehaviorLedger {
  */
 declare function createBehaviorLedger(): BehaviorLedger;
 
+/**
+ * Decision Ledger — Analyzer Types
+ *
+ * Types for the graph analysis engine that understands the entire rule graph
+ * and finds what's missing, broken, or unreachable.
+ */
+/** A node in the fact dependency graph */
+interface FactNode {
+    /** The fact tag */
+    tag: string;
+    /** Rules that produce this fact */
+    producedBy: string[];
+    /** Rules that read/consume this fact */
+    consumedBy: string[];
+}
+/** An edge in the dependency graph (rule → fact or fact → rule) */
+interface DependencyEdge {
+    from: string;
+    to: string;
+    type: 'produces' | 'consumes';
+}
+/** The full dependency graph */
+interface DependencyGraph {
+    /** Fact nodes keyed by tag */
+    facts: Map<string, FactNode>;
+    /** All edges */
+    edges: DependencyEdge[];
+    /** Rule IDs that produce facts */
+    producers: Map<string, string[]>;
+    /** Rule IDs that consume facts */
+    consumers: Map<string, string[]>;
+}
+/** A single step in a derivation chain */
+interface DerivationStep {
+    type: 'event' | 'rule-fired' | 'fact-produced' | 'fact-read';
+    id: string;
+    description: string;
+}
+/** A chain showing how a fact was derived */
+interface DerivationChain {
+    /** The target fact tag */
+    targetFact: string;
+    /** Ordered steps from origin to target */
+    steps: DerivationStep[];
+    /** Depth of the chain */
+    depth: number;
+}
+/** A rule that can never fire given known event types */
+interface DeadRule {
+    ruleId: string;
+    description: string;
+    /** Event types the rule requires */
+    requiredEventTypes: string[];
+    /** Why it's dead */
+    reason: string;
+}
+/** A fact combination that no rule sequence can produce */
+interface UnreachableState {
+    /** The fact tags that can't be produced together */
+    factTags: string[];
+    /** Why it's unreachable */
+    reason: string;
+}
+/** A rule that always loses to another */
+interface ShadowedRule {
+    /** The shadowed rule */
+    ruleId: string;
+    /** The rule that shadows it */
+    shadowedBy: string;
+    /** Shared event types */
+    sharedEventTypes: string[];
+    /** Why it's shadowed */
+    reason: string;
+}
+/** Two rules that produce conflicting facts */
+interface Contradiction {
+    /** First rule */
+    ruleA: string;
+    /** Second rule */
+    ruleB: string;
+    /** The conflicting fact tag */
+    conflictingTag: string;
+    /** Description of the conflict */
+    reason: string;
+}
+/** An expected behavior with no covering rule */
+interface Gap {
+    /** The expectation name */
+    expectationName: string;
+    /** What's missing */
+    description: string;
+    /** Related rule IDs that partially cover */
+    partialCoverage: string[];
+    /** The type of gap */
+    type: 'no-rule' | 'partial-coverage' | 'no-contract';
+}
+/** Impact of removing a fact */
+interface ImpactReport {
+    /** The fact being analyzed */
+    factTag: string;
+    /** Rules that would stop firing */
+    affectedRules: string[];
+    /** Facts that would disappear (transitively) */
+    affectedFacts: string[];
+    /** Total downstream impact depth */
+    depth: number;
+}
+/** Result of running a contract example against its rule */
+interface ExampleVerification {
+    /** The example index */
+    index: number;
+    /** Given/When/Then description */
+    given: string;
+    when: string;
+    expectedThen: string;
+    /** Whether it passed */
+    passed: boolean;
+    /** Actual output if different */
+    actualOutput?: string;
+    /** Error if execution failed */
+    error?: string;
+}
+/** Contract verification result for a single rule */
+interface ContractVerificationResult {
+    ruleId: string;
+    /** Example verification results */
+    examples: ExampleVerification[];
+    /** Whether all examples passed */
+    allPassed: boolean;
+    /** Number of passing examples */
+    passCount: number;
+    /** Number of failing examples */
+    failCount: number;
+}
+/** Invariant check result */
+interface InvariantCheck {
+    /** The invariant statement */
+    invariant: string;
+    /** The rule it belongs to */
+    ruleId: string;
+    /** Whether it holds */
+    holds: boolean;
+    /** Explanation */
+    explanation: string;
+}
+/** Contract gap finding (deeper than registration-time) */
+interface ContractCoverageGap {
+    ruleId: string;
+    /** What's not covered */
+    description: string;
+    /** Type of gap */
+    type: 'missing-edge-case' | 'missing-error-path' | 'missing-boundary' | 'cross-reference-broken';
+}
+/** Cross-reference result */
+interface CrossReference {
+    /** Rule whose contract references another rule's facts */
+    sourceRuleId: string;
+    /** The referenced fact tag */
+    referencedFactTag: string;
+    /** The rule that produces the referenced fact (or null if missing) */
+    producerRuleId: string | null;
+    /** Whether the producer exists */
+    valid: boolean;
+}
+/** Types of findings that can generate suggestions */
+type FindingType = 'dead-rule' | 'gap' | 'contradiction' | 'unreachable-state' | 'shadowed-rule' | 'contract-gap';
+/** An actionable fix suggestion */
+interface Suggestion {
+    /** What finding this addresses */
+    findingType: FindingType;
+    /** Related entity ID */
+    entityId: string;
+    /** Human-readable suggestion */
+    message: string;
+    /** Suggested action type */
+    action: 'remove' | 'add-rule' | 'modify' | 'merge' | 'add-priority' | 'add-event-type' | 'add-contract';
+    /** Priority (higher = more important) */
+    priority: number;
+    /** Optional code skeleton */
+    skeleton?: string;
+}
+/** The complete analysis report from the decision ledger analyzer */
+interface AnalysisReport {
+    /** Timestamp of the analysis */
+    timestamp: string;
+    /** Fact derivation chains */
+    factDerivationChains: DerivationChain[];
+    /** Rules that can never fire */
+    deadRules: DeadRule[];
+    /** Fact combos no rule can produce */
+    unreachableStates: UnreachableState[];
+    /** Rules always overshadowed by another */
+    shadowedRules: ShadowedRule[];
+    /** Rules producing conflicting facts */
+    contradictions: Contradiction[];
+    /** Expected behaviors with no covering rule */
+    gaps: Gap[];
+    /** Actionable fix suggestions */
+    suggestions: Suggestion[];
+    /** Summary statistics */
+    summary: {
+        totalRules: number;
+        totalConstraints: number;
+        deadRuleCount: number;
+        unreachableStateCount: number;
+        shadowedRuleCount: number;
+        contradictionCount: number;
+        gapCount: number;
+        suggestionCount: number;
+        healthScore: number;
+    };
+}
+/** A change between two analysis runs */
+interface LedgerDiffEntry {
+    type: 'added' | 'removed' | 'changed';
+    category: 'dead-rule' | 'unreachable-state' | 'shadowed-rule' | 'contradiction' | 'gap' | 'suggestion';
+    description: string;
+    /** Entity ID (rule, state, etc.) */
+    entityId: string;
+}
+/** Diff between two analysis reports */
+interface LedgerDiff {
+    /** Timestamp of the diff */
+    timestamp: string;
+    /** Before report timestamp */
+    beforeTimestamp: string;
+    /** After report timestamp */
+    afterTimestamp: string;
+    /** Changes found */
+    changes: LedgerDiffEntry[];
+    /** Score change */
+    scoreDelta: number;
+    /** Summary */
+    summary: string;
+}
+
+/**
+ * Expectations DSL — Types
+ *
+ * Types for declaring behavioral expectations about rules.
+ * Expectations replace traditional tests with behavioral declarations.
+ */
+/** A condition under which a behavior should or should not occur. */
+interface ExpectationCondition {
+    /** Human-readable condition description */
+    description: string;
+    /** Type of expectation */
+    type: 'onlyWhen' | 'never' | 'always';
+}
+/** Verification status for a single expectation condition. */
+type ConditionStatus = 'satisfied' | 'violated' | 'unverifiable';
+/** Detailed result for a single condition check. */
+interface ConditionResult {
+    condition: ExpectationCondition;
+    status: ConditionStatus;
+    /** Explanation of how the condition was verified or why it couldn't be */
+    explanation: string;
+    /** Related rule IDs that informed this check */
+    relatedRules: string[];
+}
+/** Verification result for a single Expectation. */
+interface ExpectationResult {
+    /** The expectation name/ID */
+    name: string;
+    /** Overall status: satisfied if ALL conditions pass */
+    status: 'satisfied' | 'violated' | 'partial';
+    /** Per-condition results */
+    conditions: ConditionResult[];
+    /** Edge cases discovered */
+    edgeCases: string[];
+    /** Suggested mitigations for violated/partial expectations */
+    mitigations: string[];
+}
+/** Full verification report for an ExpectationSet. */
+interface VerificationReport {
+    /** Set name */
+    setName: string;
+    /** Timestamp of verification */
+    timestamp: string;
+    /** Overall status: satisfied if ALL expectations are satisfied */
+    status: 'satisfied' | 'violated' | 'partial';
+    /** Per-expectation results */
+    expectations: ExpectationResult[];
+    /** Summary stats */
+    summary: {
+        total: number;
+        satisfied: number;
+        violated: number;
+        partial: number;
+    };
+    /** All edge cases found across all expectations */
+    allEdgeCases: string[];
+    /** All mitigations suggested */
+    allMitigations: string[];
+}
+/** Options for creating an ExpectationSet */
+interface ExpectationSetOptions {
+    /** Name/domain for this set of expectations */
+    name: string;
+    /** Optional description */
+    description?: string;
+}
+/** Interface describing a rule or constraint for verification */
+interface VerifiableDescriptor {
+    id: string;
+    description: string;
+    eventTypes?: string | string[];
+    contract?: {
+        behavior: string;
+        examples: Array<{
+            given: string;
+            when: string;
+            then: string;
+        }>;
+        invariants: string[];
+        ruleId: string;
+    };
+}
+/** Registry-like interface for verification */
+interface VerifiableRegistry {
+    getAllRules(): VerifiableDescriptor[];
+    getAllConstraints(): VerifiableDescriptor[];
+    getRuleIds(): string[];
+    getConstraintIds(): string[];
+}
+
+/**
+ * Expectations DSL — Core
+ *
+ * Behavioral declarations for Praxis rules. Instead of writing test
+ * assertions, you declare what behaviors you expect from your system.
+ *
+ * @example
+ * ```ts
+ * import { expectBehavior, ExpectationSet, verify } from '@plures/praxis/expectations';
+ *
+ * const expectations = new ExpectationSet({ name: 'settings' });
+ *
+ * expectations.add(
+ *   expectBehavior('settings-saved-toast')
+ *     .onlyWhen('settings.diff is non-empty')
+ *     .never('when settings panel opens without changes')
+ *     .never('when save fails')
+ *     .always('includes which settings changed')
+ * );
+ *
+ * const report = verify(registry, expectations);
+ * ```
+ */
+
+/**
+ * A behavioral expectation declaration.
+ *
+ * Chainable API for declaring conditions under which a behavior
+ * should or should not occur.
+ */
+declare class Expectation {
+    readonly name: string;
+    private _conditions;
+    constructor(name: string);
+    /**
+     * Declare that this behavior should ONLY occur when a condition is true.
+     * If the condition is false, the behavior should NOT occur.
+     */
+    onlyWhen(condition: string): this;
+    /**
+     * Declare that this behavior should NEVER occur under a given condition.
+     */
+    never(condition: string): this;
+    /**
+     * Declare that this behavior should ALWAYS have a certain property.
+     */
+    always(condition: string): this;
+    /** Get all declared conditions. */
+    get conditions(): ReadonlyArray<ExpectationCondition>;
+}
+/**
+ * A collection of expectations for a specific domain.
+ */
+declare class ExpectationSet {
+    readonly name: string;
+    readonly description: string;
+    private _expectations;
+    constructor(options: ExpectationSetOptions);
+    /** Add an expectation to the set. */
+    add(expectation: Expectation): this;
+    /** Get all expectations in this set. */
+    get expectations(): ReadonlyArray<Expectation>;
+    /** Number of expectations. */
+    get size(): number;
+}
+/**
+ * Create a new behavioral expectation.
+ *
+ * @example
+ * ```ts
+ * expectBehavior('settings-saved-toast')
+ *   .onlyWhen('settings.diff is non-empty')
+ *   .never('when save fails')
+ *   .always('includes which settings changed');
+ * ```
+ */
+declare function expectBehavior(name: string): Expectation;
+/**
+ * Verify expectations against a rule registry.
+ *
+ * Walks the rule graph to determine if expectations are satisfied,
+ * violated, or unverifiable given the registered rules and contracts.
+ */
+declare function verify(registry: VerifiableRegistry, expectations: ExpectationSet): VerificationReport;
+/**
+ * Format a verification report as human-readable text.
+ */
+declare function formatVerificationReport(report: VerificationReport): string;
+
+/**
+ * Decision Ledger — Graph Analysis Engine
+ *
+ * Builds the fact dependency graph and analyzes the rule registry
+ * for dead rules, unreachable states, shadowed rules, contradictions,
+ * and gaps in behavioral expectations.
+ */
+
+/**
+ * Build the fact dependency graph from a registry.
+ *
+ * This runs each rule with synthetic probe events to discover which facts
+ * it reads from state and which facts it produces. For static analysis we
+ * inspect rule metadata, contracts, event types, and probe execution.
+ */
+declare function analyzeDependencyGraph<TContext = unknown>(registry: PraxisRegistry<TContext>): DependencyGraph;
+/**
+ * Find rules that can never fire given known event types.
+ */
+declare function findDeadRules<TContext = unknown>(registry: PraxisRegistry<TContext>, knownEventTypes: string[]): DeadRule[];
+/**
+ * Find fact combinations that no rule sequence can produce.
+ *
+ * This checks pairs of facts where each fact can be produced individually
+ * but no single rule or chain produces both. This is conservative —
+ * if two facts are produced by completely independent rules that never
+ * fire together, they form an unreachable state pair.
+ */
+declare function findUnreachableStates<TContext = unknown>(registry: PraxisRegistry<TContext>): UnreachableState[];
+/**
+ * Find rules where another rule with same event types always produces
+ * a superset of the facts.
+ */
+declare function findShadowedRules<TContext = unknown>(registry: PraxisRegistry<TContext>): ShadowedRule[];
+/**
+ * Find rules that produce facts with the same tag but potentially conflicting
+ * payloads under the same event conditions.
+ */
+declare function findContradictions<TContext = unknown>(registry: PraxisRegistry<TContext>): Contradiction[];
+/**
+ * Find expectations that have no covering rule or only partial coverage.
+ */
+declare function findGaps<TContext = unknown>(registry: PraxisRegistry<TContext>, expectations: ExpectationSet): Gap[];
+
+/**
+ * Decision Ledger — Fact Derivation Tracing
+ *
+ * Trace how facts are derived through chains of rule firings,
+ * and analyze the impact of removing a fact from the system.
+ */
+
+/**
+ * Trace how a fact was derived through the rule chain.
+ *
+ * Starting from the fact tag, walks backward through the dependency graph
+ * to find the full derivation chain: event → rule A → fact X → rule B → fact Y
+ *
+ * Uses the engine's current state to identify which rules actually fired.
+ */
+declare function traceDerivation<TContext = unknown>(factTag: string, _engine: LogicEngine<TContext>, registry: PraxisRegistry<TContext>): DerivationChain;
+/**
+ * Trace the impact of removing a fact from the system.
+ *
+ * Returns which rules would stop firing and which downstream facts
+ * would disappear if the given fact were removed.
+ */
+declare function traceImpact<TContext = unknown>(factTag: string, registry: PraxisRegistry<TContext>): ImpactReport;
+
+/**
+ * Decision Ledger — Contract Verification
+ *
+ * Goes beyond simple contract existence checking to actually run rules
+ * against their contract examples, verify invariants, and cross-reference
+ * fact dependencies between contracts.
+ */
+
+/**
+ * Actually run a rule's implementation against each contract example's
+ * `given` state and verify the output matches `then`.
+ *
+ * This is deeper than contract existence checking — it executes the rule.
+ */
+declare function verifyContractExamples<TContext = unknown>(rule: RuleDescriptor<TContext>, contract: Contract): ContractVerificationResult;
+/**
+ * Check that stated invariants hold across all rules.
+ *
+ * For each rule with a contract, check if the invariants are consistent
+ * with the rule's behavior description and examples.
+ */
+declare function verifyInvariants<TContext = unknown>(registry: PraxisRegistry<TContext>): InvariantCheck[];
+/**
+ * Find rules with contracts that don't cover all code paths.
+ *
+ * Analyzes contract examples to find:
+ * - Rules with only happy-path examples (no error cases)
+ * - Rules with no boundary condition examples
+ * - Rules that handle multiple event types but only have examples for some
+ */
+declare function findContractGaps<TContext = unknown>(registry: PraxisRegistry<TContext>): ContractCoverageGap[];
+/**
+ * Find contracts that reference facts from other rules and verify
+ * those producing rules actually exist.
+ */
+declare function crossReferenceContracts<TContext = unknown>(registry: PraxisRegistry<TContext>): CrossReference[];
+
+/**
+ * Decision Ledger — Actionable Fix Suggestions
+ *
+ * For each finding from the analyzer, generates concrete,
+ * actionable suggestions with optional code skeletons.
+ */
+
+/**
+ * Generate a suggestion for any type of finding.
+ */
+declare function suggest(finding: DeadRule | UnreachableState | ShadowedRule | Contradiction | Gap | ContractCoverageGap, type: FindingType): Suggestion;
+/**
+ * Generate suggestions for all findings at once.
+ */
+declare function suggestAll(findings: {
+    deadRules?: DeadRule[];
+    gaps?: Gap[];
+    contradictions?: Contradiction[];
+    unreachableStates?: UnreachableState[];
+    shadowedRules?: ShadowedRule[];
+    contractGaps?: ContractCoverageGap[];
+}): Suggestion[];
+
+/**
+ * Decision Ledger — Report Generation
+ *
+ * Generates the full analysis report, human-readable markdown,
+ * CI-friendly output, and diffs between analysis runs.
+ */
+
+/**
+ * Generate the full analysis report.
+ *
+ * This is the main entry point for the Decision Ledger analyzer.
+ * It runs all analyses and produces a comprehensive report.
+ */
+declare function generateLedger<TContext = unknown>(registry: PraxisRegistry<TContext>, engine: LogicEngine<TContext>, expectations?: ExpectationSet): AnalysisReport;
+/**
+ * Format an analysis report as human-readable markdown.
+ */
+declare function formatLedger(report: AnalysisReport): string;
+/**
+ * Format report as CI-friendly output with warnings and errors.
+ */
+declare function formatBuildOutput(report: AnalysisReport): string;
+/**
+ * Diff two analysis reports to find what changed between them.
+ */
+declare function diffLedgers(before: AnalysisReport, after: AnalysisReport): LedgerDiff;
+
 /**
  * Praxis Schema Loader (Common/Browser Compatible)
  *
@@ -3507,296 +4077,117 @@ declare function resizeEvent(width: number, height: number): PraxisEvent;
  *
  * ## Measuring Completeness
  *
- * ### Quantitative Metrics
- * - **Rule Coverage**: (domain `if` branches in Praxis) / (total domain `if` branches)
- * - **Constraint Coverage**: (data invariants in Praxis) / (total data invariants)
- * - **Contract Coverage**: (rules with contracts) / (rules that need contracts)
- * - **Context Coverage**: (state fields wired to context) / (state fields rules need)
- * - **Event Coverage**: (state transitions with events) / (state transitions that matter)
- *
- * ### Qualitative Indicators
- * - Can you change a business rule by editing ONE rule definition? (single source of truth)
- * - Can you test a business rule without rendering UI? (Praxis engine is headless)
- * - Can you explain every business rule to a PM by reading the registry? (self-documenting)
- * - Does the PraxisPanel show all active concerns? (observable)
- *
- * ## The Completeness Score
- *
- * ```
- * Score = (
- *   rulesCovered / totalDomainBranches * 40 +     // Rules are king (40%)
- *   constraintsCovered / totalInvariants * 20 +    // Invariants matter (20%)
- *   contractsCovered / rulesNeedingContracts * 15 + // Contracts prevent bugs (15%)
- *   contextFieldsCovered / totalNeeded * 15 +       // Context = visibility (15%)
- *   eventsCovered / totalTransitions * 10            // Events = reactivity (10%)
- * )
- * ```
- *
- * 90+ = Complete | 70-89 = Good | 50-69 = Partial | <50 = Incomplete
- */
-interface LogicBranch {
-    /** Source file + line */
-    location: string;
-    /** The condition expression */
-    condition: string;
-    /** Classification */
-    kind: 'domain' | 'invariant' | 'ui' | 'transport' | 'wiring' | 'transform';
-    /** If domain/invariant: the Praxis rule/constraint that covers it, or null */
-    coveredBy: string | null;
-    /** Human note */
-    note?: string;
-}
-interface StateField {
-    /** Store or source name */
-    source: string;
-    /** Field path */
-    field: string;
-    /** Whether it's in the Praxis context */
-    inContext: boolean;
-    /** Whether any rule references it */
-    usedByRule: boolean;
-}
-interface StateTransition {
-    /** What changes */
-    description: string;
-    /** The Praxis event tag, or null if missing */
-    eventTag: string | null;
-    /** Source location */
-    location: string;
-}
-interface CompletenessReport {
-    /** Overall score (0-100) */
-    score: number;
-    /** Rating */
-    rating: 'complete' | 'good' | 'partial' | 'incomplete';
-    rules: {
-        total: number;
-        covered: number;
-        uncovered: LogicBranch[];
-    };
-    constraints: {
-        total: number;
-        covered: number;
-        uncovered: LogicBranch[];
-    };
-    contracts: {
-        total: number;
-        withContracts: number;
-        missing: string[];
-    };
-    context: {
-        total: number;
-        covered: number;
-        missing: StateField[];
-    };
-    events: {
-        total: number;
-        covered: number;
-        missing: StateTransition[];
-    };
-}
-interface CompletenessConfig {
-    /** Minimum score to pass (default: 90) */
-    threshold?: number;
-    /** Whether to throw on failure (for CI) */
-    strict?: boolean;
-}
-/**
- * Run a completeness audit against a Praxis registry and app manifest.
- *
- * The manifest is a developer-authored declaration of all logic branches,
- * state fields, and state transitions in the app. The auditor checks which
- * ones are covered by Praxis.
- */
-declare function auditCompleteness(manifest: {
-    branches: LogicBranch[];
-    stateFields: StateField[];
-    transitions: StateTransition[];
-    rulesNeedingContracts: string[];
-}, registryRuleIds: string[], registryConstraintIds: string[], rulesWithContracts: string[], config?: CompletenessConfig): CompletenessReport;
-/**
- * Format a completeness report as human-readable text.
- */
-declare function formatReport(report: CompletenessReport): string;
-
-/**
- * Expectations DSL — Types
- *
- * Types for declaring behavioral expectations about rules.
- * Expectations replace traditional tests with behavioral declarations.
- */
-/** A condition under which a behavior should or should not occur. */
-interface ExpectationCondition {
-    /** Human-readable condition description */
-    description: string;
-    /** Type of expectation */
-    type: 'onlyWhen' | 'never' | 'always';
-}
-/** Verification status for a single expectation condition. */
-type ConditionStatus = 'satisfied' | 'violated' | 'unverifiable';
-/** Detailed result for a single condition check. */
-interface ConditionResult {
-    condition: ExpectationCondition;
-    status: ConditionStatus;
-    /** Explanation of how the condition was verified or why it couldn't be */
-    explanation: string;
-    /** Related rule IDs that informed this check */
-    relatedRules: string[];
-}
-/** Verification result for a single Expectation. */
-interface ExpectationResult {
-    /** The expectation name/ID */
-    name: string;
-    /** Overall status: satisfied if ALL conditions pass */
-    status: 'satisfied' | 'violated' | 'partial';
-    /** Per-condition results */
-    conditions: ConditionResult[];
-    /** Edge cases discovered */
-    edgeCases: string[];
-    /** Suggested mitigations for violated/partial expectations */
-    mitigations: string[];
-}
-/** Full verification report for an ExpectationSet. */
-interface VerificationReport {
-    /** Set name */
-    setName: string;
-    /** Timestamp of verification */
-    timestamp: string;
-    /** Overall status: satisfied if ALL expectations are satisfied */
-    status: 'satisfied' | 'violated' | 'partial';
-    /** Per-expectation results */
-    expectations: ExpectationResult[];
-    /** Summary stats */
-    summary: {
-        total: number;
-        satisfied: number;
-        violated: number;
-        partial: number;
-    };
-    /** All edge cases found across all expectations */
-    allEdgeCases: string[];
-    /** All mitigations suggested */
-    allMitigations: string[];
-}
-/** Options for creating an ExpectationSet */
-interface ExpectationSetOptions {
-    /** Name/domain for this set of expectations */
-    name: string;
-    /** Optional description */
-    description?: string;
-}
-/** Interface describing a rule or constraint for verification */
-interface VerifiableDescriptor {
-    id: string;
-    description: string;
-    eventTypes?: string | string[];
-    contract?: {
-        behavior: string;
-        examples: Array<{
-            given: string;
-            when: string;
-            then: string;
-        }>;
-        invariants: string[];
-        ruleId: string;
-    };
-}
-/** Registry-like interface for verification */
-interface VerifiableRegistry {
-    getAllRules(): VerifiableDescriptor[];
-    getAllConstraints(): VerifiableDescriptor[];
-    getRuleIds(): string[];
-    getConstraintIds(): string[];
-}
-
-/**
- * Expectations DSL — Core
- *
- * Behavioral declarations for Praxis rules. Instead of writing test
- * assertions, you declare what behaviors you expect from your system.
- *
- * @example
- * ```ts
- * import { expectBehavior, ExpectationSet, verify } from '@plures/praxis/expectations';
+ * ### Quantitative Metrics
+ * - **Rule Coverage**: (domain `if` branches in Praxis) / (total domain `if` branches)
+ * - **Constraint Coverage**: (data invariants in Praxis) / (total data invariants)
+ * - **Contract Coverage**: (rules with contracts) / (rules that need contracts)
+ * - **Context Coverage**: (state fields wired to context) / (state fields rules need)
+ * - **Event Coverage**: (state transitions with events) / (state transitions that matter)
  *
- * const expectations = new ExpectationSet({ name: 'settings' });
+ * ### Qualitative Indicators
+ * - Can you change a business rule by editing ONE rule definition? (single source of truth)
+ * - Can you test a business rule without rendering UI? (Praxis engine is headless)
+ * - Can you explain every business rule to a PM by reading the registry? (self-documenting)
+ * - Does the PraxisPanel show all active concerns? (observable)
  *
- * expectations.add(
- *   expectBehavior('settings-saved-toast')
- *     .onlyWhen('settings.diff is non-empty')
- *     .never('when settings panel opens without changes')
- *     .never('when save fails')
- *     .always('includes which settings changed')
- * );
+ * ## The Completeness Score
  *
- * const report = verify(registry, expectations);
  * ```
- */
-
-/**
- * A behavioral expectation declaration.
+ * Score = (
+ *   rulesCovered / totalDomainBranches * 40 +     // Rules are king (40%)
+ *   constraintsCovered / totalInvariants * 20 +    // Invariants matter (20%)
+ *   contractsCovered / rulesNeedingContracts * 15 + // Contracts prevent bugs (15%)
+ *   contextFieldsCovered / totalNeeded * 15 +       // Context = visibility (15%)
+ *   eventsCovered / totalTransitions * 10            // Events = reactivity (10%)
+ * )
+ * ```
  *
- * Chainable API for declaring conditions under which a behavior
- * should or should not occur.
+ * 90+ = Complete | 70-89 = Good | 50-69 = Partial | <50 = Incomplete
  */
-declare class Expectation {
-    readonly name: string;
-    private _conditions;
-    constructor(name: string);
-    /**
-     * Declare that this behavior should ONLY occur when a condition is true.
-     * If the condition is false, the behavior should NOT occur.
-     */
-    onlyWhen(condition: string): this;
-    /**
-     * Declare that this behavior should NEVER occur under a given condition.
-     */
-    never(condition: string): this;
-    /**
-     * Declare that this behavior should ALWAYS have a certain property.
-     */
-    always(condition: string): this;
-    /** Get all declared conditions. */
-    get conditions(): ReadonlyArray<ExpectationCondition>;
+interface LogicBranch {
+    /** Source file + line */
+    location: string;
+    /** The condition expression */
+    condition: string;
+    /** Classification */
+    kind: 'domain' | 'invariant' | 'ui' | 'transport' | 'wiring' | 'transform';
+    /** If domain/invariant: the Praxis rule/constraint that covers it, or null */
+    coveredBy: string | null;
+    /** Human note */
+    note?: string;
 }
-/**
- * A collection of expectations for a specific domain.
- */
-declare class ExpectationSet {
-    readonly name: string;
-    readonly description: string;
-    private _expectations;
-    constructor(options: ExpectationSetOptions);
-    /** Add an expectation to the set. */
-    add(expectation: Expectation): this;
-    /** Get all expectations in this set. */
-    get expectations(): ReadonlyArray<Expectation>;
-    /** Number of expectations. */
-    get size(): number;
+interface StateField {
+    /** Store or source name */
+    source: string;
+    /** Field path */
+    field: string;
+    /** Whether it's in the Praxis context */
+    inContext: boolean;
+    /** Whether any rule references it */
+    usedByRule: boolean;
+}
+interface StateTransition {
+    /** What changes */
+    description: string;
+    /** The Praxis event tag, or null if missing */
+    eventTag: string | null;
+    /** Source location */
+    location: string;
+}
+interface CompletenessReport {
+    /** Overall score (0-100) */
+    score: number;
+    /** Rating */
+    rating: 'complete' | 'good' | 'partial' | 'incomplete';
+    rules: {
+        total: number;
+        covered: number;
+        uncovered: LogicBranch[];
+    };
+    constraints: {
+        total: number;
+        covered: number;
+        uncovered: LogicBranch[];
+    };
+    contracts: {
+        total: number;
+        withContracts: number;
+        missing: string[];
+    };
+    context: {
+        total: number;
+        covered: number;
+        missing: StateField[];
+    };
+    events: {
+        total: number;
+        covered: number;
+        missing: StateTransition[];
+    };
+}
+interface CompletenessConfig {
+    /** Minimum score to pass (default: 90) */
+    threshold?: number;
+    /** Whether to throw on failure (for CI) */
+    strict?: boolean;
 }
 /**
- * Create a new behavioral expectation.
- *
- * @example
- * ```ts
- * expectBehavior('settings-saved-toast')
- *   .onlyWhen('settings.diff is non-empty')
- *   .never('when save fails')
- *   .always('includes which settings changed');
- * ```
- */
-declare function expectBehavior(name: string): Expectation;
-/**
- * Verify expectations against a rule registry.
+ * Run a completeness audit against a Praxis registry and app manifest.
  *
- * Walks the rule graph to determine if expectations are satisfied,
- * violated, or unverifiable given the registered rules and contracts.
+ * The manifest is a developer-authored declaration of all logic branches,
+ * state fields, and state transitions in the app. The auditor checks which
+ * ones are covered by Praxis.
  */
-declare function verify(registry: VerifiableRegistry, expectations: ExpectationSet): VerificationReport;
+declare function auditCompleteness(manifest: {
+    branches: LogicBranch[];
+    stateFields: StateField[];
+    transitions: StateTransition[];
+    rulesNeedingContracts: string[];
+}, registryRuleIds: string[], registryConstraintIds: string[], rulesWithContracts: string[], config?: CompletenessConfig): CompletenessReport;
 /**
- * Format a verification report as human-readable text.
+ * Format a completeness report as human-readable text.
  */
-declare function formatVerificationReport(report: VerificationReport): string;
+declare function formatReport(report: CompletenessReport): string;
 
 /**
  * Praxis Rules Factory — Types
@@ -4117,4 +4508,295 @@ declare function formatGate(config?: PredefinedGateConfig): PraxisModule<GateCon
  */
 declare function expectationGate(config?: PredefinedGateConfig): PraxisModule<GateContext>;
 
-export { AcknowledgeContractGap, type ActivityState, type Actor, ActorManager, Assumption, BehaviorLedger, type BranchRulesConfig, CHRONICLE_PATHS, type CanvasDocument, type CanvasEdge, type CanvasEdgeStyle, type CanvasEditorConfig, type CanvasNode, type CanvasNodeStyle, type Chronicle, ChronicleContext, type ChronicleEdge, type ChronicleEvent, type ChronicleNode, type ChronicleSpan, type ChronosMcpTools, type ChronosSearchParams, type ChronosTraceParams, type CompletenessConfig, type CompletenessReport, ComponentDefinition, type ConditionResult, type ConditionStatus, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, Contract, ContractAdded, ContractGapAcknowledged, ContractMissing, ContractUpdated, ContractValidated, type DataRulesConfig, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, type EdgeType, type EventDefinition, type EventStreamEntry, Expectation, type ExpectationCondition, type ExpectationResult, ExpectationSet, type ExpectationSetOptions, type FactDefinition, type FormRulesConfig, ReactiveLogicEngine as FrameworkAgnosticReactiveEngine, type ReactiveEngineOptions as FrameworkAgnosticReactiveEngineOptions, type GateConfig, type GateState, type GateStatus, type GeneratedDoc, type GeneratedPluresDBFile, type GraphEdge, type GuardianError, type GuardianResult, type GuardianWarning, type InputRulesConfig, type LedgerEntry, type LedgerEntryStatus, type LifecycleState, type LoaderOptions, type LoaderResult, type LogicBranch, LogicDefinition, LogicEngine, type McpToolResult, MissingArtifact, ModelDefinition, type NavigationRulesConfig, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, PluresDbChronicle, PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, type PraxisDiff, PraxisEvent, PraxisFact, PraxisModule, PraxisRegistry, PraxisSchema, PraxisSchemaRegistry, PraxisState, type PredefinedGateConfig, type RegistryGraph, RegistryIntrospector, type RegistrySchema, type RegistryStats, RuleDescriptor, RuleFn, type RuleNode, type RuleSchema, type SanitizationType, type SemverContractConfig, type SemverReport, Severity, type StateChangeCallback, type StateDoc, type StateDocsConfig, StateDocsGenerator, type StateField, type StateMachineDoc, type StateTransition, type StoredSchema, type TauriAppConfig, type TauriBridge, type TauriCommand, type TauriEvent, type TauriFS, type TauriFileEntry, type TauriMenuItem, type TauriNotification, type TauriNotificationOptions, type TauriPlugin, type TauriPraxisAdapter, type TauriSecurityConfig, type TauriTray, type TauriUpdateConfig, type TauriUpdateInfo, type TauriWindowConfig, type ToastRulesConfig, type TraceDirection, type TransitionDoc, type UIContext, type UnifiedApp, type UnifiedAppConfig, UnsubscribeFn$1 as UnsubscribeFn, type UnumAdapter, type UnumAdapterConfig, type UnumChannel, type UnumIdentity, type UnumMessage, type UnumStore, ValidateContracts, type ValidateOptions, ValidationReport, ValidationResult, type VerifiableDescriptor, type VerifiableRegistry, type VerificationReport, attachAllIntegrations, attachTauriToEngine, attachToEngine, attachUnumToEngine, auditCompleteness, branchRules, canvasToMermaid, canvasToSchema, canvasToYaml, commitFromState, createBehaviorLedger, createCanvasEditor, createChronicle, createChronosMcpTools, createReactiveEngine as createFrameworkAgnosticReactiveEngine, createIntrospector, createMockTauriBridge, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createSchemaRegistry, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUIModule, createUnifiedApp, createUnumAdapter, dataRules, defineConstraint, defineEvent, defineFact, defineGate, defineModule, defineRule, dirtyGuardRule, errorDisplayRule, expectBehavior, expectationGate, filterEvents, filterFacts, findEvent, findFact, formRules, formatGate, formatReport, formatValidationReport, formatValidationReportJSON, formatValidationReportSARIF, formatVerificationReport, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, initGateRule, inputRules, lintGate, loadSchema, loadSchemaFromFile, loadSchemaFromJson, loadSchemaFromYaml, loadingGateRule, mustBeInitializedConstraint, navigationRequest, navigationRules, noInteractionWhileLoadingConstraint, offlineIndicatorRule, registerSchema, resizeEvent, schemaToCanvas, semverContract, toastRules, uiModule, uiStateChanged, validateContracts, validateForGeneration, validateWithGuardian, verify, viewportRule };
+/**
+ * Project Chronicle — Core Event Store
+ *
+ * Records project lifecycle events (rule registrations, contract changes,
+ * gate transitions, build events, etc.) as a queryable, append-only log.
+ *
+ * This is the development-lifecycle counterpart to runtime Chronos:
+ * where runtime Chronos records "user typed, rule fired, fact emitted",
+ * project-level Chronos records "rule registered, contract updated,
+ * gate opened, completeness score changed."
+ */
+/** The kind of project lifecycle event. */
+type ProjectEventKind = 'rule' | 'contract' | 'expectation' | 'gate' | 'build' | 'fact';
+/**
+ * A single project lifecycle event.
+ *
+ * Immutable once recorded — the chronicle is append-only.
+ */
+interface ProjectEvent {
+    /** Event kind (rule, contract, expectation, gate, build, fact). */
+    kind: ProjectEventKind;
+    /**
+     * Action that occurred.
+     * Examples: 'registered', 'modified', 'removed', 'satisfied', 'violated',
+     *           'opened', 'closed', 'blocked', 'audit-complete', 'introduced', 'deprecated'.
+     */
+    action: string;
+    /** The subject (rule id, contract id, gate name, fact tag, etc.). */
+    subject: string;
+    /** Unix ms timestamp. */
+    timestamp: number;
+    /** Arbitrary metadata for this event. */
+    metadata: Record<string, unknown>;
+    /** Optional before/after diff for modifications. */
+    diff?: {
+        before: unknown;
+        after: unknown;
+    };
+}
+/** Options for creating a ProjectChronicle. */
+interface ProjectChronicleOptions {
+    /** Maximum events to retain (0 = unlimited, default 10_000). */
+    maxEvents?: number;
+    /** Optional clock function (for testing). */
+    now?: () => number;
+}
+/**
+ * In-memory, append-only chronicle of project lifecycle events.
+ *
+ * Thread-safe for single-threaded JS; immutable snapshots via `getEvents()`.
+ */
+declare class ProjectChronicle {
+    private events;
+    private readonly maxEvents;
+    private readonly now;
+    constructor(options?: ProjectChronicleOptions);
+    /**
+     * Record a project event. Returns the recorded event (with timestamp filled in).
+     */
+    record(event: Omit<ProjectEvent, 'timestamp'> & {
+        timestamp?: number;
+    }): ProjectEvent;
+    recordRuleRegistered(ruleId: string, meta?: Record<string, unknown>): ProjectEvent;
+    recordRuleModified(ruleId: string, diff: {
+        before: unknown;
+        after: unknown;
+    }, meta?: Record<string, unknown>): ProjectEvent;
+    recordRuleRemoved(ruleId: string, meta?: Record<string, unknown>): ProjectEvent;
+    recordContractAdded(contractId: string, meta?: Record<string, unknown>): ProjectEvent;
+    recordContractModified(contractId: string, diff: {
+        before: unknown;
+        after: unknown;
+    }, meta?: Record<string, unknown>): ProjectEvent;
+    recordExpectationSatisfied(name: string, meta?: Record<string, unknown>): ProjectEvent;
+    recordExpectationViolated(name: string, meta?: Record<string, unknown>): ProjectEvent;
+    recordGateTransition(gateName: string, from: string, to: string, meta?: Record<string, unknown>): ProjectEvent;
+    recordBuildAudit(score: number, delta: number, meta?: Record<string, unknown>): ProjectEvent;
+    recordFactIntroduced(factTag: string, meta?: Record<string, unknown>): ProjectEvent;
+    recordFactDeprecated(factTag: string, meta?: Record<string, unknown>): ProjectEvent;
+    /** Return a shallow copy of all events. */
+    getEvents(): ProjectEvent[];
+    /** Total number of recorded events. */
+    get size(): number;
+    /** Clear all events (primarily for testing). */
+    clear(): void;
+}
+/**
+ * Create a new ProjectChronicle instance.
+ */
+declare function createProjectChronicle(options?: ProjectChronicleOptions): ProjectChronicle;
+
+/**
+ * Timeline — Queryable view over ProjectChronicle events
+ *
+ * Provides filtering, range queries, subject history, and behavioral deltas.
+ */
+
+/** Filter criteria for timeline queries. All fields are optional (AND logic). */
+interface TimelineFilter {
+    /** Filter by event kind(s). */
+    kind?: ProjectEventKind | ProjectEventKind[];
+    /** Filter by action string(s). */
+    action?: string | string[];
+    /** Filter by subject (exact match or array). */
+    subject?: string | string[];
+    /** Only events at or after this timestamp (inclusive). */
+    since?: number;
+    /** Only events at or before this timestamp (inclusive). */
+    until?: number;
+}
+/** Summary of changes between two points in time. */
+interface BehavioralDelta {
+    /** Time range of this delta. */
+    from: number;
+    to: number;
+    /** Events within the range. */
+    events: ProjectEvent[];
+    /** Summary counts by kind. */
+    summary: Record<ProjectEventKind, number>;
+    /** Subjects that were added (first 'registered' / 'added' / 'introduced'). */
+    added: string[];
+    /** Subjects that were removed ('removed' / 'deprecated'). */
+    removed: string[];
+    /** Subjects that were modified. */
+    modified: string[];
+}
+/**
+ * Queryable timeline wrapping a ProjectChronicle.
+ *
+ * All query methods return new arrays — never the internal event store.
+ */
+declare class Timeline {
+    private readonly chronicle;
+    constructor(chronicle: ProjectChronicle);
+    /**
+     * Query events with optional filtering.
+     * Returns matching events sorted chronologically (oldest first).
+     */
+    getTimeline(filter?: TimelineFilter): ProjectEvent[];
+    /**
+     * Get all events since a timestamp (inclusive).
+     */
+    getEventsSince(timestamp: number): ProjectEvent[];
+    /**
+     * Compute a behavioral delta between two timestamps.
+     */
+    getDelta(from: number, to: number): BehavioralDelta;
+    /**
+     * Get full history for a specific subject (rule id, gate name, etc.).
+     * Sorted chronologically.
+     */
+    getHistory(subjectId: string): ProjectEvent[];
+}
+/**
+ * Create a Timeline for a given chronicle.
+ */
+declare function createTimeline(chronicle: ProjectChronicle): Timeline;
+
+/**
+ * Auto-Recording Hooks — wire ProjectChronicle into PraxisRegistry & LogicEngine
+ *
+ * Opt-in: call `enableProjectChronicle(registry, engine)` to start recording.
+ * The hooks use Proxy wrapping to intercept method calls without modifying
+ * the original classes.
+ */
+
+/** Handle returned by enableProjectChronicle for cleanup. */
+interface ChronicleHandle {
+    /** The underlying chronicle being written to. */
+    chronicle: ProjectChronicle;
+    /** Disconnect all hooks (restores original methods). */
+    disconnect: () => void;
+}
+/** Options for enabling project chronicle hooks. */
+interface EnableChronicleOptions {
+    /** Provide an existing chronicle (otherwise a new one is created). */
+    chronicle?: ProjectChronicle;
+    /** Record engine step results (fact production/retraction). Default: true. */
+    recordSteps?: boolean;
+    /** Record constraint check results. Default: true. */
+    recordConstraints?: boolean;
+}
+/**
+ * Enable project-level chronicle recording.
+ *
+ * Wraps registry's `registerRule`, `registerModule` and engine's `step`,
+ * `checkConstraints` methods to automatically record events.
+ *
+ * @returns A handle with the chronicle and a `disconnect()` to undo all hooks.
+ *
+ * @example
+ * ```ts
+ * const { chronicle, disconnect } = enableProjectChronicle(registry, engine);
+ * registry.registerRule(myRule); // auto-recorded
+ * engine.step(events);          // step results auto-recorded
+ * console.log(chronicle.size);  // number of events recorded
+ * disconnect();                 // stop recording
+ * ```
+ */
+declare function enableProjectChronicle<TContext = unknown>(registry: PraxisRegistry<TContext>, engine: LogicEngine<TContext>, options?: EnableChronicleOptions): ChronicleHandle;
+/**
+ * Record a completeness audit result into the chronicle.
+ *
+ * Standalone utility — call after `auditCompleteness()`.
+ */
+declare function recordAudit(chronicle: ProjectChronicle, report: CompletenessReport, previousScore?: number): void;
+
+/**
+ * Behavioral Diff Engine
+ *
+ * Compares registry snapshots, contract coverage, and expectation status
+ * to produce human-readable deltas and conventional commit messages.
+ *
+ * This is the foundation for "commit from state" — describing WHAT changed
+ * in behavioral terms rather than file terms.
+ */
+
+/** Snapshot of a registry's state (used for before/after comparison). */
+interface RegistrySnapshot {
+    rules: Map<string, RuleDescriptor> | Array<RuleDescriptor>;
+    constraints: Map<string, ConstraintDescriptor> | Array<ConstraintDescriptor>;
+}
+/** Diff result for registries. */
+interface RegistryDiff {
+    rulesAdded: string[];
+    rulesRemoved: string[];
+    rulesModified: string[];
+    constraintsAdded: string[];
+    constraintsRemoved: string[];
+    constraintsModified: string[];
+}
+/** Contract coverage snapshot. */
+interface ContractCoverage {
+    /** rule id → has contract */
+    coverage: Map<string, boolean> | Record<string, boolean>;
+}
+/** Diff result for contract coverage. */
+interface ContractDiff {
+    contractsAdded: string[];
+    contractsRemoved: string[];
+    coverageBefore: number;
+    coverageAfter: number;
+}
+/** Expectation satisfaction snapshot. */
+interface ExpectationSnapshot {
+    /** expectation name → satisfied */
+    expectations: Map<string, boolean> | Record<string, boolean>;
+}
+/** Diff result for expectations. */
+interface ExpectationDiff {
+    newlySatisfied: string[];
+    newlyViolated: string[];
+    unchanged: string[];
+}
+/** Full behavioral diff combining all dimensions. */
+interface FullBehavioralDiff {
+    registry: RegistryDiff;
+    contracts: ContractDiff;
+    expectations: ExpectationDiff;
+}
+/**
+ * Compare two registry snapshots.
+ *
+ * Detects rules/constraints that were added, removed, or modified
+ * (description or contract changed).
+ */
+declare function diffRegistries(before: RegistrySnapshot, after: RegistrySnapshot): RegistryDiff;
+/**
+ * Compare contract coverage between two snapshots.
+ */
+declare function diffContracts(before: ContractCoverage, after: ContractCoverage): ContractDiff;
+/**
+ * Compare expectation satisfaction between two snapshots.
+ */
+declare function diffExpectations(before: ExpectationSnapshot, after: ExpectationSnapshot): ExpectationDiff;
+/**
+ * Format a RegistryDiff as a human-readable delta string.
+ */
+declare function formatDelta(diff: RegistryDiff): string;
+/**
+ * Generate a conventional commit message from a registry diff.
+ *
+ * Uses the same logic as `commitFromState` in `project/` but works
+ * directly from a RegistryDiff.
+ */
+declare function formatCommitMessage(diff: RegistryDiff): string;
+/**
+ * Aggregate multiple diffs into release notes.
+ */
+declare function formatReleaseNotes(diffs: RegistryDiff[]): string;
+
+export { AcknowledgeContractGap, type ActivityState, type Actor, ActorManager, type AnalysisReport, Assumption, BehaviorLedger, type BehavioralDelta, type BranchRulesConfig, CHRONICLE_PATHS, type CanvasDocument, type CanvasEdge, type CanvasEdgeStyle, type CanvasEditorConfig, type CanvasNode, type CanvasNodeStyle, type Chronicle, ChronicleContext, type ChronicleEdge, type ChronicleEvent, type ChronicleHandle, type ChronicleNode, type ChronicleSpan, type ChronosMcpTools, type ChronosSearchParams, type ChronosTraceParams, type CompletenessConfig, type CompletenessReport, ComponentDefinition, type ConditionResult, type ConditionStatus, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, Contract, ContractAdded, type ContractCoverage, type ContractCoverageGap, type ContractDiff, ContractGapAcknowledged, ContractMissing, ContractUpdated, ContractValidated, type ContractVerificationResult, type Contradiction, type CrossReference, type DataRulesConfig, type DeadRule, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, type DependencyEdge, type DependencyGraph, type DerivationChain, type DerivationStep, type EdgeType, type EnableChronicleOptions, type EventDefinition, type EventStreamEntry, type ExampleVerification, Expectation, type ExpectationCondition, type ExpectationDiff, type ExpectationResult, ExpectationSet, type ExpectationSetOptions, type ExpectationSnapshot, type FactDefinition, type FactNode, type FindingType, type FormRulesConfig, ReactiveLogicEngine as FrameworkAgnosticReactiveEngine, type ReactiveEngineOptions as FrameworkAgnosticReactiveEngineOptions, type FullBehavioralDiff, type Gap, type GateConfig, type GateState, type GateStatus, type GeneratedDoc, type GeneratedPluresDBFile, type GraphEdge, type GuardianError, type GuardianResult, type GuardianWarning, type ImpactReport, type InputRulesConfig, type InvariantCheck, type LedgerDiff, type LedgerDiffEntry, type LedgerEntry, type LedgerEntryStatus, type LifecycleState, type LoaderOptions, type LoaderResult, type LogicBranch, LogicDefinition, LogicEngine, type McpToolResult, MissingArtifact, ModelDefinition, type NavigationRulesConfig, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, PluresDbChronicle, PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, type PraxisDiff, PraxisEvent, PraxisFact, PraxisModule, PraxisRegistry, PraxisSchema, PraxisSchemaRegistry, PraxisState, type PredefinedGateConfig, ProjectChronicle, type ProjectChronicleOptions, type ProjectEvent, type ProjectEventKind, type RegistryDiff, type RegistryGraph, RegistryIntrospector, type RegistrySchema, type RegistrySnapshot, type RegistryStats, RuleDescriptor, RuleFn, type RuleNode, type RuleSchema, type SanitizationType, type SemverContractConfig, type SemverReport, Severity, type ShadowedRule, type StateChangeCallback, type StateDoc, type StateDocsConfig, StateDocsGenerator, type StateField, type StateMachineDoc, type StateTransition, type StoredSchema, type Suggestion, type TauriAppConfig, type TauriBridge, type TauriCommand, type TauriEvent, type TauriFS, type TauriFileEntry, type TauriMenuItem, type TauriNotification, type TauriNotificationOptions, type TauriPlugin, type TauriPraxisAdapter, type TauriSecurityConfig, type TauriTray, type TauriUpdateConfig, type TauriUpdateInfo, type TauriWindowConfig, Timeline, type TimelineFilter, type ToastRulesConfig, type TraceDirection, type TransitionDoc, type UIContext, type UnifiedApp, type UnifiedAppConfig, type UnreachableState, UnsubscribeFn$1 as UnsubscribeFn, type UnumAdapter, type UnumAdapterConfig, type UnumChannel, type UnumIdentity, type UnumMessage, type UnumStore, ValidateContracts, type ValidateOptions, ValidationReport, ValidationResult, type VerifiableDescriptor, type VerifiableRegistry, type VerificationReport, analyzeDependencyGraph, attachAllIntegrations, attachTauriToEngine, attachToEngine, attachUnumToEngine, auditCompleteness, branchRules, canvasToMermaid, canvasToSchema, canvasToYaml, commitFromState, createBehaviorLedger, createCanvasEditor, createChronicle, createChronosMcpTools, createReactiveEngine as createFrameworkAgnosticReactiveEngine, createIntrospector, createMockTauriBridge, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createProjectChronicle, createSchemaRegistry, createStateDocsGenerator, createTauriPraxisAdapter, createTimeline, createTimerActor, createUIModule, createUnifiedApp, createUnumAdapter, crossReferenceContracts, dataRules, defineConstraint, defineEvent, defineFact, defineGate, defineModule, defineRule, diffContracts, diffExpectations, diffLedgers, diffRegistries, dirtyGuardRule, enableProjectChronicle, errorDisplayRule, expectBehavior, expectationGate, filterEvents, filterFacts, findContractGaps, findContradictions, findDeadRules, findEvent, findFact, findGaps, findShadowedRules, findUnreachableStates, formRules, formatCommitMessage as formatBehavioralCommit, formatBuildOutput, formatDelta, formatGate, formatLedger, formatReleaseNotes, formatReport, formatValidationReport, formatValidationReportJSON, formatValidationReportSARIF, formatVerificationReport, generateDocs, generateId, generateLedger, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, initGateRule, inputRules, lintGate, loadSchema, loadSchemaFromFile, loadSchemaFromJson, loadSchemaFromYaml, loadingGateRule, mustBeInitializedConstraint, navigationRequest, navigationRules, noInteractionWhileLoadingConstraint, offlineIndicatorRule, recordAudit, registerSchema, resizeEvent, schemaToCanvas, semverContract, suggest, suggestAll, toastRules, traceDerivation, traceImpact, uiModule, uiStateChanged, validateContracts, validateForGeneration, validateWithGuardian, verify, verifyContractExamples, verifyInvariants, viewportRule };