@plures/praxis 1.1.2 → 1.2.0

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

package/dist/browser/integrations/svelte.js

@@ -1,3 +1,9 @@
+import {
+  ReactiveLogicEngine,
+  createReactiveEngine
+} from "../chunk-LE2ZJYFC.js";
+import "../chunk-VOMLVI6V.js";
+
 // src/integrations/svelte.ts
 function createPraxisStore(engine) {
   let currentState = engine.getState();
@@ -288,10 +294,12 @@ function createHistoryEngine(engine, options = {}) {
 }
 export {
   HistoryStateManager,
+  ReactiveLogicEngine,
   createContextStore,
   createDerivedStore,
   createHistoryEngine,
   createPraxisStore,
+  createReactiveEngine,
   usePraxisContext,
   usePraxisEngine,
   usePraxisSubscription

package/dist/browser/{engine-BjdqxeXG.d.ts → reactive-engine.svelte-C9OpcTHf.d.ts}

@@ -330,4 +330,90 @@ declare class LogicEngine<TContext = unknown> {
  */
 declare function createPraxisEngine<TContext = unknown>(options: PraxisEngineOptions<TContext>): LogicEngine<TContext>;
 
-export { type ConstraintDescriptor as C, LogicEngine as L, type PraxisState as P, type RuleDescriptor as R, type PraxisEvent as a, PraxisRegistry as b, type PraxisFact as c, type RuleFn as d, type ConstraintFn as e, type PraxisModule as f, type PraxisDiagnostics as g, type PraxisStepConfig as h, type PraxisStepResult as i, type PraxisStepFn as j, PRAXIS_PROTOCOL_VERSION as k, type RuleId as l, type ConstraintId as m, type PraxisEngineOptions as n, createPraxisEngine as o };
+/**
+ * Praxis Reactive Logic Engine - Svelte 5 Implementation
+ *
+ * This version uses Svelte 5 runes ($state) for built-in reactivity.
+ * The state object is automatically reactive when used in Svelte components.
+ */
+
+interface ReactiveEngineOptions<TContext> {
+    initialContext: TContext;
+    initialFacts?: any[];
+    initialMeta?: Record<string, unknown>;
+    registry?: PraxisRegistry<TContext>;
+}
+/**
+ * Reactive Logic Engine using Svelte 5 runes.
+ * Combines the standard LogicEngine with reactive state management.
+ */
+declare class ReactiveLogicEngine<TContext extends object> {
+    state: {
+        context: TContext;
+        facts: any[];
+        meta: Record<string, unknown>;
+    };
+    private _engine;
+    constructor(options: ReactiveEngineOptions<TContext>);
+    /**
+     * Access the reactive context.
+     * In Svelte 5 components, changes to this object will automatically trigger updates.
+     */
+    get context(): TContext;
+    /**
+     * Access the reactive facts list.
+     */
+    get facts(): any[];
+    /**
+     * Access the reactive metadata.
+     */
+    get meta(): Record<string, unknown>;
+    /**
+     * Apply a mutation to the state.
+     * Changes will automatically trigger Svelte reactivity.
+     *
+     * @param mutator A function that receives the state and modifies it.
+     */
+    apply(mutator: (state: {
+        context: TContext;
+        facts: any[];
+        meta: Record<string, unknown>;
+    }) => void): void;
+    /**
+     * Process events through the logic engine and update reactive state.
+     *
+     * @param events Events to process
+     */
+    step(events: PraxisEvent[]): void;
+}
+/**
+ * Create a reactive logic engine with Svelte 5 runes.
+ *
+ * @param options Configuration options
+ * @returns A reactive logic engine instance
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { createReactiveEngine } from '@plures/praxis/svelte';
+ *
+ *   const engine = createReactiveEngine({
+ *     initialContext: { count: 0 },
+ *     registry
+ *   });
+ *
+ *   // Use $derived for computed values
+ *   const count = $derived(engine.context.count);
+ *   const doubled = $derived(engine.context.count * 2);
+ *
+ *   function increment() {
+ *     engine.step([Increment.create({ amount: 1 })]);
+ *   }
+ * </script>
+ *
+ * <button on:click={increment}>Count: {count}, Doubled: {doubled}</button>
+ * ```
+ */
+declare function createReactiveEngine<TContext extends object>(options: ReactiveEngineOptions<TContext>): ReactiveLogicEngine<TContext>;
+
+export { type ConstraintDescriptor as C, LogicEngine as L, type PraxisState as P, type RuleDescriptor as R, type PraxisEvent as a, PraxisRegistry as b, type PraxisFact as c, type RuleFn as d, type ConstraintFn as e, type PraxisModule as f, type PraxisDiagnostics as g, type PraxisStepConfig as h, type PraxisStepResult as i, type PraxisStepFn as j, PRAXIS_PROTOCOL_VERSION as k, type RuleId as l, type ConstraintId as m, type PraxisEngineOptions as n, createPraxisEngine as o, type ReactiveEngineOptions as p, ReactiveLogicEngine as q, createReactiveEngine as r };

package/dist/node/adapter-K6DOX6XS.js

@@ -0,0 +1,13 @@
+import {
+  InMemoryPraxisDB,
+  PluresDBPraxisAdapter,
+  createInMemoryDB,
+  createPluresDB
+} from "./chunk-JQ64KMLN.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  InMemoryPraxisDB,
+  PluresDBPraxisAdapter,
+  createInMemoryDB,
+  createPluresDB
+};

package/dist/node/chunk-JQ64KMLN.js

@@ -0,0 +1,141 @@
+// 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();
+}
+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);
+}
+
+export {
+  InMemoryPraxisDB,
+  createInMemoryDB,
+  PluresDBPraxisAdapter,
+  createPluresDB
+};

package/dist/node/chunk-LE2ZJYFC.js

@@ -0,0 +1,154 @@
+import {
+  createPraxisEngine
+} from "./chunk-VOMLVI6V.js";
+
+// 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/reactive-engine.svelte.ts
+import * as $ from "svelte/internal/client";
+var ReactiveLogicEngine = class {
+  #state = (
+    // Use Svelte's $state rune for automatic reactivity
+    $.state($.proxy({ context: {}, facts: [], meta: {} }))
+  );
+  get state() {
+    return $.get(this.#state);
+  }
+  set state(value) {
+    $.set(this.#state, value, true);
+  }
+  _engine;
+  constructor(options) {
+    this.state.context = options.initialContext;
+    this.state.facts = options.initialFacts ?? [];
+    this.state.meta = options.initialMeta ?? {};
+    if (options.registry) {
+      this._engine = createPraxisEngine({
+        initialContext: options.initialContext,
+        registry: options.registry
+      });
+    } else {
+      this._engine = createPraxisEngine({
+        initialContext: options.initialContext,
+        registry: new PraxisRegistry()
+      });
+    }
+  }
+  /**
+   * Access the reactive context.
+   * In Svelte 5 components, changes to this object will automatically trigger updates.
+   */
+  get context() {
+    return this.state.context;
+  }
+  /**
+   * Access the reactive facts list.
+   */
+  get facts() {
+    return this.state.facts;
+  }
+  /**
+   * Access the reactive metadata.
+   */
+  get meta() {
+    return this.state.meta;
+  }
+  /**
+   * Apply a mutation to the state.
+   * Changes will automatically trigger Svelte reactivity.
+   * 
+   * @param mutator A function that receives the state and modifies it.
+   */
+  apply(mutator) {
+    mutator(this.state);
+  }
+  /**
+   * Process events through the logic engine and update reactive state.
+   * 
+   * @param events Events to process
+   */
+  step(events) {
+    const result = this._engine.step(events);
+    this.state.context = result.state.context;
+    this.state.facts = result.state.facts;
+    this.state.meta = result.state.meta ?? {};
+  }
+};
+function createReactiveEngine(options) {
+  return new ReactiveLogicEngine(options);
+}
+
+export {
+  PraxisRegistry,
+  ReactiveLogicEngine,
+  createReactiveEngine
+};