@plures/praxis 1.1.3 → 1.2.0

package/dist/browser/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
+};

package/dist/browser/{chunk-R45WXWKH.js → chunk-VOMLVI6V.js}

@@ -1,77 +1,6 @@
 // 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") {
@@ -261,85 +190,8 @@ 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
+  createPraxisEngine
 };

package/dist/browser/engine-YJZV4SLD.js

@@ -0,0 +1,8 @@
+import {
+  LogicEngine,
+  createPraxisEngine
+} from "./chunk-VOMLVI6V.js";
+export {
+  LogicEngine,
+  createPraxisEngine
+};

package/dist/browser/index.d.ts

@@ -3161,4 +3161,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, 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, 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 };