@plures/praxis 1.1.3 → 1.2.0

package/dist/browser/index.js

@@ -1,11 +1,19 @@
 import {
-  LogicEngine,
-  PRAXIS_PROTOCOL_VERSION,
   PraxisRegistry,
   ReactiveLogicEngine,
-  createPraxisEngine,
   createReactiveEngine
-} from "./chunk-R45WXWKH.js";
+} from "./chunk-LE2ZJYFC.js";
+import {
+  LogicEngine,
+  PRAXIS_PROTOCOL_VERSION,
+  createPraxisEngine
+} from "./chunk-VOMLVI6V.js";
+import {
+  InMemoryPraxisDB,
+  PluresDBPraxisAdapter,
+  createInMemoryDB,
+  createPluresDB
+} from "./chunk-JQ64KMLN.js";
 
 // src/core/reactive-engine.ts
 var ReactiveLogicEngine2 = class _ReactiveLogicEngine {
@@ -1148,141 +1156,6 @@ 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();
-}
-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) {
   return `${PRAXIS_PATHS.SCHEMAS}/${schemaName}`;
@@ -2830,6 +2703,138 @@ 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 import("./engine-YJZV4SLD.js");
+  const { createInMemoryDB: createInMemoryDB2 } = await import("./adapter-TM4IS5KT.js");
+  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 module = {
+        rules: config.registry.getAllRules(),
+        constraints: config.registry.getAllConstraints()
+      };
+      return docs.generateFromModule(module);
+    };
+  }
+  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 import("./adapter-TM4IS5KT.js");
+  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();
+      }
+    }
+  };
+}
 export {
   ActorManager,
   ReactiveLogicEngine2 as FrameworkAgnosticReactiveEngine,
@@ -2845,6 +2850,7 @@ export {
   ReactiveLogicEngine,
   RegistryIntrospector,
   StateDocsGenerator,
+  attachAllIntegrations,
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
@@ -2868,6 +2874,7 @@ export {
   createStateDocsGenerator,
   createTauriPraxisAdapter,
   createTimerActor,
+  createUnifiedApp,
   createUnumAdapter,
   defineConstraint,
   defineEvent,

package/dist/browser/integrations/svelte.js

@@ -1,7 +1,8 @@
 import {
   ReactiveLogicEngine,
   createReactiveEngine
-} from "../chunk-R45WXWKH.js";
+} from "../chunk-LE2ZJYFC.js";
+import "../chunk-VOMLVI6V.js";
 
 // src/integrations/svelte.ts
 function createPraxisStore(engine) {

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
+};