@plures/praxis 1.1.1 → 1.1.3

package/dist/node/integrations/svelte.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,21 +17,372 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/integrations/svelte.ts
 var svelte_exports = {};
 __export(svelte_exports, {
   HistoryStateManager: () => HistoryStateManager,
+  ReactiveLogicEngine: () => ReactiveLogicEngine,
   createContextStore: () => createContextStore,
   createDerivedStore: () => createDerivedStore,
   createHistoryEngine: () => createHistoryEngine,
   createPraxisStore: () => createPraxisStore,
+  createReactiveEngine: () => createReactiveEngine,
   usePraxisContext: () => usePraxisContext,
   usePraxisEngine: () => usePraxisEngine,
   usePraxisSubscription: () => usePraxisSubscription
 });
 module.exports = __toCommonJS(svelte_exports);
+
+// src/core/reactive-engine.svelte.ts
+var $ = __toESM(require("svelte/internal/client"), 1);
+
+// 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(module2) {
+    for (const rule of module2.rules) {
+      this.registerRule(rule);
+    }
+    for (const constraint of module2.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/protocol.ts
+var PRAXIS_PROTOCOL_VERSION = "1.0.0";
+
+// 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;
+  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
+    };
+  }
+};
+function createPraxisEngine(options) {
+  return new LogicEngine(options);
+}
+
+// src/core/reactive-engine.svelte.ts
+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);
+}
+
+// src/integrations/svelte.ts
 function createPraxisStore(engine) {
   let currentState = engine.getState();
   const subscribers = /* @__PURE__ */ new Set();
@@ -198,14 +551,14 @@ var HistoryStateManager = class {
   /**
    * Record a new history entry
    */
-  record(state, events, label) {
+  record(state2, events, label) {
     if (this.currentIndex < this.history.length - 1) {
       this.history = this.history.slice(0, this.currentIndex + 1);
     }
     this.history.push({
       id: `history-${++this.idCounter}`,
       timestamp: Date.now(),
-      state,
+      state: state2,
       events,
       label
     });
@@ -320,10 +673,12 @@ function createHistoryEngine(engine, options = {}) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HistoryStateManager,
+  ReactiveLogicEngine,
   createContextStore,
   createDerivedStore,
   createHistoryEngine,
   createPraxisStore,
+  createReactiveEngine,
   usePraxisContext,
   usePraxisEngine,
   usePraxisSubscription

package/dist/node/integrations/svelte.d.cts

@@ -1,4 +1,5 @@
-import { L as LogicEngine } from '../engine-CVJobhHm.cjs';
+import { L as LogicEngine } from '../reactive-engine.svelte-1M4m_C_v.cjs';
+export { a as ReactiveEngineOptions, R as ReactiveLogicEngine, c as createReactiveEngine } from '../reactive-engine.svelte-1M4m_C_v.cjs';
 import { P as PraxisState, a as PraxisEvent } from '../protocol-Qek7ebBl.cjs';
 
 /**
@@ -10,6 +11,7 @@ import { P as PraxisState, a as PraxisEvent } from '../protocol-Qek7ebBl.cjs';
  * 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/node/integrations/svelte.d.ts

@@ -1,4 +1,5 @@
-import { L as LogicEngine } from '../engine-1iqLe6_P.js';
+import { L as LogicEngine } from '../reactive-engine.svelte-ChNFn4Hj.js';
+export { a as ReactiveEngineOptions, R as ReactiveLogicEngine, c as createReactiveEngine } from '../reactive-engine.svelte-ChNFn4Hj.js';
 import { P as PraxisState, a as PraxisEvent } from '../protocol-Qek7ebBl.js';
 
 /**
@@ -10,6 +11,7 @@ import { P as PraxisState, a as PraxisEvent } from '../protocol-Qek7ebBl.js';
  * 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/node/integrations/svelte.js

@@ -1,3 +1,7 @@
+import {
+  ReactiveLogicEngine,
+  createReactiveEngine
+} from "../chunk-R45WXWKH.js";
 import "../chunk-QGM4M3NI.js";
 
 // src/integrations/svelte.ts
@@ -290,10 +294,12 @@ function createHistoryEngine(engine, options = {}) {
 }
 export {
   HistoryStateManager,
+  ReactiveLogicEngine,
   createContextStore,
   createDerivedStore,
   createHistoryEngine,
   createPraxisStore,
+  createReactiveEngine,
   usePraxisContext,
   usePraxisEngine,
   usePraxisSubscription

package/dist/node/{engine-CVJobhHm.d.cts → reactive-engine.svelte-1M4m_C_v.d.cts}

@@ -211,4 +211,90 @@ declare class LogicEngine<TContext = unknown> {
  */
 declare function createPraxisEngine<TContext = unknown>(options: PraxisEngineOptions<TContext>): LogicEngine<TContext>;
 
-export { type ConstraintDescriptor as C, LogicEngine as L, PraxisRegistry as P, type RuleDescriptor as R, type RuleFn as a, type ConstraintFn as b, type PraxisModule as c, type RuleId as d, type ConstraintId as e, type PraxisEngineOptions as f, createPraxisEngine as g };
+/**
+ * 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, PraxisRegistry as P, ReactiveLogicEngine as R, type ReactiveEngineOptions as a, type RuleDescriptor as b, createReactiveEngine as c, type RuleFn as d, type ConstraintFn as e, type PraxisModule as f, type RuleId as g, type ConstraintId as h, type PraxisEngineOptions as i, createPraxisEngine as j };

package/dist/node/{engine-1iqLe6_P.d.ts → reactive-engine.svelte-ChNFn4Hj.d.ts}

@@ -211,4 +211,90 @@ declare class LogicEngine<TContext = unknown> {
  */
 declare function createPraxisEngine<TContext = unknown>(options: PraxisEngineOptions<TContext>): LogicEngine<TContext>;
 
-export { type ConstraintDescriptor as C, LogicEngine as L, PraxisRegistry as P, type RuleDescriptor as R, type RuleFn as a, type ConstraintFn as b, type PraxisModule as c, type RuleId as d, type ConstraintId as e, type PraxisEngineOptions as f, createPraxisEngine as g };
+/**
+ * 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, PraxisRegistry as P, ReactiveLogicEngine as R, type ReactiveEngineOptions as a, type RuleDescriptor as b, createReactiveEngine as c, type RuleFn as d, type ConstraintFn as e, type PraxisModule as f, type RuleId as g, type ConstraintId as h, type PraxisEngineOptions as i, createPraxisEngine as j };