@plures/praxis 1.1.2 → 1.2.0

package/dist/node/index.js

@@ -1,3 +1,14 @@
+import {
+  InMemoryPraxisDB,
+  PluresDBPraxisAdapter,
+  createInMemoryDB,
+  createPluresDB
+} from "./chunk-JQ64KMLN.js";
+import {
+  StateDocsGenerator,
+  createStateDocsGenerator,
+  generateDocs
+} from "./chunk-S54337I5.js";
 import {
   canvasToMermaid,
   canvasToSchema,
@@ -6,6 +17,11 @@ import {
   schemaToCanvas,
   validateWithGuardian
 } from "./chunk-SRM3OPPM.js";
+import {
+  PraxisRegistry,
+  ReactiveLogicEngine,
+  createReactiveEngine
+} from "./chunk-LE2ZJYFC.js";
 import {
   TerminalAdapter,
   createMockExecutor,
@@ -27,320 +43,226 @@ import {
   createSchemaTemplate,
   validateSchema
 } from "./chunk-UATVJBNV.js";
+import {
+  LogicEngine,
+  PRAXIS_PROTOCOL_VERSION,
+  createPraxisEngine
+} from "./chunk-VOMLVI6V.js";
 import "./chunk-QGM4M3NI.js";
 
-// 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;
+// 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.registry = options.registry;
-    this.state = {
+    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
+      meta: options.initialMeta ?? {}
     };
+    this._contextProxy = this._createReactiveProxy(this._state.context);
+    this._factsProxy = this._createReactiveProxy(this._state.facts);
+    this._metaProxy = this._createReactiveProxy(this._state.meta);
   }
   /**
-   * Get the current context
+   * Create a reactive proxy that notifies subscribers on changes.
+   * Uses a WeakMap cache to avoid creating multiple proxies for the same object.
    */
-  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()
+  _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;
+      }
     };
-    return this.stepWithConfig(events, config);
+    const proxy = new Proxy(target, handler);
+    this._proxyCache.set(target, proxy);
+    return proxy;
   }
   /**
-   * Process events with specific rule and constraint configuration.
-   *
-   * @param events Events to process
-   * @param config Step configuration
-   * @returns Result with new state and diagnostics
+   * Notify all subscribers of state changes
    */
-  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 }
-        });
-      }
+  _notify() {
+    if (this._batchDepth > 0) {
+      this._pendingNotification = true;
+      return;
     }
-    newState = {
-      ...newState,
-      facts: [...newState.facts, ...newFacts]
+    const currentState = {
+      context: this._contextProxy,
+      facts: this._factsProxy,
+      meta: this._metaProxy
     };
-    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;
-      }
+    this._subscribers.forEach((callback) => {
       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 }
-          });
-        }
+        callback(currentState);
       } catch (error) {
-        diagnostics.push({
-          kind: "constraint-violation",
-          message: `Error checking constraint "${constraintId}": ${error instanceof Error ? error.message : String(error)}`,
-          data: { constraintId, error }
-        });
+        console.error("Error in reactive engine subscriber:", 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
+   * Get the full state object
    */
-  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 = (
-    // 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.
-    $.state($.proxy({ context: {}, facts: [], meta: {} }))
-  );
   get state() {
-    return $.get(this.#state);
-  }
-  set state(value) {
-    $.set(this.#state, value, true);
-  }
-  constructor(options) {
-    this.state.context = options.initialContext;
-    this.state.facts = options.initialFacts ?? [];
-    this.state.meta = options.initialMeta ?? {};
+    return {
+      context: this._contextProxy,
+      facts: this._factsProxy,
+      meta: this._metaProxy
+    };
   }
   /**
-   * 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() {
-    return this.state.context;
+    return this._contextProxy;
   }
   /**
    * Access the reactive facts list.
+   * Changes to this array will trigger subscriber notifications.
    */
   get facts() {
-    return this.state.facts;
+    return this._factsProxy;
+  }
+  /**
+   * Access the reactive metadata.
+   * Changes to this object will trigger subscriber notifications.
+   */
+  get 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) {
-    mutator(this.state);
+    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();
+      }
+    }
   }
   /**
-   * Access the reactive meta.
+   * Subscribe to state changes.
+   * Returns an unsubscribe function.
+   * 
+   * @param callback Function to call when state changes
+   * @returns Unsubscribe function
    */
-  get meta() {
-    return this.state.meta;
+  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 {
@@ -429,7 +351,7 @@ var ActorManager = class {
   /**
    * Notify active actors of a state change
    */
-  async notifyStateChange(state2) {
+  async notifyStateChange(state) {
     if (!this.engine) {
       return;
     }
@@ -437,7 +359,7 @@ var ActorManager = class {
     for (const actorId of this.activeActors) {
       const actor = this.actors.get(actorId);
       if (actor?.onStateChange) {
-        const result = actor.onStateChange(state2, this.engine);
+        const result = actor.onStateChange(state, this.engine);
         if (result instanceof Promise) {
           promises.push(result);
         }
@@ -915,14 +837,14 @@ var PraxisDBStore = class {
   async checkConstraints(newFacts) {
     const constraints = this.registry.getAllConstraints();
     const errors = [];
-    const state2 = {
+    const state = {
       context: this.context,
       facts: newFacts,
       meta: {}
     };
     for (const constraint of constraints) {
       try {
-        const result = constraint.impl(state2);
+        const result = constraint.impl(state);
         if (result === false) {
           errors.push(`Constraint "${constraint.id}" violated`);
         } else if (typeof result === "string") {
@@ -956,7 +878,7 @@ var PraxisDBStore = class {
    */
   async triggerRulesForEvents(events) {
     const rules = this.registry.getAllRules();
-    const state2 = {
+    const state = {
       context: this.context,
       facts: [],
       meta: {}
@@ -964,7 +886,7 @@ var PraxisDBStore = class {
     const derivedFacts = [];
     for (const rule of rules) {
       try {
-        const facts = rule.impl(state2, events);
+        const facts = rule.impl(state, events);
         derivedFacts.push(...facts);
       } catch (error) {
         this.onRuleError(rule.id, error);
@@ -1006,54 +928,6 @@ function createPraxisDBStore(db, registry, initialContext, onRuleError) {
   return new PraxisDBStore({ db, registry, initialContext, onRuleError });
 }
 
-// src/core/pluresdb/adapter.ts
-var InMemoryPraxisDB = class {
-  store = /* @__PURE__ */ new Map();
-  watchers = /* @__PURE__ */ new Map();
-  async get(key) {
-    return this.store.get(key);
-  }
-  async set(key, value) {
-    this.store.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);
-    return () => {
-      watchers.delete(wrappedCallback);
-      if (watchers.size === 0) {
-        this.watchers.delete(key);
-      }
-    };
-  }
-  /**
-   * Get all keys (for testing/debugging)
-   */
-  keys() {
-    return Array.from(this.store.keys());
-  }
-  /**
-   * Clear all data (for testing)
-   */
-  clear() {
-    this.store.clear();
-    this.watchers.clear();
-  }
-};
-function createInMemoryDB() {
-  return new InMemoryPraxisDB();
-}
-
 // src/core/pluresdb/schema-registry.ts
 function getSchemaPath(schemaName) {
   return `${PRAXIS_PATHS.SCHEMAS}/${schemaName}`;
@@ -1374,447 +1248,6 @@ function attachUnumToEngine(_engine, _adapter, _channelId) {
   };
 }
 
-// src/integrations/state-docs.ts
-var StateDocsGenerator = class {
-  config;
-  constructor(config) {
-    this.config = {
-      target: "./docs",
-      globs: ["**/*.ts", "**/*.js"],
-      visualization: {
-        format: "mermaid",
-        exportPng: false,
-        theme: "default"
-      },
-      template: {
-        toc: true,
-        timestamp: true
-      },
-      ...config
-    };
-  }
-  /**
-   * Generate documentation from a Praxis schema
-   */
-  generateFromSchema(schema) {
-    const docs = [];
-    docs.push(this.generateSchemaReadme(schema));
-    if (schema.models && schema.models.length > 0) {
-      docs.push(this.generateModelsDoc(schema));
-    }
-    if (schema.components && schema.components.length > 0) {
-      docs.push(this.generateComponentsDoc(schema));
-    }
-    if (schema.logic && schema.logic.length > 0) {
-      for (const logic of schema.logic) {
-        docs.push(this.generateLogicDoc(logic));
-        docs.push(this.generateLogicDiagram(logic));
-      }
-    }
-    return docs;
-  }
-  /**
-   * Generate documentation from a Praxis registry
-   */
-  generateFromModule(module) {
-    const docs = [];
-    const rules = module.rules;
-    const constraints = module.constraints;
-    docs.push(this.generateRulesDoc(rules));
-    docs.push(this.generateConstraintsDoc(constraints));
-    docs.push(this.generateRegistryDiagram(rules, constraints));
-    return docs;
-  }
-  /**
-   * Generate the main schema README
-   */
-  generateSchemaReadme(schema) {
-    const lines = [];
-    if (this.config.template?.header) {
-      lines.push(this.config.template.header);
-      lines.push("");
-    }
-    lines.push(`# ${schema.name || this.config.projectTitle}`);
-    lines.push("");
-    if (schema.description) {
-      lines.push(schema.description);
-      lines.push("");
-    }
-    if (this.config.template?.toc) {
-      lines.push("## Table of Contents");
-      lines.push("");
-      lines.push("- [Overview](#overview)");
-      if (schema.models && schema.models.length > 0) {
-        lines.push("- [Models](#models)");
-      }
-      if (schema.components && schema.components.length > 0) {
-        lines.push("- [Components](#components)");
-      }
-      if (schema.logic && schema.logic.length > 0) {
-        lines.push("- [Logic](#logic)");
-      }
-      lines.push("");
-    }
-    lines.push("## Overview");
-    lines.push("");
-    lines.push(`**Version:** ${schema.version}`);
-    lines.push("");
-    lines.push("### Statistics");
-    lines.push("");
-    lines.push("| Category | Count |");
-    lines.push("|----------|-------|");
-    lines.push(`| Models | ${schema.models?.length || 0} |`);
-    lines.push(`| Components | ${schema.components?.length || 0} |`);
-    lines.push(`| Logic Modules | ${schema.logic?.length || 0} |`);
-    lines.push("");
-    if (schema.models && schema.models.length > 0) {
-      lines.push("## Models");
-      lines.push("");
-      for (const model of schema.models) {
-        lines.push(`### ${model.name}`);
-        lines.push("");
-        if (model.description) {
-          lines.push(model.description);
-          lines.push("");
-        }
-        lines.push("**Fields:**");
-        lines.push("");
-        lines.push("| Name | Type | Required |");
-        lines.push("|------|------|----------|");
-        for (const field of model.fields) {
-          const required = field.optional ? "No" : "Yes";
-          lines.push(`| ${field.name} | ${field.type} | ${required} |`);
-        }
-        lines.push("");
-      }
-    }
-    if (schema.components && schema.components.length > 0) {
-      lines.push("## Components");
-      lines.push("");
-      for (const component of schema.components) {
-        lines.push(`### ${component.name}`);
-        lines.push("");
-        lines.push(`**Type:** ${component.type}`);
-        lines.push("");
-        if (component.description) {
-          lines.push(component.description);
-          lines.push("");
-        }
-        if (component.model) {
-          lines.push(`**Model:** ${component.model}`);
-          lines.push("");
-        }
-      }
-    }
-    if (schema.logic && schema.logic.length > 0) {
-      lines.push("## Logic");
-      lines.push("");
-      for (const logic of schema.logic) {
-        lines.push(`### ${logic.id}`);
-        lines.push("");
-        if (logic.description) {
-          lines.push(logic.description);
-          lines.push("");
-        }
-        if (logic.events && logic.events.length > 0) {
-          lines.push("**Events:**");
-          lines.push("");
-          for (const event of logic.events) {
-            lines.push(`- \`${event.tag}\`: ${event.description || ""}`);
-          }
-          lines.push("");
-        }
-        if (logic.facts && logic.facts.length > 0) {
-          lines.push("**Facts:**");
-          lines.push("");
-          for (const fact of logic.facts) {
-            lines.push(`- \`${fact.tag}\`: ${fact.description || ""}`);
-          }
-          lines.push("");
-        }
-        if (logic.rules && logic.rules.length > 0) {
-          lines.push("**Rules:**");
-          lines.push("");
-          for (const rule of logic.rules) {
-            lines.push(`- \`${rule.id}\`: ${rule.description || ""}`);
-          }
-          lines.push("");
-        }
-      }
-    }
-    if (this.config.template?.timestamp) {
-      lines.push("---");
-      lines.push("");
-      lines.push(`*Generated on ${(/* @__PURE__ */ new Date()).toISOString()} by State-Docs*`);
-    }
-    if (this.config.template?.footer) {
-      lines.push("");
-      lines.push(this.config.template.footer);
-    }
-    return {
-      path: `${this.config.target}/README.md`,
-      content: lines.join("\n"),
-      type: "markdown"
-    };
-  }
-  /**
-   * Generate models documentation
-   */
-  generateModelsDoc(schema) {
-    const lines = [
-      "# Models",
-      "",
-      "This document describes all data models defined in the schema.",
-      ""
-    ];
-    if (schema.models) {
-      for (const model of schema.models) {
-        lines.push(`## ${model.name}`);
-        lines.push("");
-        if (model.description) {
-          lines.push(model.description);
-          lines.push("");
-        }
-        lines.push("### Fields");
-        lines.push("");
-        lines.push("| Name | Type | Required | Description |");
-        lines.push("|------|------|----------|-------------|");
-        for (const field of model.fields) {
-          const required = field.optional ? "No" : "Yes";
-          const description = field.description || "-";
-          lines.push(`| ${field.name} | \`${field.type}\` | ${required} | ${description} |`);
-        }
-        lines.push("");
-        if (model.indexes && model.indexes.length > 0) {
-          lines.push("### Indexes");
-          lines.push("");
-          for (const index of model.indexes) {
-            lines.push(`- **${index.name}**: \`${index.fields.join(", ")}\``);
-          }
-          lines.push("");
-        }
-      }
-    }
-    return {
-      path: `${this.config.target}/models.md`,
-      content: lines.join("\n"),
-      type: "markdown"
-    };
-  }
-  /**
-   * Generate components documentation
-   */
-  generateComponentsDoc(schema) {
-    const lines = [
-      "# Components",
-      "",
-      "This document describes all UI components defined in the schema.",
-      ""
-    ];
-    if (schema.components) {
-      for (const component of schema.components) {
-        lines.push(`## ${component.name}`);
-        lines.push("");
-        lines.push(`**Type:** ${component.type}`);
-        lines.push("");
-        if (component.description) {
-          lines.push(component.description);
-          lines.push("");
-        }
-        if (component.model) {
-          lines.push(
-            `**Associated Model:** [${component.model}](./models.md#${component.model.toLowerCase()})`
-          );
-          lines.push("");
-        }
-      }
-    }
-    return {
-      path: `${this.config.target}/components.md`,
-      content: lines.join("\n"),
-      type: "markdown"
-    };
-  }
-  /**
-   * Generate logic documentation
-   */
-  generateLogicDoc(logic) {
-    const lines = [`# ${logic.id}`, ""];
-    if (logic.description) {
-      lines.push(logic.description);
-      lines.push("");
-    }
-    if (logic.events && logic.events.length > 0) {
-      lines.push("## Events");
-      lines.push("");
-      lines.push("| Event | Description | Payload |");
-      lines.push("|-------|-------------|---------|");
-      for (const event of logic.events) {
-        const payload = event.payload ? Object.entries(event.payload).map(([k, v]) => `${k}: ${v}`).join(", ") : "-";
-        lines.push(`| \`${event.tag}\` | ${event.description || "-"} | ${payload} |`);
-      }
-      lines.push("");
-    }
-    if (logic.facts && logic.facts.length > 0) {
-      lines.push("## Facts");
-      lines.push("");
-      lines.push("| Fact | Description | Payload |");
-      lines.push("|------|-------------|---------|");
-      for (const fact of logic.facts) {
-        const payload = fact.payload ? Object.entries(fact.payload).map(([k, v]) => `${k}: ${v}`).join(", ") : "-";
-        lines.push(`| \`${fact.tag}\` | ${fact.description || "-"} | ${payload} |`);
-      }
-      lines.push("");
-    }
-    if (logic.rules && logic.rules.length > 0) {
-      lines.push("## Rules");
-      lines.push("");
-      for (const rule of logic.rules) {
-        lines.push(`### ${rule.id}`);
-        lines.push("");
-        if (rule.description) {
-          lines.push(rule.description);
-          lines.push("");
-        }
-        if (rule.priority !== void 0) {
-          lines.push(`**Priority:** ${rule.priority}`);
-          lines.push("");
-        }
-      }
-    }
-    if (logic.constraints && logic.constraints.length > 0) {
-      lines.push("## Constraints");
-      lines.push("");
-      for (const constraint of logic.constraints) {
-        lines.push(`### ${constraint.id}`);
-        lines.push("");
-        if (constraint.description) {
-          lines.push(constraint.description);
-          lines.push("");
-        }
-        if (constraint.message) {
-          lines.push(`**Error Message:** ${constraint.message}`);
-          lines.push("");
-        }
-      }
-    }
-    return {
-      path: `${this.config.target}/logic/${logic.id}.md`,
-      content: lines.join("\n"),
-      type: "markdown"
-    };
-  }
-  /**
-   * Generate Mermaid diagram for logic
-   */
-  generateLogicDiagram(logic) {
-    const lines = ["stateDiagram-v2"];
-    if (logic.events && logic.facts) {
-      lines.push("    [*] --> Processing");
-      for (const event of logic.events) {
-        lines.push(`    Processing --> ${event.tag.replace(/[^a-zA-Z0-9]/g, "")}: ${event.tag}`);
-      }
-      for (const fact of logic.facts) {
-        lines.push(`    ${fact.tag.replace(/[^a-zA-Z0-9]/g, "")} --> [*]`);
-      }
-    }
-    return {
-      path: `${this.config.target}/logic/${logic.id}.mmd`,
-      content: lines.join("\n"),
-      type: "mermaid"
-    };
-  }
-  /**
-   * Generate rules documentation
-   */
-  generateRulesDoc(rules) {
-    const lines = [
-      "# Rules",
-      "",
-      "This document describes all rules registered in the Praxis engine.",
-      ""
-    ];
-    for (const rule of rules) {
-      lines.push(`## ${rule.id}`);
-      lines.push("");
-      if (rule.description) {
-        lines.push(rule.description);
-        lines.push("");
-      }
-      if (rule.meta?.eventType) {
-        lines.push(`**Triggers on:** \`${rule.meta.eventType}\``);
-        lines.push("");
-      }
-      if (rule.meta?.priority !== void 0) {
-        lines.push(`**Priority:** ${rule.meta.priority}`);
-        lines.push("");
-      }
-    }
-    return {
-      path: `${this.config.target}/rules.md`,
-      content: lines.join("\n"),
-      type: "markdown"
-    };
-  }
-  /**
-   * Generate constraints documentation
-   */
-  generateConstraintsDoc(constraints) {
-    const lines = [
-      "# Constraints",
-      "",
-      "This document describes all constraints (invariants) registered in the Praxis engine.",
-      ""
-    ];
-    for (const constraint of constraints) {
-      lines.push(`## ${constraint.id}`);
-      lines.push("");
-      if (constraint.description) {
-        lines.push(constraint.description);
-        lines.push("");
-      }
-      if (constraint.meta?.errorMessage) {
-        lines.push(`**Error Message:** ${constraint.meta.errorMessage}`);
-        lines.push("");
-      }
-    }
-    return {
-      path: `${this.config.target}/constraints.md`,
-      content: lines.join("\n"),
-      type: "markdown"
-    };
-  }
-  /**
-   * Generate state diagram from registry
-   */
-  generateRegistryDiagram(rules, constraints) {
-    const lines = ["graph TD", "    subgraph Rules"];
-    for (const rule of rules) {
-      const id = rule.id.replace(/[^a-zA-Z0-9]/g, "_");
-      lines.push(`        ${id}["${rule.id}"]`);
-    }
-    lines.push("    end");
-    lines.push("    subgraph Constraints");
-    for (const constraint of constraints) {
-      const id = constraint.id.replace(/[^a-zA-Z0-9]/g, "_");
-      lines.push(`        ${id}["${constraint.id}"]`);
-    }
-    lines.push("    end");
-    return {
-      path: `${this.config.target}/state-diagram.mmd`,
-      content: lines.join("\n"),
-      type: "mermaid"
-    };
-  }
-};
-function createStateDocsGenerator(config) {
-  return new StateDocsGenerator(config);
-}
-function generateDocs(schema, config) {
-  const generator = createStateDocsGenerator(config);
-  return generator.generateFromSchema(schema);
-}
-
 // src/integrations/tauri.ts
 function createMockTauriBridge() {
   const eventHandlers = /* @__PURE__ */ new Map();
@@ -1934,8 +1367,8 @@ function createMockTauriBridge() {
 function createTauriPraxisAdapter(options) {
   const { bridge, statePath = "praxis-state.json", eventsPath = "praxis-events.json" } = options;
   return {
-    async saveState(state2) {
-      const json = JSON.stringify(state2, null, 2);
+    async saveState(state) {
+      const json = JSON.stringify(state, null, 2);
       await bridge.fs.writeTextFile(statePath, json);
     },
     async loadState() {
@@ -2034,13 +1467,147 @@ function generateTauriConfig(config) {
     plugins: Object.fromEntries((config.plugins || []).map((p) => [p.name, p.config || {}]))
   };
 }
+
+// src/integrations/unified.ts
+async function createUnifiedApp(config) {
+  const { createPraxisEngine: createPraxisEngine2 } = await import("./engine-2DQBKBJC.js");
+  const { createInMemoryDB: createInMemoryDB2 } = await import("./adapter-K6DOX6XS.js");
+  const db = config.db || createInMemoryDB2();
+  const pluresdb = createPluresDBAdapter({
+    db,
+    registry: config.registry,
+    initialContext: config.initialContext
+  });
+  const engine = createPraxisEngine2({
+    initialContext: config.initialContext,
+    registry: config.registry
+  });
+  pluresdb.attachEngine(engine);
+  const disposers = [];
+  let unum;
+  let channel;
+  if (config.enableUnum) {
+    const fullIdentity = config.unumIdentity ? {
+      ...config.unumIdentity,
+      id: generateId(),
+      createdAt: Date.now()
+    } : void 0;
+    unum = await createUnumAdapter({
+      db,
+      identity: fullIdentity,
+      realtime: true
+    });
+    channel = await unum.createChannel(
+      config.unumIdentity?.name || "praxis-app",
+      []
+    );
+    const unumDisposer = attachUnumToEngine(engine, unum, channel.id);
+    disposers.push(unumDisposer);
+  }
+  let docs;
+  let generateDocs2;
+  if (config.enableDocs && config.docsConfig) {
+    docs = createStateDocsGenerator({
+      projectTitle: config.docsConfig.projectTitle,
+      target: config.docsConfig.target || "./docs"
+    });
+    generateDocs2 = () => {
+      const module = {
+        rules: config.registry.getAllRules(),
+        constraints: config.registry.getAllConstraints()
+      };
+      return docs.generateFromModule(module);
+    };
+  }
+  let canvas;
+  if (config.schema) {
+    canvas = schemaToCanvas(config.schema, { layout: "hierarchical" });
+  }
+  return {
+    engine,
+    pluresdb,
+    unum,
+    channel,
+    docs,
+    canvas,
+    generateDocs: generateDocs2,
+    dispose: () => {
+      pluresdb.dispose();
+      if (unum) {
+        unum.disconnect().catch((err) => {
+          console.warn("Warning: Error during Unum disconnect:", err);
+        });
+      }
+      for (const disposer of disposers) {
+        disposer();
+      }
+    }
+  };
+}
+async function attachAllIntegrations(engine, registry, options = {}) {
+  const { createInMemoryDB: createInMemoryDB2 } = await import("./adapter-K6DOX6XS.js");
+  const db = options.db || createInMemoryDB2();
+  const pluresdb = createPluresDBAdapter({
+    db,
+    registry,
+    initialContext: engine.getContext()
+  });
+  pluresdb.attachEngine(engine);
+  const disposers = [];
+  let unum;
+  let channel;
+  if (options.enableUnum) {
+    const fullIdentity = options.unumIdentity ? {
+      ...options.unumIdentity,
+      id: generateId(),
+      createdAt: Date.now()
+    } : void 0;
+    unum = await createUnumAdapter({
+      db,
+      identity: fullIdentity,
+      realtime: true
+    });
+    channel = await unum.createChannel(
+      options.unumIdentity?.name || "praxis-app",
+      []
+    );
+    const unumDisposer = attachUnumToEngine(engine, unum, channel.id);
+    disposers.push(unumDisposer);
+  }
+  let docs;
+  if (options.enableDocs && options.docsConfig) {
+    docs = createStateDocsGenerator({
+      projectTitle: options.docsConfig.projectTitle,
+      target: options.docsConfig.target || "./docs"
+    });
+  }
+  return {
+    pluresdb,
+    unum,
+    channel,
+    docs,
+    dispose: () => {
+      pluresdb.dispose();
+      if (unum) {
+        unum.disconnect().catch((err) => {
+          console.warn("Warning: Error during Unum disconnect:", err);
+        });
+      }
+      for (const disposer of disposers) {
+        disposer();
+      }
+    }
+  };
+}
 export {
   ActorManager,
+  ReactiveLogicEngine2 as FrameworkAgnosticReactiveEngine,
   InMemoryPraxisDB,
   LogicEngine,
   PRAXIS_PATHS,
   PRAXIS_PROTOCOL_VERSION,
   PluresDBGenerator,
+  PluresDBPraxisAdapter,
   PraxisDBStore,
   PraxisRegistry,
   PraxisSchemaRegistry,
@@ -2048,6 +1615,7 @@ export {
   RegistryIntrospector,
   StateDocsGenerator,
   TerminalAdapter,
+  attachAllIntegrations,
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
@@ -2055,20 +1623,24 @@ export {
   canvasToSchema,
   canvasToYaml,
   createCanvasEditor,
+  createReactiveEngine2 as createFrameworkAgnosticReactiveEngine,
   createInMemoryDB,
   createIntrospector,
   createMockExecutor,
   createMockTauriBridge,
+  createPluresDB,
   createPluresDBAdapter,
   createPluresDBGenerator,
   createPraxisDBStore,
   createPraxisEngine,
+  createReactiveEngine,
   createSchemaRegistry,
   createSchemaTemplate,
   createStateDocsGenerator,
   createTauriPraxisAdapter,
   createTerminalAdapter,
   createTimerActor,
+  createUnifiedApp,
   createUnumAdapter,
   defineConstraint,
   defineEvent,