@plures/praxis 1.1.3 → 1.2.10

package/dist/browser/index.d.ts

@@ -1,5 +1,6 @@
-import { L as LogicEngine, P as PraxisState, a as PraxisEvent, b as PraxisRegistry, R as RuleDescriptor, C as ConstraintDescriptor, c as PraxisFact, d as RuleFn, e as ConstraintFn, f as PraxisModule } from './reactive-engine.svelte-C9OpcTHf.js';
-export { m as ConstraintId, k as PRAXIS_PROTOCOL_VERSION, g as PraxisDiagnostics, n as PraxisEngineOptions, h as PraxisStepConfig, j as PraxisStepFn, i as PraxisStepResult, p as ReactiveEngineOptions, q as ReactiveLogicEngine, l as RuleId, o as createPraxisEngine, r as createReactiveEngine } from './reactive-engine.svelte-C9OpcTHf.js';
+import { L as LogicEngine, P as PraxisState, a as PraxisEvent, b as PraxisRegistry, R as RuleDescriptor, C as ConstraintDescriptor, c as PraxisFact, d as RuleFn, e as Contract, f as ConstraintFn, g as PraxisModule } from './reactive-engine.svelte-9aS0kTa8.js';
+export { n as ConstraintId, l as PRAXIS_PROTOCOL_VERSION, h as PraxisDiagnostics, o as PraxisEngineOptions, i as PraxisStepConfig, k as PraxisStepFn, j as PraxisStepResult, q as ReactiveEngineOptions, r as ReactiveLogicEngine, m as RuleId, p as createPraxisEngine, s as createReactiveEngine } from './reactive-engine.svelte-9aS0kTa8.js';
+import { LocalFirstOptions } from '@plures/pluresdb/local-first';
 
 /**
  * Praxis Reactive Logic Engine
@@ -434,6 +435,7 @@ interface DefineRuleOptions<TContext = unknown> {
     id: string;
     description: string;
     impl: RuleFn<TContext>;
+    contract?: Contract;
     meta?: Record<string, unknown>;
 }
 /**
@@ -460,6 +462,7 @@ interface DefineConstraintOptions<TContext = unknown> {
     id: string;
     description: string;
     impl: ConstraintFn<TContext>;
+    contract?: Contract;
     meta?: Record<string, unknown>;
 }
 /**
@@ -943,6 +946,7 @@ declare function validateForGeneration(schema: PraxisSchema): ValidationResult;
  * Provides a minimal adapter layer for PluresDB integration.
  * This module defines the core interface and an in-memory implementation.
  */
+
 /**
  * Function to unsubscribe from a watch
  */
@@ -1013,7 +1017,10 @@ declare function createInMemoryDB(): InMemoryPraxisDB;
  */
 type PluresDBInstance = {
     get(key: string): Promise<any>;
-    put(key: string, value: any): Promise<void>;
+    put(key: string, value: any): Promise<any>;
+    delete?(key: string): Promise<void>;
+    list?(): Promise<any[]>;
+    close?(): Promise<void>;
 };
 /**
  * Configuration options for PluresDBPraxisAdapter
@@ -1055,7 +1062,7 @@ declare class PluresDBPraxisAdapter implements PraxisDB {
  *
  * @example
  * ```typescript
- * import { PluresNode } from 'pluresdb';
+ * import { PluresNode } from '@plures/pluresdb';
  * import { createPluresDB } from '@plures/praxis';
  *
  * const pluresdb = new PluresNode({ autoStart: true });
@@ -1075,6 +1082,26 @@ declare class PluresDBPraxisAdapter implements PraxisDB {
  * ```
  */
 declare function createPluresDB(config: PluresDBAdapterConfig | PluresDBInstance): PluresDBPraxisAdapter;
+/**
+ * Options for creating a local-first PluresDB adapter using the unified API
+ */
+interface PraxisLocalFirstOptions extends LocalFirstOptions {
+    /** Optional polling interval override for watch semantics (ms). Defaults to 1000ms. */
+    pollInterval?: number;
+}
+/**
+ * Create a PraxisDB adapter backed by PluresDB's unified local-first API.
+ *
+ * This will auto-detect the best backend (WASM/Tauri/IPC/network) unless a mode is provided.
+ * Uses dynamic import to avoid bundling the local-first module in environments that don't need it.
+ *
+ * @example
+ * ```typescript
+ * const db = await createPraxisLocalFirst({ mode: 'auto' });
+ * await db.set('/_praxis/facts/user/1', { id: '1', name: 'Alice' });
+ * ```
+ */
+declare function createPraxisLocalFirst(options?: PraxisLocalFirstOptions): Promise<PluresDBPraxisAdapter>;
 
 /**
  * PraxisDB Store
@@ -3161,4 +3188,133 @@ declare function attachTauriToEngine<TContext>(engine: LogicEngine<TContext>, ad
  */
 declare function generateTauriConfig(config: TauriAppConfig): Record<string, unknown>;
 
-export { type ActivityState, type Actor, ActorManager, type CanvasDocument, type CanvasEdge, type CanvasEdgeStyle, type CanvasEditorConfig, type CanvasNode, type CanvasNodeStyle, type ComponentDefinition, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, type EventDefinition$1 as EventDefinition, type EventStreamEntry, type FactDefinition$1 as FactDefinition, ReactiveLogicEngine as FrameworkAgnosticReactiveEngine, type ReactiveEngineOptions as FrameworkAgnosticReactiveEngineOptions, type GeneratedDoc, type GeneratedPluresDBFile, type GraphEdge, type GuardianError, type GuardianResult, type GuardianWarning, InMemoryPraxisDB, type LifecycleState, type LoaderOptions, type LoaderResult, type LogicDefinition, LogicEngine, type ModelDefinition, type NodeBindings, type NodeDefinition, type OrchestrationDefinition, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterConfig, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, type PluresDBInstance, PluresDBPraxisAdapter, type PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, PraxisEvent, PraxisFact, PraxisModule, PraxisRegistry, type PraxisSchema, PraxisSchemaRegistry, PraxisState, type RegistryGraph, RegistryIntrospector, type RegistrySchema, type RegistryStats, RuleDescriptor, RuleFn, type RuleNode, type RuleSchema, type StateChangeCallback, type StateDoc, type StateDocsConfig, StateDocsGenerator, type StateMachineDoc, type StoredSchema, type TauriAppConfig, type TauriBridge, type TauriCommand, type TauriEvent, type TauriFS, type TauriFileEntry, type TauriMenuItem, type TauriNotification, type TauriNotificationOptions, type TauriPlugin, type TauriPraxisAdapter, type TauriSecurityConfig, type TauriTray, type TauriUpdateConfig, type TauriUpdateInfo, type TauriWindowConfig, type TerminalNodeProps, type TransitionDoc, type UnsubscribeFn, type UnumAdapter, type UnumAdapterConfig, type UnumChannel, type UnumIdentity, type UnumMessage, type UnumStore, type ValidationError, type ValidationResult, attachTauriToEngine, attachToEngine, attachUnumToEngine, canvasToMermaid, canvasToSchema, canvasToYaml, createCanvasEditor, createReactiveEngine as createFrameworkAgnosticReactiveEngine, createInMemoryDB, createIntrospector, createMockTauriBridge, createPluresDB, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createSchema, createSchemaRegistry, createSchemaTemplate, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUnumAdapter, defineConstraint, defineEvent, defineFact, defineModule, defineRule, filterEvents, filterFacts, findEvent, findFact, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, loadSchemaFromJson, loadSchemaFromYaml, registerSchema, schemaToCanvas, validateForGeneration, validateSchema, validateWithGuardian };
+/**
+ * Unified Integration Helpers
+ *
+ * Convenience functions for setting up Praxis with all ecosystem integrations
+ * (PluresDB, Unum, State-Docs, CodeCanvas) in a single call.
+ */
+
+/**
+ * Configuration for unified Praxis application
+ */
+interface UnifiedAppConfig<TContext = unknown> {
+    /** Praxis registry with rules and constraints */
+    registry: PraxisRegistry<TContext>;
+    /** Initial context for the engine */
+    initialContext: TContext;
+    /** PluresDB instance (if not provided, creates in-memory DB) */
+    db?: PraxisDB;
+    /** Enable Unum for distributed communication */
+    enableUnum?: boolean;
+    /** Unum identity configuration (without id and createdAt which are auto-generated) */
+    unumIdentity?: Omit<UnumIdentity, 'id' | 'createdAt'>;
+    /** Enable State-Docs documentation generation */
+    enableDocs?: boolean;
+    /** State-Docs configuration */
+    docsConfig?: {
+        projectTitle: string;
+        target?: string;
+    };
+    /** Praxis schema for CodeCanvas integration */
+    schema?: PraxisSchema;
+}
+/**
+ * Unified application instance with all integrations
+ */
+interface UnifiedApp<TContext = unknown> {
+    /** Praxis logic engine */
+    engine: LogicEngine<TContext>;
+    /** PluresDB adapter for persistence */
+    pluresdb: PluresDBAdapter<TContext>;
+    /** Unum adapter for distributed communication (if enabled) */
+    unum?: UnumAdapter;
+    /** Default Unum channel (if Unum enabled) */
+    channel?: UnumChannel;
+    /** State-Docs generator (if enabled) */
+    docs?: StateDocsGenerator;
+    /** CodeCanvas document (if schema provided) */
+    canvas?: CanvasDocument;
+    /** Generate documentation from current state */
+    generateDocs?: () => GeneratedDoc[];
+    /** Cleanup function to dispose all integrations */
+    dispose: () => void;
+}
+/**
+ * Create a unified Praxis application with all integrations
+ *
+ * This is a convenience function that sets up:
+ * - Praxis logic engine
+ * - PluresDB for persistence (auto-attaches to engine)
+ * - Unum for distributed communication (optional)
+ * - State-Docs for documentation generation (optional)
+ * - CodeCanvas for visual schema editing (optional)
+ *
+ * @example
+ * ```typescript
+ * import { createUnifiedApp } from '@plures/praxis';
+ *
+ * const app = await createUnifiedApp({
+ *   registry: myRegistry,
+ *   initialContext: { count: 0 },
+ *   enableUnum: true,
+ *   unumIdentity: { name: 'node-1' },
+ *   enableDocs: true,
+ *   docsConfig: { projectTitle: 'My App' },
+ *   schema: mySchema,
+ * });
+ *
+ * // Use the engine
+ * app.engine.step([myEvent]);
+ *
+ * // Broadcast to other nodes
+ * if (app.channel) {
+ *   await app.unum?.broadcastEvent(app.channel.id, myEvent);
+ * }
+ *
+ * // Generate documentation
+ * const docs = app.generateDocs?.();
+ *
+ * // Cleanup
+ * app.dispose();
+ * ```
+ */
+declare function createUnifiedApp<TContext = unknown>(config: UnifiedAppConfig<TContext>): Promise<UnifiedApp<TContext>>;
+/**
+ * Attach all available integrations to an existing Praxis engine
+ *
+ * This is useful when you already have an engine and want to add integrations.
+ *
+ * @example
+ * ```typescript
+ * import { createPraxisEngine, attachAllIntegrations } from '@plures/praxis';
+ *
+ * const engine = createPraxisEngine({ initialContext: {}, registry });
+ *
+ * const integrations = await attachAllIntegrations(engine, registry, {
+ *   enableUnum: true,
+ *   enableDocs: true,
+ * });
+ *
+ * // Later cleanup
+ * integrations.dispose();
+ * ```
+ */
+declare function attachAllIntegrations<TContext = unknown>(engine: LogicEngine<TContext>, registry: PraxisRegistry<TContext>, options?: {
+    db?: PraxisDB;
+    enableUnum?: boolean;
+    unumIdentity?: Omit<UnumIdentity, 'id' | 'createdAt'>;
+    enableDocs?: boolean;
+    docsConfig?: {
+        projectTitle: string;
+        target?: string;
+    };
+}): Promise<{
+    pluresdb: PluresDBAdapter<TContext>;
+    unum?: UnumAdapter;
+    channel?: UnumChannel;
+    docs?: StateDocsGenerator;
+    dispose: () => void;
+}>;
+
+export { type ActivityState, type Actor, ActorManager, type CanvasDocument, type CanvasEdge, type CanvasEdgeStyle, type CanvasEditorConfig, type CanvasNode, type CanvasNodeStyle, type ComponentDefinition, ConstraintDescriptor, ConstraintFn, type ConstraintNode, type ConstraintSchema, type DefineConstraintOptions, type DefineModuleOptions, type DefineRuleOptions, type EventDefinition$1 as EventDefinition, type EventStreamEntry, type FactDefinition$1 as FactDefinition, ReactiveLogicEngine as FrameworkAgnosticReactiveEngine, type ReactiveEngineOptions as FrameworkAgnosticReactiveEngineOptions, type GeneratedDoc, type GeneratedPluresDBFile, type GraphEdge, type GuardianError, type GuardianResult, type GuardianWarning, InMemoryPraxisDB, type LifecycleState, type LoaderOptions, type LoaderResult, type LogicDefinition, LogicEngine, type ModelDefinition, type NodeBindings, type NodeDefinition, type OrchestrationDefinition, PRAXIS_PATHS, type PluresDBAdapter, type PluresDBAdapterConfig, type PluresDBAdapterOptions, PluresDBGenerator, type PluresDBGeneratorOptions, type PluresDBInstance, PluresDBPraxisAdapter, type PraxisDB, PraxisDBStore, type PraxisDBStoreOptions, PraxisEvent, PraxisFact, type PraxisLocalFirstOptions, PraxisModule, PraxisRegistry, type PraxisSchema, PraxisSchemaRegistry, PraxisState, type RegistryGraph, RegistryIntrospector, type RegistrySchema, type RegistryStats, RuleDescriptor, RuleFn, type RuleNode, type RuleSchema, type StateChangeCallback, type StateDoc, type StateDocsConfig, StateDocsGenerator, type StateMachineDoc, type StoredSchema, type TauriAppConfig, type TauriBridge, type TauriCommand, type TauriEvent, type TauriFS, type TauriFileEntry, type TauriMenuItem, type TauriNotification, type TauriNotificationOptions, type TauriPlugin, type TauriPraxisAdapter, type TauriSecurityConfig, type TauriTray, type TauriUpdateConfig, type TauriUpdateInfo, type TauriWindowConfig, type TerminalNodeProps, type TransitionDoc, type UnifiedApp, type UnifiedAppConfig, type UnsubscribeFn, type UnumAdapter, type UnumAdapterConfig, type UnumChannel, type UnumIdentity, type UnumMessage, type UnumStore, type ValidationError, type ValidationResult, attachAllIntegrations, attachTauriToEngine, attachToEngine, attachUnumToEngine, canvasToMermaid, canvasToSchema, canvasToYaml, createCanvasEditor, createReactiveEngine as createFrameworkAgnosticReactiveEngine, createInMemoryDB, createIntrospector, createMockTauriBridge, createPluresDB, createPluresDBAdapter, createPluresDBGenerator, createPraxisDBStore, createPraxisLocalFirst, createSchema, createSchemaRegistry, createSchemaTemplate, createStateDocsGenerator, createTauriPraxisAdapter, createTimerActor, createUnifiedApp, createUnumAdapter, defineConstraint, defineEvent, defineFact, defineModule, defineRule, filterEvents, filterFacts, findEvent, findFact, generateDocs, generateId, generateTauriConfig, getEventPath, getFactPath, getSchemaPath, loadSchemaFromJson, loadSchemaFromYaml, registerSchema, schemaToCanvas, validateForGeneration, validateSchema, validateWithGuardian };

package/dist/browser/index.js

@@ -1,11 +1,20 @@
 import {
-  LogicEngine,
-  PRAXIS_PROTOCOL_VERSION,
   PraxisRegistry,
   ReactiveLogicEngine,
-  createPraxisEngine,
   createReactiveEngine
-} from "./chunk-R45WXWKH.js";
+} from "./chunk-K377RW4V.js";
+import {
+  LogicEngine,
+  PRAXIS_PROTOCOL_VERSION,
+  createPraxisEngine
+} from "./chunk-VOMLVI6V.js";
+import {
+  InMemoryPraxisDB,
+  PluresDBPraxisAdapter,
+  createInMemoryDB,
+  createPluresDB,
+  createPraxisLocalFirst
+} from "./chunk-MBVHLOU2.js";
 
 // src/core/reactive-engine.ts
 var ReactiveLogicEngine2 = class _ReactiveLogicEngine {
@@ -571,19 +580,25 @@ function defineEvent(tag) {
   };
 }
 function defineRule(options) {
+  const contract = options.contract ?? options.meta?.contract;
+  const meta = contract ? { ...options.meta ?? {}, contract } : options.meta;
   return {
     id: options.id,
     description: options.description,
     impl: options.impl,
-    meta: options.meta
+    contract,
+    meta
   };
 }
 function defineConstraint(options) {
+  const contract = options.contract ?? options.meta?.contract;
+  const meta = contract ? { ...options.meta ?? {}, contract } : options.meta;
   return {
     id: options.id,
     description: options.description,
     impl: options.impl,
-    meta: options.meta
+    contract,
+    meta
   };
 }
 function defineModule(options) {
@@ -1148,141 +1163,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 +2710,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-CIMBGDC7.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-CIMBGDC7.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 +2857,7 @@ export {
   ReactiveLogicEngine,
   RegistryIntrospector,
   StateDocsGenerator,
+  attachAllIntegrations,
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
@@ -2861,6 +2874,7 @@ export {
   createPluresDBGenerator,
   createPraxisDBStore,
   createPraxisEngine,
+  createPraxisLocalFirst,
   createReactiveEngine,
   createSchema,
   createSchemaRegistry,
@@ -2868,6 +2882,7 @@ export {
   createStateDocsGenerator,
   createTauriPraxisAdapter,
   createTimerActor,
+  createUnifiedApp,
   createUnumAdapter,
   defineConstraint,
   defineEvent,

package/dist/browser/integrations/svelte.d.ts

@@ -1,5 +1,5 @@
-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';
+import { L as LogicEngine, P as PraxisState, a as PraxisEvent } from '../reactive-engine.svelte-9aS0kTa8.js';
+export { q as ReactiveEngineOptions, r as ReactiveLogicEngine, s as createReactiveEngine } from '../reactive-engine.svelte-9aS0kTa8.js';
 
 /**
  * Svelte v5 Integration

package/dist/browser/integrations/svelte.js

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