@plures/praxis 1.1.2 → 1.1.3

package/dist/browser/integrations/svelte.js

@@ -1,3 +1,8 @@
+import {
+  ReactiveLogicEngine,
+  createReactiveEngine
+} from "../chunk-R45WXWKH.js";
+
 // src/integrations/svelte.ts
 function createPraxisStore(engine) {
   let currentState = engine.getState();
@@ -288,10 +293,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/chunk-R45WXWKH.js

@@ -0,0 +1,345 @@
+// 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;
+  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
+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 {
+  PRAXIS_PROTOCOL_VERSION,
+  PraxisRegistry,
+  LogicEngine,
+  createPraxisEngine,
+  ReactiveLogicEngine,
+  createReactiveEngine
+};

package/dist/node/components/index.d.cts

@@ -1,5 +1,5 @@
-import { T as TerminalAdapter } from '../terminal-adapter-XLtCjjb_.cjs';
-export { c as createTerminalAdapter } from '../terminal-adapter-XLtCjjb_.cjs';
+import { T as TerminalAdapter } from '../terminal-adapter-CDzxoLKR.cjs';
+export { c as createTerminalAdapter } from '../terminal-adapter-CDzxoLKR.cjs';
 import '../schema.cjs';
 
 /**

package/dist/node/components/index.d.ts

@@ -1,5 +1,5 @@
-import { T as TerminalAdapter } from '../terminal-adapter-07HGftGQ.js';
-export { c as createTerminalAdapter } from '../terminal-adapter-07HGftGQ.js';
+import { T as TerminalAdapter } from '../terminal-adapter-CWka-yL8.js';
+export { c as createTerminalAdapter } from '../terminal-adapter-CWka-yL8.js';
 import '../schema.js';
 
 /**