@plures/praxis 1.1.2 → 1.1.3

package/README.md

@@ -1,6 +1,6 @@
 dotnet build
 dotnet test
-# Praxis 1.1.2
+# Praxis
 
 **Typed, visual-first application logic for Svelte, Node, and the browser.**
 
@@ -10,19 +10,20 @@ dotnet test
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org/)
 [![Deno Compatible](https://img.shields.io/badge/deno-compatible-brightgreen)](https://deno.land/)
 
-Praxis is a schema-driven, rule-based engine with first-class Svelte 5 integration, component generation, and optional cloud sync. Version **1.1.2** delivers a unified ESM/CJS build, curated subpath exports, Svelte runes support, and a slimmer, publish-ready package for npm and JSR.
+Praxis is a schema-driven, rule-based engine with first-class Svelte 5 integration, component generation, and optional cloud sync. The library delivers a unified ESM/CJS build, curated subpath exports, Svelte runes support, and a slimmer, publish-ready package for npm and JSR.
 
 ---
 
-## What’s new in 1.1.2
+## What’s new
 - **Unified builds & exports**: `./`, `./svelte`, `./schema`, `./component`, `./cloud`, `./components`, and CLI all ship with ESM, CJS, and type definitions.
 - **Svelte 5 runes native**: Runes-friendly stores and helpers; server+client builds for integrations.
+- **Framework-agnostic reactivity**: Proxy-based reactive engine for use without Svelte, enabling reactive state management in Node.js, browsers, and any JavaScript environment.
 - **Logic engine refinements**: Typed registry, step diagnostics, and trace-friendly rule execution.
 - **Cloud relay & local-first**: Polished cloud connector alongside PluresDB-first workflows.
 - **Publish-ready**: npm public access + JSR exports aligned to source.
 
 ## Capabilities at a glance
-- **Logic Engine**: Facts, events, rules, constraints, registry, introspection, and reactive engine variant.
+- **Logic Engine**: Facts, events, rules, constraints, registry, introspection, and reactive engine variants (Svelte 5 + framework-agnostic).
 - **Schema & Codegen**: PSF-style schema types plus component generator for Svelte UIs.
 - **Svelte Integration**: Typed helpers, runes-ready builds, and Svelte component typings.
 - **Local-First Data**: PluresDB integrations for offline-first, reactive state.
@@ -100,16 +101,47 @@ engine.step([Login.create({ username: 'alex' })]);
   registry.registerRule(counterRule);
 
   const engine = createReactiveEngine({ initialContext: { count: 0 }, registry });
-  const count = engine.$derived((s) => s.context.count);
+  
+  // Use Svelte's $derived with the reactive engine state
+  const count = $derived(engine.context.count);
 
   function addOne() {
     engine.step([Increment.create({ amount: 1 })]);
   }
 </script>
 
-<button on:click={addOne}>Count is {$count}</button>
+<button on:click={addOne}>Count is {count}</button>
 ```
 
+## Framework-agnostic reactive engine
+For non-Svelte environments, use the framework-agnostic reactive engine with Proxy-based reactivity:
+
+```typescript
+import { createFrameworkAgnosticReactiveEngine } from '@plures/praxis';
+
+const engine = createFrameworkAgnosticReactiveEngine({
+  initialContext: { count: 0 },
+});
+
+// Subscribe to state changes
+engine.subscribe((state) => {
+  console.log('Count:', state.context.count);
+});
+
+// Create derived/computed values
+const doubled = engine.$derived((state) => state.context.count * 2);
+doubled.subscribe((value) => {
+  console.log('Doubled:', value);
+});
+
+// Apply mutations (batched for performance)
+engine.apply((state) => {
+  state.context.count += 1;
+});
+```
+
+See the [reactive counter example](./examples/reactive-counter/README.md) for a complete demonstration.
+
 ## Cloud relay (optional)
 ```ts
 import { connectRelay } from '@plures/praxis/cloud';
@@ -129,6 +161,35 @@ await relay.sync({
 });
 ```
 
+## PluresDB integration
+```ts
+import { PluresNode } from 'pluresdb';
+import { createPluresDB, createPraxisDBStore } from '@plures/praxis';
+import { PraxisRegistry } from '@plures/praxis';
+
+// Initialize the official PluresDB from npm
+const pluresdb = new PluresNode({
+  config: {
+    port: 34567,
+    dataDir: './data',
+  },
+  autoStart: true,
+});
+
+// Wrap it with the Praxis adapter
+const db = createPluresDB(pluresdb);
+
+// Use with Praxis store for local-first reactive data
+const registry = new PraxisRegistry();
+const store = createPraxisDBStore(db, registry);
+
+// Or use in-memory database for development/testing
+import { createInMemoryDB } from '@plures/praxis';
+const devDb = createInMemoryDB();
+```
+
+> **Note:** Praxis now uses the official [PluresDB package from NPM](https://www.npmjs.com/package/pluresdb), which provides P2P sync, CRDT conflict resolution, SQLite compatibility, and more. The `createPluresDB()` function wraps PluresDB to provide the `PraxisDB` interface used by Praxis.
+
 ## CLI (npx-friendly)
 ```bash
 npx praxis --help

package/dist/browser/chunk-R45WXWKH.js

@@ -0,0 +1,345 @@
+// src/core/protocol.ts
+var PRAXIS_PROTOCOL_VERSION = "1.0.0";
+
+// src/core/rules.ts
+var PraxisRegistry = class {
+  rules = /* @__PURE__ */ new Map();
+  constraints = /* @__PURE__ */ new Map();
+  /**
+   * Register a rule
+   */
+  registerRule(descriptor) {
+    if (this.rules.has(descriptor.id)) {
+      throw new Error(`Rule with id "${descriptor.id}" already registered`);
+    }
+    this.rules.set(descriptor.id, descriptor);
+  }
+  /**
+   * Register a constraint
+   */
+  registerConstraint(descriptor) {
+    if (this.constraints.has(descriptor.id)) {
+      throw new Error(`Constraint with id "${descriptor.id}" already registered`);
+    }
+    this.constraints.set(descriptor.id, descriptor);
+  }
+  /**
+   * Register a module (all its rules and constraints)
+   */
+  registerModule(module) {
+    for (const rule of module.rules) {
+      this.registerRule(rule);
+    }
+    for (const constraint of module.constraints) {
+      this.registerConstraint(constraint);
+    }
+  }
+  /**
+   * Get a rule by ID
+   */
+  getRule(id) {
+    return this.rules.get(id);
+  }
+  /**
+   * Get a constraint by ID
+   */
+  getConstraint(id) {
+    return this.constraints.get(id);
+  }
+  /**
+   * Get all registered rule IDs
+   */
+  getRuleIds() {
+    return Array.from(this.rules.keys());
+  }
+  /**
+   * Get all registered constraint IDs
+   */
+  getConstraintIds() {
+    return Array.from(this.constraints.keys());
+  }
+  /**
+   * Get all rules
+   */
+  getAllRules() {
+    return Array.from(this.rules.values());
+  }
+  /**
+   * Get all constraints
+   */
+  getAllConstraints() {
+    return Array.from(this.constraints.values());
+  }
+};
+
+// src/core/engine.ts
+function safeClone(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (typeof globalThis.structuredClone === "function") {
+    try {
+      return globalThis.structuredClone(value);
+    } catch {
+    }
+  }
+  if (Array.isArray(value)) {
+    return [...value];
+  }
+  return { ...value };
+}
+var LogicEngine = class {
+  state;
+  registry;
+  constructor(options) {
+    this.registry = options.registry;
+    this.state = {
+      context: options.initialContext,
+      facts: options.initialFacts ?? [],
+      meta: options.initialMeta ?? {},
+      protocolVersion: PRAXIS_PROTOCOL_VERSION
+    };
+  }
+  /**
+   * Get the current state (immutable copy)
+   */
+  getState() {
+    return {
+      context: safeClone(this.state.context),
+      facts: [...this.state.facts],
+      meta: this.state.meta ? safeClone(this.state.meta) : void 0,
+      protocolVersion: this.state.protocolVersion
+    };
+  }
+  /**
+   * Get the current context
+   */
+  getContext() {
+    return safeClone(this.state.context);
+  }
+  /**
+   * Get current facts
+   */
+  getFacts() {
+    return [...this.state.facts];
+  }
+  /**
+   * Process events through the engine.
+   * Applies all registered rules and checks all registered constraints.
+   *
+   * @param events Events to process
+   * @returns Result with new state and diagnostics
+   */
+  step(events) {
+    const config = {
+      ruleIds: this.registry.getRuleIds(),
+      constraintIds: this.registry.getConstraintIds()
+    };
+    return this.stepWithConfig(events, config);
+  }
+  /**
+   * Process events with specific rule and constraint configuration.
+   *
+   * @param events Events to process
+   * @param config Step configuration
+   * @returns Result with new state and diagnostics
+   */
+  stepWithConfig(events, config) {
+    const diagnostics = [];
+    let newState = { ...this.state };
+    const newFacts = [];
+    for (const ruleId of config.ruleIds) {
+      const rule = this.registry.getRule(ruleId);
+      if (!rule) {
+        diagnostics.push({
+          kind: "rule-error",
+          message: `Rule "${ruleId}" not found in registry`,
+          data: { ruleId }
+        });
+        continue;
+      }
+      try {
+        const ruleFacts = rule.impl(newState, events);
+        newFacts.push(...ruleFacts);
+      } catch (error) {
+        diagnostics.push({
+          kind: "rule-error",
+          message: `Error executing rule "${ruleId}": ${error instanceof Error ? error.message : String(error)}`,
+          data: { ruleId, error }
+        });
+      }
+    }
+    newState = {
+      ...newState,
+      facts: [...newState.facts, ...newFacts]
+    };
+    for (const constraintId of config.constraintIds) {
+      const constraint = this.registry.getConstraint(constraintId);
+      if (!constraint) {
+        diagnostics.push({
+          kind: "constraint-violation",
+          message: `Constraint "${constraintId}" not found in registry`,
+          data: { constraintId }
+        });
+        continue;
+      }
+      try {
+        const result = constraint.impl(newState);
+        if (result === false) {
+          diagnostics.push({
+            kind: "constraint-violation",
+            message: `Constraint "${constraintId}" violated`,
+            data: { constraintId, description: constraint.description }
+          });
+        } else if (typeof result === "string") {
+          diagnostics.push({
+            kind: "constraint-violation",
+            message: result,
+            data: { constraintId, description: constraint.description }
+          });
+        }
+      } catch (error) {
+        diagnostics.push({
+          kind: "constraint-violation",
+          message: `Error checking constraint "${constraintId}": ${error instanceof Error ? error.message : String(error)}`,
+          data: { constraintId, error }
+        });
+      }
+    }
+    this.state = newState;
+    return {
+      state: newState,
+      diagnostics
+    };
+  }
+  /**
+   * Update the context directly (for exceptional cases).
+   * Generally, context should be updated through rules.
+   *
+   * @param updater Function that produces new context from old context
+   */
+  updateContext(updater) {
+    this.state = {
+      ...this.state,
+      context: updater(this.state.context)
+    };
+  }
+  /**
+   * Add facts directly (for exceptional cases).
+   * Generally, facts should be added through rules.
+   *
+   * @param facts Facts to add
+   */
+  addFacts(facts) {
+    this.state = {
+      ...this.state,
+      facts: [...this.state.facts, ...facts]
+    };
+  }
+  /**
+   * Clear all facts
+   */
+  clearFacts() {
+    this.state = {
+      ...this.state,
+      facts: []
+    };
+  }
+  /**
+   * Reset the engine to initial state
+   */
+  reset(options) {
+    this.state = {
+      context: options.initialContext,
+      facts: options.initialFacts ?? [],
+      meta: options.initialMeta ?? {},
+      protocolVersion: PRAXIS_PROTOCOL_VERSION
+    };
+  }
+};
+function createPraxisEngine(options) {
+  return new LogicEngine(options);
+}
+
+// src/core/reactive-engine.svelte.ts
+import * as $ from "svelte/internal/client";
+var ReactiveLogicEngine = class {
+  #state = (
+    // Use Svelte's $state rune for automatic reactivity
+    $.state($.proxy({ context: {}, facts: [], meta: {} }))
+  );
+  get state() {
+    return $.get(this.#state);
+  }
+  set state(value) {
+    $.set(this.#state, value, true);
+  }
+  _engine;
+  constructor(options) {
+    this.state.context = options.initialContext;
+    this.state.facts = options.initialFacts ?? [];
+    this.state.meta = options.initialMeta ?? {};
+    if (options.registry) {
+      this._engine = createPraxisEngine({
+        initialContext: options.initialContext,
+        registry: options.registry
+      });
+    } else {
+      this._engine = createPraxisEngine({
+        initialContext: options.initialContext,
+        registry: new PraxisRegistry()
+      });
+    }
+  }
+  /**
+   * Access the reactive context.
+   * In Svelte 5 components, changes to this object will automatically trigger updates.
+   */
+  get context() {
+    return this.state.context;
+  }
+  /**
+   * Access the reactive facts list.
+   */
+  get facts() {
+    return this.state.facts;
+  }
+  /**
+   * Access the reactive metadata.
+   */
+  get meta() {
+    return this.state.meta;
+  }
+  /**
+   * Apply a mutation to the state.
+   * Changes will automatically trigger Svelte reactivity.
+   * 
+   * @param mutator A function that receives the state and modifies it.
+   */
+  apply(mutator) {
+    mutator(this.state);
+  }
+  /**
+   * Process events through the logic engine and update reactive state.
+   * 
+   * @param events Events to process
+   */
+  step(events) {
+    const result = this._engine.step(events);
+    this.state.context = result.state.context;
+    this.state.facts = result.state.facts;
+    this.state.meta = result.state.meta ?? {};
+  }
+};
+function createReactiveEngine(options) {
+  return new ReactiveLogicEngine(options);
+}
+
+export {
+  PRAXIS_PROTOCOL_VERSION,
+  PraxisRegistry,
+  LogicEngine,
+  createPraxisEngine,
+  ReactiveLogicEngine,
+  createReactiveEngine
+};

package/dist/browser/index.d.ts

@@ -1,36 +1,85 @@
-import { L as LogicEngine, P as PraxisState, a as PraxisEvent, b as PraxisRegistry, R as RuleDescriptor, C as ConstraintDescriptor, c as PraxisFact, d as RuleFn, e as ConstraintFn, f as PraxisModule } from './engine-BjdqxeXG.js';
-export { m as ConstraintId, k as PRAXIS_PROTOCOL_VERSION, g as PraxisDiagnostics, n as PraxisEngineOptions, h as PraxisStepConfig, j as PraxisStepFn, i as PraxisStepResult, l as RuleId, o as createPraxisEngine } from './engine-BjdqxeXG.js';
+import { L as LogicEngine, P as PraxisState, a as PraxisEvent, b as PraxisRegistry, R as RuleDescriptor, C as ConstraintDescriptor, c as PraxisFact, d as RuleFn, e as ConstraintFn, f as PraxisModule } from './reactive-engine.svelte-C9OpcTHf.js';
+export { m as ConstraintId, k as PRAXIS_PROTOCOL_VERSION, g as PraxisDiagnostics, n as PraxisEngineOptions, h as PraxisStepConfig, j as PraxisStepFn, i as PraxisStepResult, p as ReactiveEngineOptions, q as ReactiveLogicEngine, l as RuleId, o as createPraxisEngine, r as createReactiveEngine } from './reactive-engine.svelte-C9OpcTHf.js';
 
 /**
  * Praxis Reactive Logic Engine
  *
- * A Svelte 5 native implementation of the Praxis Logic Engine.
- * Uses Runes ($state, $derived, $effect) for fine-grained reactivity.
+ * A framework-agnostic reactive implementation of the Praxis Logic Engine.
+ * Uses JavaScript Proxies to provide reactivity without Svelte-specific primitives.
+ *
+ * This implementation provides:
+ * - Proxy-based state tracking for automatic reactivity
+ * - Subscription-based change notifications
+ * - Computed/derived values support
+ * - Compatible API with Svelte-based implementation
  */
 interface ReactiveEngineOptions<TContext> {
     initialContext: TContext;
     initialFacts?: any[];
     initialMeta?: Record<string, unknown>;
 }
+/**
+ * Callback type for state change subscribers
+ */
+type StateChangeCallback<TContext> = (state: {
+    context: TContext;
+    facts: any[];
+    meta: Record<string, unknown>;
+}) => void;
+/**
+ * Callback type for unsubscribe function
+ */
+type UnsubscribeFn$1 = () => void;
+/**
+ * Framework-agnostic reactive logic engine using JavaScript Proxies
+ */
 declare class ReactiveLogicEngine<TContext extends object> {
-    state: {
+    private _state;
+    private _subscribers;
+    private _contextProxy;
+    private _factsProxy;
+    private _metaProxy;
+    private _batchDepth;
+    private _pendingNotification;
+    private _proxyCache;
+    private static readonly ARRAY_MUTATORS;
+    constructor(options: ReactiveEngineOptions<TContext>);
+    /**
+     * Create a reactive proxy that notifies subscribers on changes.
+     * Uses a WeakMap cache to avoid creating multiple proxies for the same object.
+     */
+    private _createReactiveProxy;
+    /**
+     * Notify all subscribers of state changes
+     */
+    private _notify;
+    /**
+     * Get the full state object
+     */
+    get state(): {
         context: TContext;
         facts: any[];
         meta: Record<string, unknown>;
     };
-    constructor(options: ReactiveEngineOptions<TContext>);
     /**
-     * Access the reactive context directly.
-     * Consumers can use this in $derived() or $effect().
+     * Access the reactive context.
+     * Changes to this object will trigger subscriber notifications.
      */
     get context(): TContext;
     /**
      * Access the reactive facts list.
+     * Changes to this array will trigger subscriber notifications.
      */
     get facts(): any[];
+    /**
+     * Access the reactive metadata.
+     * Changes to this object will trigger subscriber notifications.
+     */
+    get meta(): Record<string, unknown>;
     /**
      * Apply a mutation to the state.
      * This is the "Action" or "Rule" equivalent.
+     * Mutations are batched - notifications only happen once per apply call.
      *
      * @param mutator A function that receives the state and modifies it.
      */
@@ -40,10 +89,54 @@ declare class ReactiveLogicEngine<TContext extends object> {
         meta: Record<string, unknown>;
     }) => void): void;
     /**
-     * Access the reactive meta.
+     * Subscribe to state changes.
+     * Returns an unsubscribe function.
+     *
+     * @param callback Function to call when state changes
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: StateChangeCallback<TContext>): UnsubscribeFn$1;
+    /**
+     * Create a derived/computed value from the state.
+     * The selector function will be called whenever the state changes.
+     *
+     * @param selector Function to extract derived value from state
+     * @returns Object with subscribe method for reactive updates
      */
-    get meta(): Record<string, unknown>;
+    $derived<TDerived>(selector: (state: {
+        context: TContext;
+        facts: any[];
+        meta: Record<string, unknown>;
+    }) => TDerived): {
+        subscribe: (callback: (value: TDerived) => void) => UnsubscribeFn$1;
+    };
 }
+/**
+ * Create a new reactive logic engine instance.
+ *
+ * @param options Configuration options for the reactive engine
+ * @returns A new ReactiveLogicEngine instance
+ *
+ * @example
+ * ```typescript
+ * const engine = createReactiveEngine({
+ *   initialContext: { count: 0 },
+ *   initialFacts: [],
+ *   initialMeta: {}
+ * });
+ *
+ * // Subscribe to changes
+ * engine.subscribe((state) => {
+ *   console.log('State changed:', state);
+ * });
+ *
+ * // Mutate state (will trigger subscribers)
+ * engine.apply((state) => {
+ *   state.context.count++;
+ * });
+ * ```
+ */
+declare function createReactiveEngine<TContext extends object>(options: ReactiveEngineOptions<TContext>): ReactiveLogicEngine<TContext>;
 
 /**
  * Actors System
@@ -915,6 +1008,73 @@ declare class InMemoryPraxisDB implements PraxisDB {
  * ```
  */
 declare function createInMemoryDB(): InMemoryPraxisDB;
+/**
+ * PluresDB instance type - represents either PluresNode or SQLiteCompatibleAPI
+ */
+type PluresDBInstance = {
+    get(key: string): Promise<any>;
+    put(key: string, value: any): Promise<void>;
+};
+/**
+ * Configuration options for PluresDBPraxisAdapter
+ */
+interface PluresDBAdapterConfig {
+    /** PluresDB instance */
+    db: PluresDBInstance;
+    /** Polling interval in milliseconds for watch functionality (default: 1000ms) */
+    pollInterval?: number;
+}
+/**
+ * PluresDB-backed implementation of PraxisDB
+ *
+ * Wraps the official PluresDB package from NPM to provide
+ * the PraxisDB interface for production use.
+ */
+declare class PluresDBPraxisAdapter implements PraxisDB {
+    private db;
+    private watchers;
+    private pollIntervals;
+    private lastValues;
+    private pollInterval;
+    constructor(config: PluresDBAdapterConfig | PluresDBInstance);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    watch<T>(key: string, callback: (val: T) => void): UnsubscribeFn;
+    /**
+     * Clean up all resources
+     */
+    dispose(): void;
+}
+/**
+ * Create a PluresDB-backed PraxisDB instance
+ *
+ * Wraps the official PluresDB package from NPM.
+ *
+ * @param config PluresDB instance or configuration object
+ * @returns PluresDBPraxisAdapter instance
+ *
+ * @example
+ * ```typescript
+ * import { PluresNode } from 'pluresdb';
+ * import { createPluresDB } from '@plures/praxis';
+ *
+ * const pluresdb = new PluresNode({ autoStart: true });
+ * const db = createPluresDB(pluresdb);
+ *
+ * await db.set('user:1', { name: 'Alice' });
+ * const user = await db.get('user:1');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom polling interval
+ * const db = createPluresDB({
+ *   db: pluresdb,
+ *   pollInterval: 500, // Poll every 500ms
+ * });
+ * ```
+ */
+declare function createPluresDB(config: PluresDBAdapterConfig | PluresDBInstance): PluresDBPraxisAdapter;
 
 /**
  * PraxisDB Store
@@ -3001,4 +3161,4 @@ declare function attachTauriToEngine<TContext>(engine: LogicEngine<TContext>, ad
  */
 declare function generateTauriConfig(config: TauriAppConfig): Record<string, unknown>;
 
-export { type ActivityState, type Actor, ActorManager, type CanvasDocument, type CanvasEdge, type CanvasEdgeStyle, type CanvasEditorConfig, type CanvasNode, type CanvasNodeStyle, type ComponentDefinition, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, type EventDefinition$1 as EventDefinition, type EventStreamEntry, type FactDefinition$1 as FactDefinition, type GeneratedDoc, type GeneratedPluresDBFile, type GraphEdge, type GuardianError, type GuardianResult, type GuardianWarning, InMemoryPraxisDB, type LifecycleState, type LoaderOptions, type LoaderResult, type LogicDefinition, LogicEngine, type ModelDefinition, type NodeBindings, type NodeDefinition, type OrchestrationDefinition, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, type PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, PraxisEvent, PraxisFact, PraxisModule, PraxisRegistry, type PraxisSchema, PraxisSchemaRegistry, PraxisState, type ReactiveEngineOptions, ReactiveLogicEngine, type RegistryGraph, RegistryIntrospector, type RegistrySchema, type RegistryStats, RuleDescriptor, RuleFn, type RuleNode, type RuleSchema, 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 TerminalNodeProps, type TransitionDoc, type UnsubscribeFn, type UnumAdapter, type UnumAdapterConfig, type UnumChannel, type UnumIdentity, type UnumMessage, type UnumStore, type ValidationError, type ValidationResult, attachTauriToEngine, attachToEngine, attachUnumToEngine, canvasToMermaid, canvasToSchema, canvasToYaml, createCanvasEditor, createInMemoryDB, createIntrospector, createMockTauriBridge, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createSchema, createSchemaRegistry, createSchemaTemplate, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUnumAdapter, defineConstraint, defineEvent, defineFact, defineModule, defineRule, filterEvents, filterFacts, findEvent, findFact, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, loadSchemaFromJson, loadSchemaFromYaml, registerSchema, schemaToCanvas, validateForGeneration, validateSchema, validateWithGuardian };
+export { type ActivityState, type Actor, ActorManager, type CanvasDocument, type CanvasEdge, type CanvasEdgeStyle, type CanvasEditorConfig, type CanvasNode, type CanvasNodeStyle, type ComponentDefinition, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, type EventDefinition$1 as EventDefinition, type EventStreamEntry, type FactDefinition$1 as FactDefinition, ReactiveLogicEngine as FrameworkAgnosticReactiveEngine, type ReactiveEngineOptions as FrameworkAgnosticReactiveEngineOptions, type GeneratedDoc, type GeneratedPluresDBFile, type GraphEdge, type GuardianError, type GuardianResult, type GuardianWarning, InMemoryPraxisDB, type LifecycleState, type LoaderOptions, type LoaderResult, type LogicDefinition, LogicEngine, type ModelDefinition, type NodeBindings, type NodeDefinition, type OrchestrationDefinition, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterConfig, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, type PluresDBInstance, PluresDBPraxisAdapter, type PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, PraxisEvent, PraxisFact, PraxisModule, PraxisRegistry, type PraxisSchema, PraxisSchemaRegistry, PraxisState, type RegistryGraph, RegistryIntrospector, type RegistrySchema, type RegistryStats, RuleDescriptor, RuleFn, type RuleNode, type RuleSchema, 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 TerminalNodeProps, type TransitionDoc, type UnsubscribeFn, type UnumAdapter, type UnumAdapterConfig, type UnumChannel, type UnumIdentity, type UnumMessage, type UnumStore, type ValidationError, type ValidationResult, attachTauriToEngine, attachToEngine, attachUnumToEngine, canvasToMermaid, canvasToSchema, canvasToYaml, createCanvasEditor, createReactiveEngine as createFrameworkAgnosticReactiveEngine, createInMemoryDB, createIntrospector, createMockTauriBridge, createPluresDB, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createSchema, createSchemaRegistry, createSchemaTemplate, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUnumAdapter, defineConstraint, defineEvent, defineFact, defineModule, defineRule, filterEvents, filterFacts, findEvent, findFact, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, loadSchemaFromJson, loadSchemaFromYaml, registerSchema, schemaToCanvas, validateForGeneration, validateSchema, validateWithGuardian };