@plures/praxis 1.1.1 → 1.1.3

package/dist/browser/index.js

@@ -1,315 +1,225 @@
-// 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());
-  }
-};
+import {
+  LogicEngine,
+  PRAXIS_PROTOCOL_VERSION,
+  PraxisRegistry,
+  ReactiveLogicEngine,
+  createPraxisEngine,
+  createReactiveEngine
+} from "./chunk-R45WXWKH.js";
 
-// 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
+      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 state (immutable copy)
+   * Create a reactive proxy that notifies subscribers on changes.
+   * Uses a WeakMap cache to avoid creating multiple proxies for the same object.
    */
-  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
+  _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 proxy = new Proxy(target, handler);
+    this._proxyCache.set(target, proxy);
+    return proxy;
   }
   /**
-   * Get the current context
-   */
-  getContext() {
-    return safeClone(this.state.context);
-  }
-  /**
-   * Get current facts
+   * Notify all subscribers of state changes
    */
-  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 }
-        });
-      }
+  _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 {
@@ -398,7 +308,7 @@ var ActorManager = class {
   /**
    * Notify active actors of a state change
    */
-  async notifyStateChange(state2) {
+  async notifyStateChange(state) {
     if (!this.engine) {
       return;
     }
@@ -406,7 +316,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);
         }
@@ -1147,14 +1057,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") {
@@ -1188,7 +1098,7 @@ var PraxisDBStore = class {
    */
   async triggerRulesForEvents(events) {
     const rules = this.registry.getAllRules();
-    const state2 = {
+    const state = {
       context: this.context,
       facts: [],
       meta: {}
@@ -1196,7 +1106,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);
@@ -1285,6 +1195,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) {
@@ -2733,8 +2730,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() {
@@ -2835,11 +2832,13 @@ function generateTauriConfig(config) {
 }
 export {
   ActorManager,
+  ReactiveLogicEngine2 as FrameworkAgnosticReactiveEngine,
   InMemoryPraxisDB,
   LogicEngine,
   PRAXIS_PATHS,
   PRAXIS_PROTOCOL_VERSION,
   PluresDBGenerator,
+  PluresDBPraxisAdapter,
   PraxisDBStore,
   PraxisRegistry,
   PraxisSchemaRegistry,
@@ -2853,13 +2852,16 @@ export {
   canvasToSchema,
   canvasToYaml,
   createCanvasEditor,
+  createReactiveEngine2 as createFrameworkAgnosticReactiveEngine,
   createInMemoryDB,
   createIntrospector,
   createMockTauriBridge,
+  createPluresDB,
   createPluresDBAdapter,
   createPluresDBGenerator,
   createPraxisDBStore,
   createPraxisEngine,
+  createReactiveEngine,
   createSchema,
   createSchemaRegistry,
   createSchemaTemplate,

package/dist/browser/integrations/svelte.d.ts

@@ -1,4 +1,5 @@
-import { L as LogicEngine, P as PraxisState, a as PraxisEvent } from '../engine-BjdqxeXG.js';
+import { L as LogicEngine, P as PraxisState, a as PraxisEvent } from '../reactive-engine.svelte-C9OpcTHf.js';
+export { p as ReactiveEngineOptions, q as ReactiveLogicEngine, r as createReactiveEngine } from '../reactive-engine.svelte-C9OpcTHf.js';
 
 /**
  * Svelte v5 Integration
@@ -9,6 +10,7 @@ import { L as LogicEngine, P as PraxisState, a as PraxisEvent } from '../engine-
  * Features:
  * - Store-based API for backward compatibility
  * - Runes-based composables for Svelte 5
+ * - createReactiveEngine for easy reactive engine setup
  * - Snapshot support for time-travel debugging
  * - History state pattern implementation
  * - Automatic cleanup and subscription management