@plures/praxis 1.1.2 → 1.2.0

package/dist/node/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,15 +30,375 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/core/protocol.ts
+var PRAXIS_PROTOCOL_VERSION;
+var init_protocol = __esm({
+  "src/core/protocol.ts"() {
+    "use strict";
+    PRAXIS_PROTOCOL_VERSION = "1.0.0";
+  }
+});
+
+// src/core/engine.ts
+var engine_exports = {};
+__export(engine_exports, {
+  LogicEngine: () => LogicEngine,
+  createPraxisEngine: () => createPraxisEngine
+});
+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 };
+}
+function createPraxisEngine(options) {
+  return new LogicEngine(options);
+}
+var LogicEngine;
+var init_engine = __esm({
+  "src/core/engine.ts"() {
+    "use strict";
+    init_protocol();
+    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
+        };
+      }
+    };
+  }
+});
+
+// src/core/pluresdb/adapter.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  InMemoryPraxisDB: () => InMemoryPraxisDB,
+  PluresDBPraxisAdapter: () => PluresDBPraxisAdapter,
+  createInMemoryDB: () => createInMemoryDB,
+  createPluresDB: () => createPluresDB
+});
+function createInMemoryDB() {
+  return new InMemoryPraxisDB();
+}
+function createPluresDB(config) {
+  return new PluresDBPraxisAdapter(config);
+}
+var InMemoryPraxisDB, PluresDBPraxisAdapter;
+var init_adapter = __esm({
+  "src/core/pluresdb/adapter.ts"() {
+    "use strict";
+    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();
+      }
+    };
+    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();
+      }
+    };
+  }
+});
+
 // src/index.ts
 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,
@@ -43,6 +406,7 @@ __export(src_exports, {
   RegistryIntrospector: () => RegistryIntrospector,
   StateDocsGenerator: () => StateDocsGenerator,
   TerminalAdapter: () => TerminalAdapter,
+  attachAllIntegrations: () => attachAllIntegrations,
   attachTauriToEngine: () => attachTauriToEngine,
   attachToEngine: () => attachToEngine,
   attachUnumToEngine: () => attachUnumToEngine,
@@ -50,20 +414,24 @@ __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,
   createTauriPraxisAdapter: () => createTauriPraxisAdapter,
   createTerminalAdapter: () => createTerminalAdapter,
   createTimerActor: () => createTimerActor,
+  createUnifiedApp: () => createUnifiedApp,
   createUnumAdapter: () => createUnumAdapter,
   defineConstraint: () => defineConstraint,
   defineEvent: () => defineEvent,
@@ -92,9 +460,7 @@ __export(src_exports, {
   validateWithGuardian: () => validateWithGuardian
 });
 module.exports = __toCommonJS(src_exports);
-
-// src/core/protocol.ts
-var PRAXIS_PROTOCOL_VERSION = "1.0.0";
+init_protocol();
 
 // src/core/rules.ts
 var PraxisRegistry = class {
@@ -167,244 +533,297 @@ var PraxisRegistry = class {
   }
 };
 
-// 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 {
-    }
+// src/index.ts
+init_engine();
+
+// src/core/reactive-engine.svelte.ts
+var $ = __toESM(require("svelte/internal/client"), 1);
+init_engine();
+var ReactiveLogicEngine = class {
+  #state = (
+    // Use Svelte's $state rune for automatic reactivity
+    $.state($.proxy({ context: {}, facts: [], meta: {} }))
+  );
+  get state() {
+    return $.get(this.#state);
   }
-  if (Array.isArray(value)) {
-    return [...value];
+  set state(value) {
+    $.set(this.#state, value, true);
   }
-  return { ...value };
-}
-var LogicEngine = class {
-  state;
-  registry;
+  _engine;
   constructor(options) {
-    this.registry = options.registry;
-    this.state = {
-      context: options.initialContext,
-      facts: options.initialFacts ?? [],
-      meta: options.initialMeta ?? {},
-      protocolVersion: PRAXIS_PROTOCOL_VERSION
-    };
+    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()
+      });
+    }
   }
   /**
-   * Get the current state (immutable copy)
+   * Access the reactive context.
+   * In Svelte 5 components, changes to this object will automatically trigger updates.
    */
-  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 context() {
+    return this.state.context;
   }
   /**
-   * Get the current context
+   * Access the reactive facts list.
    */
-  getContext() {
-    return safeClone(this.state.context);
+  get facts() {
+    return this.state.facts;
   }
   /**
-   * Get current facts
+   * Access the reactive metadata.
    */
-  getFacts() {
-    return [...this.state.facts];
+  get meta() {
+    return this.state.meta;
   }
   /**
-   * 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
+   * Apply a mutation to the state.
+   * Changes will automatically trigger Svelte reactivity.
+   * 
+   * @param mutator A function that receives the state and modifies it.
    */
-  step(events) {
-    const config = {
-      ruleIds: this.registry.getRuleIds(),
-      constraintIds: this.registry.getConstraintIds()
-    };
-    return this.stepWithConfig(events, config);
+  apply(mutator) {
+    mutator(this.state);
   }
   /**
-   * Process events with specific rule and constraint configuration.
-   *
+   * Process events through the logic engine and update reactive state.
+   * 
    * @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)
+  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);
   }
   /**
-   * Add facts directly (for exceptional cases).
-   * Generally, facts should be added through rules.
-   *
-   * @param facts Facts to add
+   * Create a reactive proxy that notifies subscribers on changes.
+   * Uses a WeakMap cache to avoid creating multiple proxies for the same object.
    */
-  addFacts(facts) {
-    this.state = {
-      ...this.state,
-      facts: [...this.state.facts, ...facts]
+  _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;
   }
   /**
-   * Clear all facts
+   * Notify all subscribers of state changes
    */
-  clearFacts() {
-    this.state = {
-      ...this.state,
-      facts: []
+  _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);
+      }
+    });
   }
   /**
-   * 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
-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.
-    $.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 {
@@ -1587,53 +2006,8 @@ 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/integrations/pluresdb.ts
+init_adapter();
 
 // src/core/pluresdb/schema-registry.ts
 function getSchemaPath(schemaName) {
@@ -3182,14 +3556,148 @@ 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 Promise.resolve().then(() => (init_engine(), engine_exports));
+  const { createInMemoryDB: createInMemoryDB2 } = await Promise.resolve().then(() => (init_adapter(), adapter_exports));
+  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 module2 = {
+        rules: config.registry.getAllRules(),
+        constraints: config.registry.getAllConstraints()
+      };
+      return docs.generateFromModule(module2);
+    };
+  }
+  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 Promise.resolve().then(() => (init_adapter(), adapter_exports));
+  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();
+      }
+    }
+  };
+}
 // 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,
@@ -3197,6 +3705,7 @@ function generateTauriConfig(config) {
   RegistryIntrospector,
   StateDocsGenerator,
   TerminalAdapter,
+  attachAllIntegrations,
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
@@ -3204,20 +3713,24 @@ function generateTauriConfig(config) {
   canvasToSchema,
   canvasToYaml,
   createCanvasEditor,
+  createFrameworkAgnosticReactiveEngine,
   createInMemoryDB,
   createIntrospector,
   createMockExecutor,
   createMockTauriBridge,
+  createPluresDB,
   createPluresDBAdapter,
   createPluresDBGenerator,
   createPraxisDBStore,
   createPraxisEngine,
+  createReactiveEngine,
   createSchemaRegistry,
   createSchemaTemplate,
   createStateDocsGenerator,
   createTauriPraxisAdapter,
   createTerminalAdapter,
   createTimerActor,
+  createUnifiedApp,
   createUnumAdapter,
   defineConstraint,
   defineEvent,