@plures/praxis 1.1.1 → 1.1.3

package/dist/node/index.cjs

@@ -31,11 +31,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   ActorManager: () => ActorManager,
+  FrameworkAgnosticReactiveEngine: () => ReactiveLogicEngine2,
   InMemoryPraxisDB: () => InMemoryPraxisDB,
   LogicEngine: () => LogicEngine,
   PRAXIS_PATHS: () => PRAXIS_PATHS,
   PRAXIS_PROTOCOL_VERSION: () => PRAXIS_PROTOCOL_VERSION,
   PluresDBGenerator: () => PluresDBGenerator,
+  PluresDBPraxisAdapter: () => PluresDBPraxisAdapter,
   PraxisDBStore: () => PraxisDBStore,
   PraxisRegistry: () => PraxisRegistry,
   PraxisSchemaRegistry: () => PraxisSchemaRegistry,
@@ -50,14 +52,17 @@ __export(src_exports, {
   canvasToSchema: () => canvasToSchema,
   canvasToYaml: () => canvasToYaml,
   createCanvasEditor: () => createCanvasEditor,
+  createFrameworkAgnosticReactiveEngine: () => createReactiveEngine2,
   createInMemoryDB: () => createInMemoryDB,
   createIntrospector: () => createIntrospector,
   createMockExecutor: () => createMockExecutor,
   createMockTauriBridge: () => createMockTauriBridge,
+  createPluresDB: () => createPluresDB,
   createPluresDBAdapter: () => createPluresDBAdapter,
   createPluresDBGenerator: () => createPluresDBGenerator,
   createPraxisDBStore: () => createPraxisDBStore,
   createPraxisEngine: () => createPraxisEngine,
+  createReactiveEngine: () => createReactiveEngine,
   createSchemaRegistry: () => createSchemaRegistry,
   createSchemaTemplate: () => createSchemaTemplate,
   createStateDocsGenerator: () => createStateDocsGenerator,
@@ -360,9 +365,7 @@ function createPraxisEngine(options) {
 var $ = __toESM(require("svelte/internal/client"), 1);
 var ReactiveLogicEngine = class {
   #state = (
-    // The single source of truth, reactive by default
-    // We use $state.raw for things that shouldn't be deeply reactive if needed,
-    // but for context we usually want deep reactivity.
+    // Use Svelte's $state rune for automatic reactivity
     $.state($.proxy({ context: {}, facts: [], meta: {} }))
   );
   get state() {
@@ -371,14 +374,26 @@ var ReactiveLogicEngine = class {
   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 directly.
-   * Consumers can use this in $derived() or $effect().
+   * Access the reactive context.
+   * In Svelte 5 components, changes to this object will automatically trigger updates.
    */
   get context() {
     return this.state.context;
@@ -389,9 +404,15 @@ var ReactiveLogicEngine = class {
   get facts() {
     return this.state.facts;
   }
+  /**
+   * Access the reactive metadata.
+   */
+  get meta() {
+    return this.state.meta;
+  }
   /**
    * Apply a mutation to the state.
-   * This is the "Action" or "Rule" equivalent.
+   * Changes will automatically trigger Svelte reactivity.
    * 
    * @param mutator A function that receives the state and modifies it.
    */
@@ -399,12 +420,234 @@ var ReactiveLogicEngine = class {
     mutator(this.state);
   }
   /**
-   * Access the reactive meta.
+   * 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);
+}
+
+// src/core/reactive-engine.ts
+var ReactiveLogicEngine2 = class _ReactiveLogicEngine {
+  _state;
+  _subscribers = /* @__PURE__ */ new Set();
+  _contextProxy;
+  _factsProxy;
+  _metaProxy;
+  _batchDepth = 0;
+  _pendingNotification = false;
+  _proxyCache = /* @__PURE__ */ new WeakMap();
+  // Array methods that mutate the array
+  static ARRAY_MUTATORS = ["push", "pop", "shift", "unshift", "splice", "sort", "reverse"];
+  constructor(options) {
+    this._state = {
+      context: options.initialContext,
+      facts: options.initialFacts ?? [],
+      meta: options.initialMeta ?? {}
+    };
+    this._contextProxy = this._createReactiveProxy(this._state.context);
+    this._factsProxy = this._createReactiveProxy(this._state.facts);
+    this._metaProxy = this._createReactiveProxy(this._state.meta);
+  }
+  /**
+   * Create a reactive proxy that notifies subscribers on changes.
+   * Uses a WeakMap cache to avoid creating multiple proxies for the same object.
+   */
+  _createReactiveProxy(target) {
+    const cached = this._proxyCache.get(target);
+    if (cached) {
+      return cached;
+    }
+    const self = this;
+    const handler = {
+      get(obj, prop) {
+        const value = Reflect.get(obj, prop);
+        if (value && typeof value === "object") {
+          return self._createReactiveProxy(value);
+        }
+        if (Array.isArray(obj) && typeof value === "function") {
+          if (_ReactiveLogicEngine.ARRAY_MUTATORS.includes(prop)) {
+            return function(...args) {
+              const result = value.apply(obj, args);
+              self._notify();
+              return result;
+            };
+          }
+        }
+        return value;
+      },
+      set(obj, prop, value) {
+        const oldValue = obj[prop];
+        const result = Reflect.set(obj, prop, value);
+        if (oldValue !== value) {
+          self._notify();
+        }
+        return result;
+      },
+      deleteProperty(obj, prop) {
+        const result = Reflect.deleteProperty(obj, prop);
+        self._notify();
+        return result;
+      }
+    };
+    const proxy2 = new Proxy(target, handler);
+    this._proxyCache.set(target, proxy2);
+    return proxy2;
+  }
+  /**
+   * Notify all subscribers of state changes
+   */
+  _notify() {
+    if (this._batchDepth > 0) {
+      this._pendingNotification = true;
+      return;
+    }
+    const currentState = {
+      context: this._contextProxy,
+      facts: this._factsProxy,
+      meta: this._metaProxy
+    };
+    this._subscribers.forEach((callback) => {
+      try {
+        callback(currentState);
+      } catch (error) {
+        console.error("Error in reactive engine subscriber:", error);
+      }
+    });
+  }
+  /**
+   * Get the full state object
+   */
+  get state() {
+    return {
+      context: this._contextProxy,
+      facts: this._factsProxy,
+      meta: this._metaProxy
+    };
+  }
+  /**
+   * Access the reactive context.
+   * Changes to this object will trigger subscriber notifications.
+   */
+  get context() {
+    return this._contextProxy;
+  }
+  /**
+   * Access the reactive facts list.
+   * Changes to this array will trigger subscriber notifications.
+   */
+  get facts() {
+    return this._factsProxy;
+  }
+  /**
+   * Access the reactive metadata.
+   * Changes to this object will trigger subscriber notifications.
    */
   get meta() {
-    return this.state.meta;
+    return this._metaProxy;
+  }
+  /**
+   * 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.
+   */
+  apply(mutator) {
+    this._batchDepth++;
+    try {
+      mutator({
+        context: this._contextProxy,
+        facts: this._factsProxy,
+        meta: this._metaProxy
+      });
+    } finally {
+      this._batchDepth--;
+      if (this._batchDepth === 0 && this._pendingNotification) {
+        this._pendingNotification = false;
+        this._notify();
+      }
+    }
+  }
+  /**
+   * Subscribe to state changes.
+   * Returns an unsubscribe function.
+   * 
+   * @param callback Function to call when state changes
+   * @returns Unsubscribe function
+   */
+  subscribe(callback) {
+    this._subscribers.add(callback);
+    try {
+      callback({
+        context: this._contextProxy,
+        facts: this._factsProxy,
+        meta: this._metaProxy
+      });
+    } catch (error) {
+      console.error("Error in reactive engine subscriber:", error);
+    }
+    return () => {
+      this._subscribers.delete(callback);
+    };
+  }
+  /**
+   * 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
+   */
+  $derived(selector) {
+    const subscribers = /* @__PURE__ */ new Set();
+    let currentValue = selector({
+      context: this._contextProxy,
+      facts: this._factsProxy,
+      meta: this._metaProxy
+    });
+    this.subscribe(() => {
+      const newValue = selector({
+        context: this._contextProxy,
+        facts: this._factsProxy,
+        meta: this._metaProxy
+      });
+      if (newValue !== currentValue) {
+        currentValue = newValue;
+        subscribers.forEach((callback) => {
+          try {
+            callback(currentValue);
+          } catch (error) {
+            console.error("Error in derived value subscriber:", error);
+          }
+        });
+      }
+    });
+    return {
+      subscribe: (callback) => {
+        subscribers.add(callback);
+        try {
+          callback(currentValue);
+        } catch (error) {
+          console.error("Error in derived value subscriber:", error);
+        }
+        return () => {
+          subscribers.delete(callback);
+        };
+      }
+    };
   }
 };
+function createReactiveEngine2(options) {
+  return new ReactiveLogicEngine2(options);
+}
 
 // src/core/actors.ts
 var ActorManager = class {
@@ -1634,6 +1877,93 @@ var InMemoryPraxisDB = class {
 function createInMemoryDB() {
   return new InMemoryPraxisDB();
 }
+var PluresDBPraxisAdapter = class {
+  db;
+  watchers = /* @__PURE__ */ new Map();
+  pollIntervals = /* @__PURE__ */ new Map();
+  lastValues = /* @__PURE__ */ new Map();
+  pollInterval;
+  constructor(config) {
+    if ("get" in config && "put" in config) {
+      this.db = config;
+      this.pollInterval = 1e3;
+    } else {
+      this.db = config.db;
+      this.pollInterval = config.pollInterval ?? 1e3;
+    }
+  }
+  async get(key) {
+    try {
+      const value = await this.db.get(key);
+      return value;
+    } catch (error) {
+      return void 0;
+    }
+  }
+  async set(key, value) {
+    await this.db.put(key, value);
+    this.lastValues.set(key, value);
+    const keyWatchers = this.watchers.get(key);
+    if (keyWatchers) {
+      for (const callback of keyWatchers) {
+        callback(value);
+      }
+    }
+  }
+  watch(key, callback) {
+    if (!this.watchers.has(key)) {
+      this.watchers.set(key, /* @__PURE__ */ new Set());
+    }
+    const watchers = this.watchers.get(key);
+    const wrappedCallback = (val) => callback(val);
+    watchers.add(wrappedCallback);
+    if (!this.pollIntervals.has(key)) {
+      const interval = setInterval(async () => {
+        try {
+          const value = await this.db.get(key);
+          const lastValue = this.lastValues.get(key);
+          if (JSON.stringify(value) !== JSON.stringify(lastValue)) {
+            this.lastValues.set(key, value);
+            const currentWatchers = this.watchers.get(key);
+            if (currentWatchers) {
+              for (const cb of currentWatchers) {
+                cb(value);
+              }
+            }
+          }
+        } catch (error) {
+        }
+      }, this.pollInterval);
+      this.pollIntervals.set(key, interval);
+    }
+    return () => {
+      watchers.delete(wrappedCallback);
+      if (watchers.size === 0) {
+        this.watchers.delete(key);
+        const interval = this.pollIntervals.get(key);
+        if (interval) {
+          clearInterval(interval);
+          this.pollIntervals.delete(key);
+        }
+        this.lastValues.delete(key);
+      }
+    };
+  }
+  /**
+   * Clean up all resources
+   */
+  dispose() {
+    for (const interval of this.pollIntervals.values()) {
+      clearInterval(interval);
+    }
+    this.pollIntervals.clear();
+    this.watchers.clear();
+    this.lastValues.clear();
+  }
+};
+function createPluresDB(config) {
+  return new PluresDBPraxisAdapter(config);
+}
 
 // src/core/pluresdb/schema-registry.ts
 function getSchemaPath(schemaName) {
@@ -3185,11 +3515,13 @@ function generateTauriConfig(config) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActorManager,
+  FrameworkAgnosticReactiveEngine,
   InMemoryPraxisDB,
   LogicEngine,
   PRAXIS_PATHS,
   PRAXIS_PROTOCOL_VERSION,
   PluresDBGenerator,
+  PluresDBPraxisAdapter,
   PraxisDBStore,
   PraxisRegistry,
   PraxisSchemaRegistry,
@@ -3204,14 +3536,17 @@ function generateTauriConfig(config) {
   canvasToSchema,
   canvasToYaml,
   createCanvasEditor,
+  createFrameworkAgnosticReactiveEngine,
   createInMemoryDB,
   createIntrospector,
   createMockExecutor,
   createMockTauriBridge,
+  createPluresDB,
   createPluresDBAdapter,
   createPluresDBGenerator,
   createPraxisDBStore,
   createPraxisEngine,
+  createReactiveEngine,
   createSchemaRegistry,
   createSchemaTemplate,
   createStateDocsGenerator,

package/dist/node/index.d.cts

@@ -1,42 +1,91 @@
 import { P as PraxisState, a as PraxisEvent, b as PraxisFact } from './protocol-Qek7ebBl.cjs';
 export { g as PRAXIS_PROTOCOL_VERSION, e as PraxisDiagnostics, d as PraxisStepConfig, f as PraxisStepFn, c as PraxisStepResult } from './protocol-Qek7ebBl.cjs';
-import { L as LogicEngine, P as PraxisRegistry, R as RuleDescriptor, C as ConstraintDescriptor, a as RuleFn, b as ConstraintFn, c as PraxisModule } from './engine-CVJobhHm.cjs';
-export { e as ConstraintId, f as PraxisEngineOptions, d as RuleId, g as createPraxisEngine } from './engine-CVJobhHm.cjs';
-import { P as PraxisDB, U as UnsubscribeFn } from './terminal-adapter-XLtCjjb_.cjs';
-export { C as CommandExecutor, I as InMemoryPraxisDB, T as TerminalAdapter, d as TerminalAdapterOptions, a as TerminalExecutionResult, b as TerminalNodeState, f as createInMemoryDB, e as createMockExecutor, c as createTerminalAdapter, r as runTerminalCommand } from './terminal-adapter-XLtCjjb_.cjs';
+import { L as LogicEngine, P as PraxisRegistry, b as RuleDescriptor, C as ConstraintDescriptor, d as RuleFn, e as ConstraintFn, f as PraxisModule } from './reactive-engine.svelte-1M4m_C_v.cjs';
+export { h as ConstraintId, i as PraxisEngineOptions, a as ReactiveEngineOptions, R as ReactiveLogicEngine, g as RuleId, j as createPraxisEngine, c as createReactiveEngine } from './reactive-engine.svelte-1M4m_C_v.cjs';
+import { P as PraxisDB, U as UnsubscribeFn$1 } from './terminal-adapter-CDzxoLKR.cjs';
+export { C as CommandExecutor, I as InMemoryPraxisDB, g as PluresDBAdapterConfig, f as PluresDBInstance, i as PluresDBPraxisAdapter, T as TerminalAdapter, d as TerminalAdapterOptions, a as TerminalExecutionResult, b as TerminalNodeState, h as createInMemoryDB, e as createMockExecutor, j as createPluresDB, c as createTerminalAdapter, r as runTerminalCommand } from './terminal-adapter-CDzxoLKR.cjs';
 import { PraxisSchema, ValidationResult, ModelDefinition, FieldDefinition, ComponentDefinition, LogicDefinition } from './schema.cjs';
 export { NodeBindings, NodeDefinition, OrchestrationDefinition, TerminalNodeProps, ValidationError, createSchemaTemplate, validateSchema } from './schema.cjs';
 
 /**
  * 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 = () => 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.
      */
@@ -46,10 +95,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;
+    /**
+     * 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;
+    };
 }
+/**
+ * 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
@@ -634,7 +727,7 @@ declare class PraxisDBStore<TContext = unknown> {
      * @param callback Called when facts of this type change
      * @returns Unsubscribe function
      */
-    watchFacts(factTag: string, callback: (facts: PraxisFact[]) => void): UnsubscribeFn;
+    watchFacts(factTag: string, callback: (facts: PraxisFact[]) => void): UnsubscribeFn$1;
     /**
      * Check constraints against the current state with new facts
      */
@@ -997,7 +1090,7 @@ declare function createPluresDBAdapter<TContext = unknown>(options: PluresDBAdap
  * detach();
  * ```
  */
-declare function attachToEngine<TContext = unknown>(store: PraxisDBStore<TContext>, engine: LogicEngine<TContext>): UnsubscribeFn;
+declare function attachToEngine<TContext = unknown>(store: PraxisDBStore<TContext>, engine: LogicEngine<TContext>): UnsubscribeFn$1;
 
 /**
  * Unum Integration
@@ -2576,4 +2669,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, ComponentDefinition, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, type EventDefinition, type EventStreamEntry, type FactDefinition, type GeneratedDoc, type GeneratedPluresDBFile, type GraphEdge, type GuardianError, type GuardianResult, type GuardianWarning, type LifecycleState, type LoaderOptions, type LoaderResult, LogicDefinition, LogicEngine, ModelDefinition, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, PraxisEvent, PraxisFact, PraxisModule, PraxisRegistry, 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 TransitionDoc, UnsubscribeFn, type UnumAdapter, type UnumAdapterConfig, type UnumChannel, type UnumIdentity, type UnumMessage, type UnumStore, ValidationResult, attachTauriToEngine, attachToEngine, attachUnumToEngine, canvasToMermaid, canvasToSchema, canvasToYaml, createCanvasEditor, createIntrospector, createMockTauriBridge, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createSchemaRegistry, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUnumAdapter, defineConstraint, defineEvent, defineFact, defineModule, defineRule, filterEvents, filterFacts, findEvent, findFact, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, loadSchema, loadSchemaFromFile, loadSchemaFromJson, loadSchemaFromYaml, registerSchema, schemaToCanvas, validateForGeneration, validateWithGuardian };
+export { type ActivityState, type Actor, ActorManager, type CanvasDocument, type CanvasEdge, type CanvasEdgeStyle, type CanvasEditorConfig, type CanvasNode, type CanvasNodeStyle, ComponentDefinition, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, 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 LifecycleState, type LoaderOptions, type LoaderResult, LogicDefinition, LogicEngine, ModelDefinition, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, PraxisEvent, PraxisFact, PraxisModule, PraxisRegistry, 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 TransitionDoc, UnsubscribeFn$1 as UnsubscribeFn, type UnumAdapter, type UnumAdapterConfig, type UnumChannel, type UnumIdentity, type UnumMessage, type UnumStore, ValidationResult, attachTauriToEngine, attachToEngine, attachUnumToEngine, canvasToMermaid, canvasToSchema, canvasToYaml, createCanvasEditor, createReactiveEngine as createFrameworkAgnosticReactiveEngine, createIntrospector, createMockTauriBridge, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createSchemaRegistry, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUnumAdapter, defineConstraint, defineEvent, defineFact, defineModule, defineRule, filterEvents, filterFacts, findEvent, findFact, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, loadSchema, loadSchemaFromFile, loadSchemaFromJson, loadSchemaFromYaml, registerSchema, schemaToCanvas, validateForGeneration, validateWithGuardian };