@plures/praxis 1.3.0 → 1.4.0

package/dist/node/index.d.ts

@@ -3619,4 +3619,502 @@ declare function auditCompleteness(manifest: {
  */
 declare function formatReport(report: CompletenessReport): string;
 
-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, type CompletenessConfig, type CompletenessReport, 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, type LogicBranch, 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 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 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, attachAllIntegrations, attachTauriToEngine, attachToEngine, attachUnumToEngine, auditCompleteness, canvasToMermaid, canvasToSchema, canvasToYaml, createBehaviorLedger, createCanvasEditor, createChronicle, createChronosMcpTools, createReactiveEngine as createFrameworkAgnosticReactiveEngine, createIntrospector, createMockTauriBridge, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createSchemaRegistry, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUIModule, createUnifiedApp, createUnumAdapter, defineConstraint, defineEvent, defineFact, defineModule, defineRule, dirtyGuardRule, errorDisplayRule, filterEvents, filterFacts, findEvent, findFact, formatReport, formatValidationReport, formatValidationReportJSON, formatValidationReportSARIF, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, initGateRule, loadSchema, loadSchemaFromFile, loadSchemaFromJson, loadSchemaFromYaml, loadingGateRule, mustBeInitializedConstraint, navigationRequest, noInteractionWhileLoadingConstraint, offlineIndicatorRule, registerSchema, resizeEvent, schemaToCanvas, uiModule, uiStateChanged, validateContracts, validateForGeneration, validateWithGuardian, viewportRule };
+/**
+ * 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 };