@plures/praxis 1.2.41 → 1.4.0

package/dist/node/index.d.ts

@@ -1,7 +1,7 @@
-import { P as PraxisState, a as PraxisEvent, b as PraxisFact } from './protocol-BocKczNv.js';
-export { f as PRAXIS_PROTOCOL_VERSION, e as PraxisDiagnostics, d as PraxisStepConfig, g as PraxisStepFn, c as PraxisStepResult } from './protocol-BocKczNv.js';
-import { L as LogicEngine, P as PraxisRegistry, b as RuleDescriptor, C as ConstraintDescriptor, d as ConstraintFn, e as Contract, f as RuleFn, g as PraxisModule, M as MissingArtifact, S as Severity, V as ValidationReport, A as Assumption } from './reactive-engine.svelte-D-xTDxT5.js';
-export { h as ConstraintId, i as ContractGap, D as DefineContractOptions, E as Example, j as PraxisEngineOptions, R as ReactiveEngineOptions, a as ReactiveLogicEngine, k as Reference, l as RuleId, m as createPraxisEngine, c as createReactiveEngine, n as defineContract, o as getContract, p as isContract } from './reactive-engine.svelte-D-xTDxT5.js';
+import { P as PraxisState, a as PraxisEvent, b as PraxisFact } from './protocol-DcyGMmWY.js';
+export { f as PRAXIS_PROTOCOL_VERSION, e as PraxisDiagnostics, d as PraxisStepConfig, g as PraxisStepFn, c as PraxisStepResult } from './protocol-DcyGMmWY.js';
+import { L as LogicEngine, P as PraxisRegistry, b as RuleDescriptor, C as ConstraintDescriptor, d as ConstraintFn, e as Contract, f as RuleFn, g as PraxisModule, M as MissingArtifact, S as Severity, V as ValidationReport, A as Assumption } from './reactive-engine.svelte-DekxqFu0.js';
+export { h as ConstraintId, i as ContractGap, D as DefineContractOptions, E as Example, j as PraxisEngineOptions, R as ReactiveEngineOptions, a as ReactiveLogicEngine, k as Reference, l as RuleId, m as RuleResult, T as TypedRuleFn, n as createPraxisEngine, c as createReactiveEngine, o as defineContract, p as fact, q as getContract, r as isContract } from './reactive-engine.svelte-DekxqFu0.js';
 import { P as PraxisDB, U as UnsubscribeFn$1 } from './terminal-adapter-CvIvgTo4.js';
 export { C as CommandExecutor, I as InMemoryPraxisDB, a as PluresDBAdapterConfig, b as PluresDBInstance, d as PluresDBPraxisAdapter, e as PraxisLocalFirstOptions, T as TerminalAdapter, f as TerminalAdapterOptions, g as TerminalExecutionResult, h as TerminalNodeState, i as createInMemoryDB, j as createMockExecutor, k as createPluresDB, l as createPraxisLocalFirst, c as createTerminalAdapter, r as runTerminalCommand } from './terminal-adapter-CvIvgTo4.js';
 import { PraxisSchema, ValidationResult, ModelDefinition, FieldDefinition, ComponentDefinition, LogicDefinition } from './schema.js';
@@ -3353,4 +3353,768 @@ declare function attachAllIntegrations<TContext = unknown>(engine: LogicEngine<T
     dispose: () => void;
 }>;
 
-export { AcknowledgeContractGap, type ActivityState, type Actor, ActorManager, Assumption, BehaviorLedger, 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, ComponentDefinition, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, Contract, ContractAdded, ContractGapAcknowledged, ContractMissing, ContractUpdated, ContractValidated, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, type EdgeType, type EventDefinition, type EventStreamEntry, type FactDefinition, ReactiveLogicEngine as FrameworkAgnosticReactiveEngine, type ReactiveEngineOptions as FrameworkAgnosticReactiveEngineOptions, type GeneratedDoc, type GeneratedPluresDBFile, type GraphEdge, type GuardianError, type GuardianResult, type GuardianWarning, type LedgerEntry, type LedgerEntryStatus, type LifecycleState, type LoaderOptions, type LoaderResult, LogicDefinition, LogicEngine, type McpToolResult, MissingArtifact, ModelDefinition, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, PluresDbChronicle, PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, PraxisEvent, PraxisFact, PraxisModule, PraxisRegistry, PraxisSchema, PraxisSchemaRegistry, PraxisState, type RegistryGraph, RegistryIntrospector, type RegistrySchema, type RegistryStats, RuleDescriptor, RuleFn, type RuleNode, type RuleSchema, Severity, type StateChangeCallback, type StateDoc, type StateDocsConfig, StateDocsGenerator, type StateMachineDoc, 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 TraceDirection, type TransitionDoc, 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, attachAllIntegrations, attachTauriToEngine, attachToEngine, attachUnumToEngine, canvasToMermaid, canvasToSchema, canvasToYaml, createBehaviorLedger, createCanvasEditor, createChronicle, createChronosMcpTools, createReactiveEngine as createFrameworkAgnosticReactiveEngine, createIntrospector, createMockTauriBridge, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createSchemaRegistry, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUnifiedApp, createUnumAdapter, defineConstraint, defineEvent, defineFact, defineModule, defineRule, filterEvents, filterFacts, findEvent, findFact, formatValidationReport, formatValidationReportJSON, formatValidationReportSARIF, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, loadSchema, loadSchemaFromFile, loadSchemaFromJson, loadSchemaFromYaml, registerSchema, schemaToCanvas, validateContracts, validateForGeneration, validateWithGuardian };
+/**
+ * Praxis UI Rules
+ *
+ * Lightweight, predefined UI-specific rules and constraints.
+ * These govern UI behavior without muddying business logic rules.
+ *
+ * UI rules are separated from domain rules by convention:
+ * - Domain rules: business decisions, data invariants, workflow logic
+ * - UI rules: visibility, loading states, error display, navigation guards
+ *
+ * Ship predefined rules that apps can opt into. Every `if` in the UI
+ * can be governed by Praxis — business rules stay clean, UI rules stay separate.
+ */
+
+/**
+ * Standard UI state fields that UI rules can read from context.
+ * Apps extend their context with these fields to enable UI rules.
+ */
+interface UIContext {
+    /** Whether the app is currently loading data */
+    loading?: boolean;
+    /** Current error message, if any */
+    error?: string | null;
+    /** Whether the app is in offline mode */
+    offline?: boolean;
+    /** Whether there are unsaved changes */
+    dirty?: boolean;
+    /** Current route/view name */
+    route?: string;
+    /** Whether the app has completed initialization */
+    initialized?: boolean;
+    /** Screen width category: 'mobile' | 'tablet' | 'desktop' */
+    viewport?: 'mobile' | 'tablet' | 'desktop';
+    /** Whether a modal/dialog is currently open */
+    modalOpen?: boolean;
+    /** Active panel/tab name */
+    activePanel?: string | null;
+}
+/**
+ * Loading gate: emits ui.loading-gate when data is loading.
+ * UI components can subscribe to this fact to show loading indicators.
+ */
+declare const loadingGateRule: RuleDescriptor<UIContext>;
+/**
+ * Error display: emits ui.error-display with the error message.
+ * Retracts when error clears.
+ */
+declare const errorDisplayRule: RuleDescriptor<UIContext>;
+/**
+ * Offline indicator: emits ui.offline-indicator when the app detects offline state.
+ */
+declare const offlineIndicatorRule: RuleDescriptor<UIContext>;
+/**
+ * Dirty guard: emits ui.unsaved-warning when there are unsaved changes.
+ * Can be used to block navigation or show save prompts.
+ */
+declare const dirtyGuardRule: RuleDescriptor<UIContext>;
+/**
+ * Init gate: blocks UI interactions until app is initialized.
+ */
+declare const initGateRule: RuleDescriptor<UIContext>;
+/**
+ * Viewport-responsive: emits ui.viewport-class based on screen size.
+ */
+declare const viewportRule: RuleDescriptor<UIContext>;
+/**
+ * No interaction while loading: constraint that fails if actions are taken during loading.
+ */
+declare const noInteractionWhileLoadingConstraint: ConstraintDescriptor<UIContext>;
+/**
+ * Must be initialized: constraint that fails if app hasn't completed init.
+ */
+declare const mustBeInitializedConstraint: ConstraintDescriptor<UIContext>;
+/**
+ * The complete UI rules module.
+ * Register this to get all predefined UI rules and constraints.
+ *
+ * @example
+ * import { uiModule } from '@plures/praxis';
+ * registry.registerModule(uiModule);
+ */
+declare const uiModule: PraxisModule<UIContext>;
+/**
+ * Create a customized UI module with only the rules you need.
+ *
+ * @example
+ * const myUI = createUIModule({
+ *   rules: ['ui/loading-gate', 'ui/dirty-guard'],
+ *   constraints: ['ui/must-be-initialized'],
+ * });
+ * registry.registerModule(myUI);
+ */
+declare function createUIModule<TContext extends UIContext>(options: {
+    rules?: string[];
+    constraints?: string[];
+    extraRules?: RuleDescriptor<TContext>[];
+    extraConstraints?: ConstraintDescriptor<TContext>[];
+}): PraxisModule<TContext>;
+/**
+ * Create a UI state change event. Fire this when UIContext fields change.
+ */
+declare function uiStateChanged(changes?: Record<string, unknown>): PraxisEvent;
+/**
+ * Create a navigation request event. Used with dirty guard.
+ */
+declare function navigationRequest(to: string): PraxisEvent;
+/**
+ * Create a resize event. Used with viewport rule.
+ */
+declare function resizeEvent(width: number, height: number): PraxisEvent;
+
+/**
+ * @plures/praxis — Completeness Analysis
+ *
+ * This module provides tools to measure and enforce "Praxis Completeness" —
+ * the degree to which an application's logic is expressed through Praxis
+ * rules, constraints, and contracts rather than scattered conditionals.
+ *
+ * ## Definition: Praxis Logic Completeness
+ *
+ * An application is "Praxis Complete" when:
+ *
+ * 1. **DOMAIN RULES (100%)** — Every business decision that produces user-visible
+ *    behavior change is expressed as a Praxis rule. "If the sprint is behind pace,
+ *    show a warning" is domain logic. It belongs in Praxis.
+ *
+ * 2. **INVARIANTS (100%)** — Every data validity assertion is a Praxis constraint.
+ *    "Sprint hours must not exceed 80" is an invariant. It belongs in Praxis.
+ *
+ * 3. **CONTRACTS (>80%)** — Rules that encode non-obvious behavior have contracts
+ *    (behavior description + examples + invariants). Contracts are documentation
+ *    AND test vectors — they prove the tool isn't the bug.
+ *
+ * 4. **CONTEXT COVERAGE (100%)** — Every piece of application state that rules
+ *    reason about is in the Praxis context. If a rule needs to know about
+ *    connection status, connection status must be in the context.
+ *
+ * 5. **EVENT COVERAGE (100%)** — Every state transition that should trigger rule
+ *    evaluation fires a Praxis event. If notes can be saved, there's a note.save
+ *    event. If sprint refreshes, there's a sprint.refresh event.
+ *
+ * ## What Is NOT Praxis Logic
+ *
+ * - **UI mechanics**: Panel toggle, scroll position, animation state, focus management
+ * - **Data transport**: fetch() calls, WebSocket plumbing, file I/O
+ * - **Framework wiring**: Svelte subscriptions, onMount, store creation
+ * - **Data transformation**: Parsing, formatting, serialization
+ * - **Routing/navigation**: URL handling, panel switching (unless it has business rules)
+ *
+ * The line: "Does this `if` statement encode a business decision or an app invariant?"
+ * If yes → Praxis rule/constraint. If no → leave it.
+ *
+ * ## 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';
+ *
+ * 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;
+
+/**
+ * Praxis Rules Factory — Types
+ *
+ * Configuration types for predefined rule module factories.
+ */
+type SanitizationType = 'sql-injection' | 'xss' | 'path-traversal' | 'command-injection';
+interface InputRulesConfig {
+    /** Sanitization checks to apply */
+    sanitize?: SanitizationType[];
+    /** Maximum input length (0 = unlimited) */
+    maxLength?: number;
+    /** Whether the input is required (non-empty) */
+    required?: boolean;
+    /** Custom field name for facts/events (default: 'input') */
+    fieldName?: string;
+}
+interface ToastRulesConfig {
+    /** Only show toast if there's a meaningful diff */
+    requireDiff?: boolean;
+    /** Auto-dismiss after N milliseconds (0 = no auto-dismiss) */
+    autoDismissMs?: number;
+    /** Prevent duplicate toasts with same message */
+    deduplicate?: boolean;
+}
+interface FormRulesConfig {
+    /** Validate fields on blur */
+    validateOnBlur?: boolean;
+    /** Gate form submission on validation passing */
+    submitGate?: boolean;
+    /** Custom form name for namespacing facts */
+    formName?: string;
+}
+interface NavigationRulesConfig {
+    /** Warn/block navigation when form has unsaved changes */
+    dirtyGuard?: boolean;
+    /** Require authentication for navigation */
+    authRequired?: boolean;
+}
+interface DataRulesConfig {
+    /** Enable optimistic UI updates */
+    optimisticUpdate?: boolean;
+    /** Rollback optimistic updates on error */
+    rollbackOnError?: boolean;
+    /** Invalidate relevant caches on data change */
+    cacheInvalidation?: boolean;
+    /** Custom entity name for facts */
+    entityName?: string;
+}
+
+/**
+ * Praxis Rules Factory
+ *
+ * Predefined rule modules for common application patterns.
+ * Each factory returns a PraxisModule with rules, constraints, and contracts.
+ *
+ * @example
+ * ```ts
+ * import { inputRules, toastRules, formRules } from '@plures/praxis/factory';
+ *
+ * const registry = new PraxisRegistry();
+ * registry.registerModule(inputRules({ sanitize: ['xss', 'sql-injection'], required: true }));
+ * registry.registerModule(toastRules({ requireDiff: true, deduplicate: true }));
+ * registry.registerModule(formRules({ validateOnBlur: true, submitGate: true }));
+ * ```
+ */
+
+/** Context type for input rules. */
+interface InputContext {
+    input?: {
+        value?: string;
+        field?: string;
+    };
+}
+/**
+ * Create input validation rules module.
+ *
+ * Generates rules for sanitizing user input, enforcing length limits,
+ * and requiring non-empty values.
+ */
+declare function inputRules(config?: InputRulesConfig): PraxisModule<InputContext>;
+/** Context type for toast rules. */
+interface ToastContext {
+    diff?: Record<string, unknown> | null;
+    toasts?: Array<{
+        message: string;
+        id: string;
+    }>;
+}
+/**
+ * Create truthful toast notification rules.
+ *
+ * Generates rules that ensure toasts only appear with meaningful content,
+ * auto-dismiss after a timeout, and avoid duplicates.
+ */
+declare function toastRules(config?: ToastRulesConfig): PraxisModule<ToastContext>;
+/** Context type for form rules. */
+interface FormContext {
+    form?: {
+        fields?: Record<string, {
+            value: unknown;
+            error?: string;
+            touched?: boolean;
+        }>;
+        valid?: boolean;
+        dirty?: boolean;
+        submitting?: boolean;
+    };
+}
+/**
+ * Create form lifecycle rules.
+ *
+ * Generates rules for field validation on blur, submit gating,
+ * and form state management.
+ */
+declare function formRules(config?: FormRulesConfig): PraxisModule<FormContext>;
+/** Context type for navigation rules. */
+interface NavigationContext {
+    dirty?: boolean;
+    authenticated?: boolean;
+    route?: string;
+}
+/**
+ * Create route protection rules.
+ *
+ * Generates rules for dirty-data navigation guards and
+ * authentication-required route protection.
+ */
+declare function navigationRules(config?: NavigationRulesConfig): PraxisModule<NavigationContext>;
+/** Context type for data rules. */
+interface DataContext {
+    pending?: Record<string, {
+        original: unknown;
+        optimistic: unknown;
+    }>;
+    cache?: Record<string, {
+        data: unknown;
+        timestamp: number;
+    }>;
+}
+/**
+ * Create data lifecycle rules.
+ *
+ * Generates rules for optimistic updates, error rollback, and cache invalidation.
+ */
+declare function dataRules(config?: DataRulesConfig): PraxisModule<DataContext>;
+
+/**
+ * Praxis Project Logic — Types
+ *
+ * Types for developer workflow rules: gates, semver contracts,
+ * commit generation, and branch management.
+ */
+type GateStatus = 'open' | 'closed' | 'blocked';
+interface GateConfig {
+    /** Expectations that must be satisfied for the gate to open */
+    expects: string[];
+    /** Action when gate is satisfied */
+    onSatisfied?: string;
+    /** Action when gate is violated */
+    onViolation?: string;
+}
+interface GateState {
+    name: string;
+    status: GateStatus;
+    /** Which expectations are satisfied */
+    satisfied: string[];
+    /** Which expectations are not satisfied */
+    unsatisfied: string[];
+    /** Timestamp of last status change */
+    lastChanged: number;
+}
+interface SemverContractConfig {
+    /** Files/sources that contain version strings */
+    sources: string[];
+    /** Invariants about version consistency */
+    invariants: string[];
+}
+interface SemverReport {
+    /** Whether all sources have consistent versions */
+    consistent: boolean;
+    /** Version found in each source */
+    versions: Record<string, string>;
+    /** Invariant violations */
+    violations: string[];
+}
+interface PraxisDiff {
+    /** Rules added since last commit */
+    rulesAdded: string[];
+    /** Rules removed */
+    rulesRemoved: string[];
+    /** Rules modified */
+    rulesModified: string[];
+    /** Contracts added */
+    contractsAdded: string[];
+    /** Contracts removed */
+    contractsRemoved: string[];
+    /** Expectations added */
+    expectationsAdded: string[];
+    /** Expectations removed */
+    expectationsRemoved: string[];
+    /** Gate state changes */
+    gateChanges: Array<{
+        gate: string;
+        from: GateStatus;
+        to: GateStatus;
+    }>;
+}
+interface BranchRulesConfig {
+    /** Naming convention pattern (e.g., 'feat/{name}', 'fix/{issue}') */
+    naming: string;
+    /** Conditions required for merge */
+    mergeConditions: string[];
+}
+interface PredefinedGateConfig {
+    /** Whether to enable this gate */
+    enabled?: boolean;
+    /** Custom expectations to add */
+    additionalExpects?: string[];
+}
+
+/**
+ * Praxis Project Logic
+ *
+ * Developer workflow rules: gates, semver contracts, commit message
+ * generation from behavioral deltas, and branch management.
+ *
+ * @example
+ * ```ts
+ * import { defineGate, semverContract, commitFromState } from '@plures/praxis/project';
+ *
+ * const testGate = defineGate('test', {
+ *   expects: ['all-tests-pass', 'no-type-errors'],
+ *   onSatisfied: 'merge-allowed',
+ *   onViolation: 'merge-blocked',
+ * });
+ *
+ * const diff = { rulesAdded: ['auth/login'], ... };
+ * const message = commitFromState(diff);
+ * // → "feat(rules): add auth/login rule"
+ * ```
+ */
+
+/**
+ * Context type for gates. Apps extend their context with gate state.
+ */
+interface GateContext {
+    gates?: Record<string, GateState>;
+    expectations?: Record<string, boolean>;
+}
+/**
+ * Define a feature gate — a condition that must be satisfied before
+ * proceeding with a workflow step (deploy, merge, release, etc.).
+ *
+ * @example
+ * ```ts
+ * const testGate = defineGate('test', {
+ *   expects: ['all-tests-pass', 'no-type-errors'],
+ *   onSatisfied: 'deploy-allowed',
+ *   onViolation: 'deploy-blocked',
+ * });
+ * registry.registerModule(testGate);
+ * ```
+ */
+declare function defineGate(name: string, config: GateConfig): PraxisModule<GateContext>;
+/**
+ * Create a semver contract module that checks version consistency
+ * across multiple sources (package.json, Cargo.toml, etc.).
+ *
+ * @example
+ * ```ts
+ * const version = semverContract({
+ *   sources: ['package.json', 'src/version.ts', 'README.md'],
+ *   invariants: ['All sources must have the same version'],
+ * });
+ * ```
+ */
+declare function semverContract(config: SemverContractConfig): PraxisModule;
+/**
+ * Generate a conventional commit message from a behavioral delta.
+ *
+ * Unlike file-based commit messages, this describes WHAT behavioral
+ * changes occurred — rule additions, contract changes, expectation shifts.
+ *
+ * @example
+ * ```ts
+ * const msg = commitFromState({
+ *   rulesAdded: ['auth/login', 'auth/logout'],
+ *   contractsAdded: ['auth/login'],
+ *   ...empty
+ * });
+ * // → "feat(rules): add auth/login, auth/logout\n\nContracts added: auth/login"
+ * ```
+ */
+declare function commitFromState(diff: PraxisDiff): string;
+/**
+ * Create branch management rules.
+ *
+ * @example
+ * ```ts
+ * const branches = branchRules({
+ *   naming: 'feat/{name}',
+ *   mergeConditions: ['tests-pass', 'review-approved'],
+ * });
+ * ```
+ */
+declare function branchRules(config: BranchRulesConfig): PraxisModule;
+/**
+ * Create a lint gate — blocks workflow until linting passes.
+ */
+declare function lintGate(config?: PredefinedGateConfig): PraxisModule<GateContext>;
+/**
+ * Create a format gate — blocks workflow until formatting is correct.
+ */
+declare function formatGate(config?: PredefinedGateConfig): PraxisModule<GateContext>;
+/**
+ * Create an expectation gate — blocks workflow until expectations are verified.
+ */
+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 };