@plures/praxis 1.1.3 → 1.2.0

package/dist/node/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,364 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/core/protocol.ts
+var PRAXIS_PROTOCOL_VERSION;
+var init_protocol = __esm({
+  "src/core/protocol.ts"() {
+    "use strict";
+    PRAXIS_PROTOCOL_VERSION = "1.0.0";
+  }
+});
+
+// src/core/engine.ts
+var engine_exports = {};
+__export(engine_exports, {
+  LogicEngine: () => LogicEngine,
+  createPraxisEngine: () => createPraxisEngine
+});
+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 };
+}
+function createPraxisEngine(options) {
+  return new LogicEngine(options);
+}
+var LogicEngine;
+var init_engine = __esm({
+  "src/core/engine.ts"() {
+    "use strict";
+    init_protocol();
+    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
+        };
+      }
+    };
+  }
+});
+
+// src/core/pluresdb/adapter.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  InMemoryPraxisDB: () => InMemoryPraxisDB,
+  PluresDBPraxisAdapter: () => PluresDBPraxisAdapter,
+  createInMemoryDB: () => createInMemoryDB,
+  createPluresDB: () => createPluresDB
+});
+function createInMemoryDB() {
+  return new InMemoryPraxisDB();
+}
+function createPluresDB(config) {
+  return new PluresDBPraxisAdapter(config);
+}
+var InMemoryPraxisDB, PluresDBPraxisAdapter;
+var init_adapter = __esm({
+  "src/core/pluresdb/adapter.ts"() {
+    "use strict";
+    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();
+      }
+    };
+    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();
+      }
+    };
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -45,6 +406,7 @@ __export(src_exports, {
   RegistryIntrospector: () => RegistryIntrospector,
   StateDocsGenerator: () => StateDocsGenerator,
   TerminalAdapter: () => TerminalAdapter,
+  attachAllIntegrations: () => attachAllIntegrations,
   attachTauriToEngine: () => attachTauriToEngine,
   attachToEngine: () => attachToEngine,
   attachUnumToEngine: () => attachUnumToEngine,
@@ -69,6 +431,7 @@ __export(src_exports, {
   createTauriPraxisAdapter: () => createTauriPraxisAdapter,
   createTerminalAdapter: () => createTerminalAdapter,
   createTimerActor: () => createTimerActor,
+  createUnifiedApp: () => createUnifiedApp,
   createUnumAdapter: () => createUnumAdapter,
   defineConstraint: () => defineConstraint,
   defineEvent: () => defineEvent,
@@ -97,9 +460,7 @@ __export(src_exports, {
   validateWithGuardian: () => validateWithGuardian
 });
 module.exports = __toCommonJS(src_exports);
-
-// src/core/protocol.ts
-var PRAXIS_PROTOCOL_VERSION = "1.0.0";
+init_protocol();
 
 // src/core/rules.ts
 var PraxisRegistry = class {
@@ -172,197 +533,12 @@ var PraxisRegistry = class {
   }
 };
 
-// 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/index.ts
+init_engine();
 
 // src/core/reactive-engine.svelte.ts
 var $ = __toESM(require("svelte/internal/client"), 1);
+init_engine();
 var ReactiveLogicEngine = class {
   #state = (
     // Use Svelte's $state rune for automatic reactivity
@@ -1830,140 +2006,8 @@ 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/integrations/pluresdb.ts
+init_adapter();
 
 // src/core/pluresdb/schema-registry.ts
 function getSchemaPath(schemaName) {
@@ -3512,6 +3556,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 Promise.resolve().then(() => (init_engine(), engine_exports));
+  const { createInMemoryDB: createInMemoryDB2 } = await Promise.resolve().then(() => (init_adapter(), adapter_exports));
+  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 module2 = {
+        rules: config.registry.getAllRules(),
+        constraints: config.registry.getAllConstraints()
+      };
+      return docs.generateFromModule(module2);
+    };
+  }
+  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 Promise.resolve().then(() => (init_adapter(), adapter_exports));
+  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();
+      }
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActorManager,
@@ -3529,6 +3705,7 @@ function generateTauriConfig(config) {
   RegistryIntrospector,
   StateDocsGenerator,
   TerminalAdapter,
+  attachAllIntegrations,
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
@@ -3553,6 +3730,7 @@ function generateTauriConfig(config) {
   createTauriPraxisAdapter,
   createTerminalAdapter,
   createTimerActor,
+  createUnifiedApp,
   createUnumAdapter,
   defineConstraint,
   defineEvent,