@plures/praxis 1.0.2 → 1.1.0

package/README.md

@@ -1,398 +1,158 @@
-# Praxis
+dotnet build
+dotnet test
+# Praxis 1.1.0
+
+**Typed, visual-first application logic for Svelte, Node, and the browser.**
 
-[![CI](https://github.com/plures/praxis/workflows/CI/badge.svg)](https://github.com/plures/praxis/actions/workflows/ci.yml)
-[![CodeQL](https://github.com/plures/praxis/workflows/CodeQL/badge.svg)](https://github.com/plures/praxis/actions/workflows/codeql.yml)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![npm version](https://img.shields.io/npm/v/@plures/praxis.svg)](https://www.npmjs.com/package/@plures/praxis)
-[![NuGet](https://img.shields.io/nuget/v/Plures.Praxis.svg)](https://www.nuget.org/packages/Plures.Praxis/)
 [![JSR](https://jsr.io/badges/@plures/praxis)](https://jsr.io/@plures/praxis)
-[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org/)
 [![Deno Compatible](https://img.shields.io/badge/deno-compatible-brightgreen)](https://deno.land/)
 
-**The Full Plures Application Framework**
+Praxis is a schema-driven, rule-based engine with first-class Svelte 5 integration, component generation, and optional cloud sync. Version **1.1.0** delivers a unified ESM/CJS build, curated subpath exports, Svelte runes support, and a slimmer, publish-ready package for npm and JSR.
 
 ---
 
-## 📊 Project Dashboard
-
-### Quick Links
-- 📖 [Documentation](./docs/) | [Getting Started](./GETTING_STARTED.md) | [Framework Guide](./FRAMEWORK.md)
-- 💬 [Discussions](https://github.com/plures/praxis/discussions) | [Issues](https://github.com/plures/praxis/issues)
-- 🚀 [Contributing](./CONTRIBUTING.md) | [Security Policy](./SECURITY.md)
-- 📋 [Changelog](./CHANGELOG.md) | [Roadmap](https://github.com/plures/praxis/issues?q=is%3Aissue+is%3Aopen+label%3Aroadmap)
-- 🔄 [Cross-Language Sync](./CROSS_LANGUAGE_SYNC.md) | [C# Documentation](./csharp/Praxis/README.md)
-
-### Project Status
-
-| Category | Status |
-|----------|--------|
-| **CI/CD** | ✅ Automated testing & builds |
-| **Version** | 1.0.2 (Stable) |
-| **Runtime Support** | Node.js 18+, Deno (experimental), .NET 8+ |
-| **Package Registries** | npm ✅ / NuGet ✅ / JSR ✅  |
-| **Test Coverage** | 327 TypeScript + 95 C# tests passing |
-| **Documentation** | 📚 Comprehensive guides available |
-
-### Language Support
-
-| Language | Package | Registry | Status |
-|----------|---------|----------|--------|
-| **TypeScript** | @plures/praxis | npm | ✅ Available |
-| **C#** | Plures.Praxis | NuGet | ✅ Available |
-| **PowerShell** | Praxis.psm1 | GitHub | ✅ Available |
-
-### Integration Status
-
-| Integration | Status | Notes |
-|------------|--------|-------|
-| **Praxis Cloud** | ✅ Available | Azure-hosted relay for sync & monetization |
-| **PluresDB** | ✅ Available | Local-first reactive datastore with 32 tests |
-| **Unum** | ✅ Available | Identity & channels integration |
-| **Svelte 5** | ✅ Full Support | Runes API, stores, history, time-travel |
-| **Tauri** | ✅ Available | Cross-platform desktop runtime |
-| **CodeCanvas** | ✅ Available | Visual schema editor & FSM enforcement |
-| **State-Docs** | ✅ Available | Documentation generation from schemas |
-
----
-
-## Overview
-
-Praxis is not just a logic engine—it's a **complete framework** for building modern, local-first, distributed applications. It provides:
-
-- **Declarative Schemas**: Define your data models, logic, and components in a unified schema format (PSF)
-- **Logic/State Machines**: Pure, functional application logic with facts, events, rules, and constraints
-- **Component Generation**: Automatically generate Svelte components from schemas
-- **Local-First Data**: Integrated PluresDB for reactive, offline-capable data storage
-- **Documentation Generation**: Automatic documentation generation from schemas with Mermaid diagrams
-- **Visual Design**: CodeCanvas integration for visual schema and logic editing
-- **Real-Time Code ↔ Canvas Sync**: Bidirectional synchronization between code and visual editor
-- **Orchestration**: DSC/MCP support for distributed system coordination
-- **Cross-Platform Runtime**: Web, desktop, and mobile via Svelte + Tauri
-
-## 🚀 Praxis 1.0 Architecture
+## What’s new in 1.1.0
+- **Unified builds & exports**: `./`, `./svelte`, `./schema`, `./component`, `./cloud`, `./components`, and CLI all ship with ESM, CJS, and type definitions.
+- **Svelte 5 runes native**: Runes-friendly stores and helpers; server+client builds for integrations.
+- **Logic engine refinements**: Typed registry, step diagnostics, and trace-friendly rule execution.
+- **Cloud relay & local-first**: Polished cloud connector alongside PluresDB-first workflows.
+- **Publish-ready**: npm public access + JSR exports aligned to source.
 
-Praxis 1.0 introduces a **schema-driven, modular architecture** where the Praxis Schema Format (PSF) serves as the single source of truth.
+## Capabilities at a glance
+- **Logic Engine**: Facts, events, rules, constraints, registry, introspection, and reactive engine variant.
+- **Schema & Codegen**: PSF-style schema types plus component generator for Svelte UIs.
+- **Svelte Integration**: Typed helpers, runes-ready builds, and Svelte component typings.
+- **Local-First Data**: PluresDB integrations for offline-first, reactive state.
+- **Cloud Relay**: Optional sync layer (GitHub-auth friendly) for distributed teams.
+- **CLI**: Scaffolding, generation, canvas helpers, and cloud commands.
 
-### Praxis Schema Format (PSF)
-
-PSF is the canonical JSON/AST format that defines your entire application:
-
-```json
-{
-  "$version": "latest",
-  "id": "my-app",
-  "name": "My Application",
-  "facts": [...],
-  "events": [...],
-  "rules": [...],
-  "constraints": [...],
-  "models": [...],
-  "components": [...],
-  "flows": [...]
-}
-```
-
-From this schema, Praxis generates:
-- **TypeScript types** for facts, events, rules
-- **Svelte components** for UI
-- **Markdown documentation** with Mermaid diagrams
-- **Database schemas** for PluresDB
-- **Canvas visualization** for visual editing
-
-### Modular Folder Structure
-
-```
-/praxis
-├── core/                     # Core framework modules
-│   ├── schema-engine/        # PSF types, compiler, generator, validator
-│   ├── logic-engine/         # Rules, constraints, engine, PSF adapter
-│   ├── db-adapter/           # PluresDB sync engine
-│   └── codegen/              # Documentation and code generators
-├── ui/                       # UI modules
-│   ├── svelte-generator/     # PSF-aware Svelte component generation
-│   └── canvas/               # Visual canvas state and projection
-├── tools/                    # Developer tools
-│   ├── cli/                  # Command-line interface
-│   └── watcher/              # File watching and live sync
-├── extensions/               # Optional integrations
-│   ├── dsc/                  # DSC/MCP orchestration
-│   ├── azure/                # Azure integration
-│   └── devtools/             # Developer tools
-└── examples/                 # Example applications
-    ├── hero-shop/            # Full e-commerce example
-    └── todo/                 # Minimal todo example
-```
-
-### Framework Philosophy
-
-### Core Framework Components
-
-Praxis provides these integrated capabilities:
-
-- **Schema Engine** – PSF parser, compiler, generator, and validator
-- **Logic Engine** – Typed facts, events, rules, and constraints for application logic
-- **Component Factory** – Generate Svelte components from schemas with data bindings
-- **Data Layer** – PluresDB integration for reactive, local-first data storage
-- **State Machines** – Flows and scenarios for orchestrated behaviors
-- **Actors** – Effectful units for side effects and external system integration
-- **Terminal Nodes** – Execute commands and scripts within the Praxis framework
-- **Documentation** – Automatic documentation generation from schemas with Mermaid diagrams
-- **Visual IDE** – CodeCanvas integration for schema and logic editing
-- **Orchestration** – DSC/MCP support for distributed coordination
-- **CLI Tools** – Command-line interface for scaffolding and generation
-
-### Design Philosophy
-
-1. **Schema-Driven Development**
-   - Define once, generate everywhere (models, components, docs, orchestration)
-   - Single source of truth for your application structure
-   - Type-safe by default across all layers
-
-2. **Local-First Architecture**
-   - Offline-capable by default with PluresDB
-   - Sync when connected, work always
-   - Data ownership and privacy built-in
-
-3. **Strong typing and functional programming**
-   - Core abstractions are strongly typed: `Fact<Tag, Payload>`, `Event<Tag, Payload>`, `Rule<Context, InFact, OutFact>`
-   - Pure functions for testability and reasoning
-   - Immutable state updates
-
-4. **Visual and Code Workflows**
-   - CodeCanvas for visual schema and logic editing
-   - Full code-level control when needed
-   - Seamless transitions between visual and code
-
-5. **Cross-Platform and Cross-Language**
-   - TypeScript-first with C# and PowerShell support
-   - Web, desktop, mobile via Svelte + Tauri
-   - Language-agnostic core protocol for maximum portability
-
-## Framework Features
-
-### 🏗️ Full Application Framework
-- **Schema-Driven**: Define data models, logic, and UI in unified schemas
-- **Component Generation**: Auto-generate Svelte components from schemas
-- **CLI Tools**: `praxis create`, `praxis generate`, `praxis canvas` commands
-- **Templates**: Pre-built app templates (basic, fullstack, distributed)
-- **Integrated Stack**: PluresDB + Unum + ADP + State-Docs + Canvas
-
-### 🎨 Visual Development
-- **CodeCanvas Integration**: Visual schema and logic editor
-- **Component Preview**: See generated components in real-time
-- **Flow Visualization**: Visualize state machines and orchestration
-- **Interactive Docs**: Navigate documentation with State-Docs
-
-### 🔌 Ecosystem Integration
-- **PluresDB**: Local-first reactive data storage
-- **Unum**: Identity and channels for distributed systems
-- **ADP**: Architectural guardrails and decision tracking
-- **State-Docs**: Living documentation generation
-- **Svelte 5**: Full runes support with history and time-travel
-- **Tauri**: Cross-platform runtime (web/desktop/mobile)
-
-### ⚡ Svelte 5 Integration
-- **Runes API**: Modern `$state`, `$derived`, `$effect` support
-- **History States**: Built-in undo/redo and time-travel debugging
-- **Store API**: Backward-compatible stores for Svelte 4/5
-- **Type Safety**: Full TypeScript support with composables
-- **Zero Config**: Works out of the box with Svelte 5
-
-## Logic Engine Features
-
-- 🎯 **Logic-First Design**: Build applications around facts, events, rules, and constraints
-- 🔄 **Pure Functional Core**: State transitions via pure `step` functions
-- 📝 **Fluent DSL**: Intuitive API for defining rules and constraints
-- 🗂️ **Registry System**: Centralized management of rules and constraints
-- 🌊 **Flows & Actors**: Orchestrate complex state transitions
-- 📦 **JSON-Friendly**: All types are serializable for cross-platform use
-- 🔒 **Type-Safe**: Full TypeScript support with strict typing
-- 🔍 **Introspection**: Generate schemas, graphs, and visualizations of your logic
-- 🌐 **Cross-Language**: C#, PowerShell, and TypeScript implementations with protocol versioning
-- 📊 **Comprehensive Testing**: 327 TypeScript and 95 C# tests covering all features
-- 🎭 **Hero Example**: Full e-commerce demo with auth, cart, features, and actors
-
-## Installation
-
-### npm (Node.js)
+## Install
+Node 18+ recommended.
 
 ```bash
+# npm
 npm install @plures/praxis
-```
-
-### NuGet (.NET / C#)
-
-```bash
-dotnet add package Plures.Praxis
-```
-
-Or add to your `.csproj`:
 
-```xml
-<PackageReference Include="Plures.Praxis" Version="0.2.1" />
+# pnpm
+pnpm add @plures/praxis
 ```
 
-See [C# Documentation](./csharp/Praxis/README.md) for detailed usage.
-
-### JSR (Deno)
-
+JSR (Deno):
 ```bash
-# Coming soon - JSR publishing in progress
-deno add @plures/praxis
+const result = engine.step([Login.create({ username: 'alice' })]);
+# or via import map pointing to npm:
+# {
+#   "imports": { "@plures/praxis": "npm:@plures/praxis@^1.1.0" }
+# }
 ```
 
-For now, you can use Praxis with Deno via import maps:
-
-```typescript
-// import_map.json
-{
-  "imports": {
-    "@plures/praxis": "npm:@plures/praxis@^0.2.1"
-  }
-}
-```
+## Quick start (logic engine)
+```ts
+import {
+  createPraxisEngine,
+  PraxisRegistry,
+  defineFact,
+  defineEvent,
+  defineRule,
+} from '@plures/praxis';
 
-### From Source
+const UserLoggedIn = defineFact<'UserLoggedIn', { userId: string }>('UserLoggedIn');
+const Login = defineEvent<'LOGIN', { username: string }>('LOGIN');
 
-```bash
-# Clone the repository
-git clone https://github.com/plures/praxis.git
-cd praxis
+const loginRule = defineRule<{ currentUser: string | null }>({
+  id: 'auth.login',
+  description: 'Authenticate and emit fact',
+  impl: (state, events) => {
+    const evt = events.find(Login.is);
+    if (!evt) return [];
+    state.context.currentUser = evt.payload.username;
+    return [UserLoggedIn.create({ userId: evt.payload.username })];
+  },
+});
 
-# TypeScript
-npm install
-npm run build
-npm test
+const registry = new PraxisRegistry();
+registry.registerRule(loginRule);
 
-# C#
-cd csharp
-dotnet build
-dotnet test
+const engine = createPraxisEngine({ initialContext: { currentUser: null }, registry });
+engine.step([Login.create({ username: 'alex' })]);
 ```
 
-## Quick Start
-
-### Using the Praxis CLI
-
-The Praxis CLI provides commands for creating and managing applications.
-
-```bash
-# Install Praxis globally
-npm install -g @plures/praxis
-
-# Create a new application
-praxis create app my-app
-cd my-app
-npm install
+## Svelte integration (runes-ready)
+```svelte
+<script lang="ts">
+  import { createReactiveEngine, defineEvent, defineRule, PraxisRegistry } from '@plures/praxis/svelte';
+
+  const Increment = defineEvent<'INCREMENT', { amount: number }>('INCREMENT');
+  const counterRule = defineRule<{ count: number }>({
+    id: 'counter.increment',
+    description: 'Add to count',
+    impl: (state, events) => {
+      const evt = events.find(Increment.is);
+      if (evt) state.context.count += evt.payload.amount;
+      return [];
+    },
+  });
 
-# Generate code from schemas
-praxis generate --schema src/schemas/app.schema.ts
+  const registry = new PraxisRegistry();
+  registry.registerRule(counterRule);
 
-# Open CodeCanvas for visual editing
-praxis canvas src/schemas/app.schema.ts
+  const engine = createReactiveEngine({ initialContext: { count: 0 }, registry });
+  const count = engine.$derived((s) => s.context.count);
 
-# Start development server
-npm run dev
+  function addOne() {
+    engine.step([Increment.create({ amount: 1 })]);
+  }
+</script>
 
-# Build for production
-npm run build
+<button on:click={addOne}>Count is {$count}</button>
 ```
 
-Available CLI commands:
-- `praxis login` - Authenticate with GitHub (device flow or token)
-- `praxis logout` - Log out from Praxis Cloud
-- `praxis whoami` - Show current authenticated user
-- `praxis create app [name]` - Create new application
-- `praxis create component [name]` - Create new component
-- `praxis generate` - Generate code from schemas
-- `praxis canvas [schema]` - Open visual editor
-- `praxis orchestrate` - Manage distributed systems
-- `praxis cloud init` - Connect to Praxis Cloud
-- `praxis cloud status` - Check cloud connection
-- `praxis cloud sync` - Manually sync to cloud
-- `praxis cloud usage` - View cloud usage metrics
-- `praxis dev` - Start development server
-- `praxis build` - Build for production
-
-See [docs/guides/getting-started.md](./docs/guides/getting-started.md) for detailed instructions.
+## Cloud relay (optional)
+```ts
+import { connectRelay } from '@plures/praxis/cloud';
 
-### Praxis Cloud
-
-Connect your application to Praxis Cloud for automatic synchronization with GitHub-native authentication and billing:
-
-```bash
-# Authenticate with GitHub
-npx praxis login
-
-# Initialize cloud connection
-npx praxis cloud init
-
-# In your code
-import { connectRelay } from "@plures/praxis/cloud";
-
-const relay = await connectRelay("https://praxis-relay.azurewebsites.net", {
-  appId: "my-app",
+const relay = await connectRelay('https://my-relay.example.com', {
+  appId: 'my-app',
   authToken: process.env.GITHUB_TOKEN,
-  autoSync: true
+  autoSync: true,
 });
 
-// Sync automatically handles CRDT merge
 await relay.sync({
-  type: "delta",
-  appId: "my-app",
+  type: 'delta',
+  appId: 'my-app',
   clock: {},
-  facts: [...],
-  timestamp: Date.now()
+  facts: [],
+  timestamp: Date.now(),
 });
 ```
 
-See [src/cloud/README.md](./src/cloud/README.md) and [examples/cloud-sync](./examples/cloud-sync) for details.
-
-### Basic Example (Logic Engine)
-
-```typescript
-import {
-  createPraxisEngine,
-  PraxisRegistry,
-  defineFact,
-  defineEvent,
-  defineRule,
-} from "@plures/praxis";
-
-// Define the context type
-interface AuthContext {
-  currentUser: string | null;
-}
-
-// Define facts and events
-const UserLoggedIn = defineFact<"UserLoggedIn", { userId: string }>("UserLoggedIn");
-const Login = defineEvent<"LOGIN", { username: string }>("LOGIN");
-
-// Define rules
-const loginRule = defineRule<AuthContext>({
-  id: "auth.login",
-  description: "Process login event",
-  impl: (state, events) => {
-    const loginEvent = events.find(Login.is);
-    if (loginEvent) {
-      state.context.currentUser = loginEvent.payload.username;
-      return [UserLoggedIn.create({ userId: loginEvent.payload.username })];
-    }
-    return [];
-  },
-});
-
-// Create engine
-const registry = new PraxisRegistry<AuthContext>();
-registry.registerRule(loginRule);
-
-const engine = createPraxisEngine({
-  initialContext: { currentUser: null },
-  registry,
-});
+## CLI (npx-friendly)
+```bash
+npx praxis --help
+npx praxis create app my-app
+npx praxis generate --schema src/schemas/app.schema.ts
+npx praxis canvas src/schemas/app.schema.ts
+```
+
+## Exports map
+- `@plures/praxis` → main engine (ESM/CJS/types)
+- `@plures/praxis/svelte` → Svelte 5 integrations
+- `@plures/praxis/schema` → Schema types
+- `@plures/praxis/component` → Component generator
+- `@plures/praxis/cloud` → Cloud relay APIs
+- `@plures/praxis/components` → TS props for Svelte components (e.g., TerminalNode)
+- `praxis` (bin) → CLI entrypoint
+
+## Documentation
+- [Getting Started](./GETTING_STARTED.md)
+- [Framework Guide](./FRAMEWORK.md)
+- [Examples](./examples/)
 
-// Dispatch events
-const result = engine.step([Login.create({ username: "alice" })]);
+## Contributing
+PRs and discussions welcome. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) and [SECURITY.md](./SECURITY.md).
 console.log(result.state.facts); // [{ tag: "UserLoggedIn", payload: { userId: "alice" } }]
 console.log(engine.getContext()); // { currentUser: "alice" }
 ```
@@ -400,13 +160,13 @@ console.log(engine.getContext()); // { currentUser: "alice" }
 ### With Constraints
 
 ```typescript
-import { defineConstraint } from "@plures/praxis";
+import { defineConstraint } from '@plures/praxis';
 
 const maxSessionsConstraint = defineConstraint<AuthContext>({
-  id: "auth.maxSessions",
-  description: "Only one user can be logged in at a time",
+  id: 'auth.maxSessions',
+  description: 'Only one user can be logged in at a time',
   impl: (state) => {
-    return state.context.currentUser === null || "User already logged in";
+    return state.context.currentUser === null || 'User already logged in';
   },
 });
 
@@ -418,7 +178,7 @@ registry.registerConstraint(maxSessionsConstraint);
 #### Store API (Svelte 4/5 Compatible)
 
 ```typescript
-import { createPraxisStore, createDerivedStore } from "@plures/praxis/svelte";
+import { createPraxisStore, createDerivedStore } from '@plures/praxis/svelte';
 
 const stateStore = createPraxisStore(engine);
 const userStore = createDerivedStore(engine, (ctx) => ctx.currentUser);
@@ -438,7 +198,7 @@ const userStore = createDerivedStore(engine, (ctx) => ctx.currentUser);
   import { createMyEngine, Login } from './my-engine';
 
   const engine = createMyEngine();
-  const { 
+  const {
     context,      // Reactive context
     dispatch,     // Dispatch events
     undo,         // Undo last action
@@ -453,15 +213,15 @@ const userStore = createDerivedStore(engine, (ctx) => ctx.currentUser);
 
 <div>
   <p>User: {context.currentUser || 'Guest'}</p>
-  
+
   <button onclick={() => dispatch([Login.create({ username: 'alice' })])}>
     Login
   </button>
-  
+
   <button onclick={undo} disabled={!canUndo}>
     ⟲ Undo
   </button>
-  
+
   <button onclick={redo} disabled={!canRedo}>
     ⟳ Redo
   </button>
@@ -469,12 +229,14 @@ const userStore = createDerivedStore(engine, (ctx) => ctx.currentUser);
 ```
 
 See the [Advanced Todo Example](src/examples/advanced-todo/) for a complete demo with:
+
 - Undo/redo functionality
 - Time-travel debugging
 - Keyboard shortcuts
 - Beautiful UI
 
 For comprehensive guides:
+
 - [Svelte Integration Guide](docs/guides/svelte-integration.md)
 - [History State Pattern](docs/guides/history-state-pattern.md)
 - [Parallel State Pattern](docs/guides/parallel-state-pattern.md)
@@ -511,6 +273,7 @@ type PraxisStepFn = (
 ```
 
 This protocol is:
+
 - Pure and deterministic (data in → data out)
 - No side effects, no global state
 - JSON-friendly for cross-language compatibility
@@ -586,7 +349,9 @@ See [FRAMEWORK.md](./FRAMEWORK.md) for complete architecture documentation.
 The repository includes multiple complete examples:
 
 ### 1. Hero E-Commerce (`src/examples/hero-ecommerce`)
+
 Comprehensive example demonstrating all Praxis features in a single application:
+
 - Authentication with session management
 - Shopping cart with discount rules
 - Feature flags for A/B testing
@@ -600,7 +365,9 @@ node dist/examples/hero-ecommerce/index.js
 ```
 
 ### 2. Offline-First Chat (`examples/offline-chat`)
+
 Demonstrates local-first architecture with PluresDB:
+
 - Offline message composition and storage
 - Automatic sync when connected
 - Message queue for offline messages
@@ -610,7 +377,9 @@ Demonstrates local-first architecture with PluresDB:
 See [examples/offline-chat/README.md](./examples/offline-chat/README.md)
 
 ### 3. Knowledge Canvas (`examples/knowledge-canvas`)
+
 Showcases CodeCanvas integration for visual knowledge management:
+
 - Visual knowledge graph editing
 - Schema-driven content types
 - Generated UI components
@@ -620,7 +389,9 @@ Showcases CodeCanvas integration for visual knowledge management:
 See [examples/knowledge-canvas/README.md](./examples/knowledge-canvas/README.md)
 
 ### 4. Self-Orchestrating Node (`examples/distributed-node`)
+
 Demonstrates distributed orchestration with DSC/MCP:
+
 - Automatic node discovery
 - Self-healing behavior
 - State synchronization across nodes
@@ -630,7 +401,9 @@ Demonstrates distributed orchestration with DSC/MCP:
 See [examples/distributed-node/README.md](./examples/distributed-node/README.md)
 
 ### 5. Terminal Node (`examples/terminal-node`)
+
 Demonstrates the terminal node feature for command execution:
+
 - Terminal adapter creation and configuration
 - Command execution and history tracking
 - YAML schema loading with terminal nodes
@@ -645,6 +418,7 @@ node examples/terminal-node/index.js
 See [examples/terminal-node/README.md](./examples/terminal-node/README.md) and [docs/TERMINAL_NODE.md](./docs/TERMINAL_NODE.md)
 
 ### 6. Auth Basic (`src/examples/auth-basic`)
+
 Login/logout with facts, rules, and constraints.
 
 ```bash
@@ -653,6 +427,7 @@ node dist/examples/auth-basic/index.js
 ```
 
 ### 7. Cart (`src/examples/cart`)
+
 Shopping cart with multiple rules, constraints, and complex state management.
 
 ```bash
@@ -661,6 +436,7 @@ node dist/examples/cart/index.js
 ```
 
 ### 8. Svelte Counter (`src/examples/svelte-counter`)
+
 Counter example showing Svelte v5 integration with reactive stores.
 
 ```bash
@@ -669,21 +445,25 @@ node dist/examples/svelte-counter/index.js
 ```
 
 ### 9. Terminal Canvas (`examples/terminal-canvas`)
+
 Combines terminal nodes with visual canvas features in a Svelte app.
 
 See [examples/terminal-canvas/README.md](./examples/terminal-canvas/README.md)
 
 ### 10. GitHub Monetization (`examples/github-monetization`)
+
 Example of GitHub-based monetization integration with Praxis Cloud.
 
 See [examples/github-monetization/README.md](./examples/github-monetization/README.md)
 
 ### 11. Simple App (`examples/simple-app`)
+
 A minimal example demonstrating basic Praxis schema usage.
 
 See [examples/simple-app/README.md](./examples/simple-app/README.md)
 
 ### 12. Cloud Sync (`examples/cloud-sync`)
+
 Demonstrates real-time synchronization with Praxis Cloud relay service.
 
 See [examples/cloud-sync/README.md](./examples/cloud-sync/README.md)
@@ -718,7 +498,7 @@ See [examples/cloud-sync/README.md](./examples/cloud-sync/README.md)
 Tools for examining and visualizing your Praxis logic:
 
 ```typescript
-import { createIntrospector, PRAXIS_PROTOCOL_VERSION } from "@plures/praxis";
+import { createIntrospector, PRAXIS_PROTOCOL_VERSION } from '@plures/praxis';
 
 const introspector = createIntrospector(registry);
 
@@ -745,6 +525,7 @@ const maxConstraints = introspector.searchConstraints('max');
 ```
 
 **Available methods:**
+
 - `getStats()` - Get registry statistics
 - `generateSchema(protocolVersion)` - Generate JSON schema
 - `generateGraph()` - Generate graph representation
@@ -764,11 +545,11 @@ Praxis integrates with the full Plures ecosystem:
 Local-first reactive datastore for offline-capable applications. **Now fully implemented** with 32 tests covering all features.
 
 ```typescript
-import { 
-  createInMemoryDB, 
-  createPraxisDBStore, 
+import {
+  createInMemoryDB,
+  createPraxisDBStore,
   createPluresDBAdapter,
-  attachToEngine 
+  attachToEngine,
 } from '@plures/praxis/pluresdb';
 
 // Create an in-memory database
@@ -778,26 +559,27 @@ const db = createInMemoryDB();
 const store = createPraxisDBStore({ db });
 
 // Or create an adapter to attach to an engine
-const adapter = createPluresDBAdapter({ 
-  db, 
+const adapter = createPluresDBAdapter({
+  db,
   registry,
-  initialContext: {} 
+  initialContext: {},
 });
 
 // Attach adapter to engine for automatic persistence
 adapter.attachEngine(engine);
 
 // Persist facts and events
-await adapter.persistFacts([{ tag: "UserLoggedIn", payload: { userId: "alice" } }]);
-await adapter.persistEvents([{ tag: "LOGIN", payload: { username: "alice" } }]);
+await adapter.persistFacts([{ tag: 'UserLoggedIn', payload: { userId: 'alice' } }]);
+await adapter.persistEvents([{ tag: 'LOGIN', payload: { username: 'alice' } }]);
 
 // Subscribe to changes
 adapter.subscribeToEvents((events) => {
-  console.log("New events:", events);
+  console.log('New events:', events);
 });
 ```
 
 **Features:**
+
 - **In-memory adapter**: Ready-to-use implementation for development and testing
 - **Reactive store**: Watch for changes with callbacks
 - **Schema registry**: Store and retrieve schemas in PluresDB
@@ -1011,6 +793,7 @@ See [csharp/Praxis/README.md](./csharp/Praxis/README.md) for complete documentat
 ## Roadmap
 
 ### Current Focus
+
 - Full CodeCanvas integration
 - Enhanced Unum identity support
 - Advanced State-Docs generation
@@ -1018,6 +801,7 @@ See [csharp/Praxis/README.md](./csharp/Praxis/README.md) for complete documentat
 - Real PluresDB sync with CRDT/offline-first capabilities
 
 ### Long Term
+
 - Mobile templates (iOS, Android)
 - Enterprise features
 - Advanced orchestration
@@ -1029,8 +813,9 @@ See [csharp/Praxis/README.md](./csharp/Praxis/README.md) for complete documentat
 The core protocol is implemented across multiple languages:
 
 **TypeScript** (Primary, npm: `@plures/praxis`)
+
 ```typescript
-import { createPraxisEngine, PraxisRegistry } from "@plures/praxis";
+import { createPraxisEngine, PraxisRegistry } from '@plures/praxis';
 
 const engine = createPraxisEngine({
   initialContext: {},
@@ -1040,6 +825,7 @@ const result = engine.step(events);
 ```
 
 **C#** (.NET 8+, NuGet: `Plures.Praxis`)
+
 ```csharp
 var engine = PraxisEngine.Create(new PraxisEngineOptions<TContext> { ... });
 var result = engine.Step(events);
@@ -1048,6 +834,7 @@ var result = engine.Step(events);
 See [csharp/Praxis/README.md](./csharp/Praxis/README.md) for full documentation.
 
 **PowerShell** (GitHub: `Praxis.psm1`)
+
 ```powershell
 $newState = Invoke-PraxisStep -State $state -Events $events
 ```