docs: update READMEs to reflect current WASI Preview 2 status

- Simplify main README with honest early development status
- Focus on WASI Preview 2 as the target (not Preview 1)
- Document what actually works: component execution, stdout/stderr
- Remove aspirational API examples that don't exist
- Tame down claims to match reality

Author: avrabe

README.md

@@ -1,136 +1,84 @@
-# PulseEngine (WRT Edition)
+# WRT - WebAssembly Runtime
 
-A pure Rust implementation of WebAssembly infrastructure designed for safety-critical systems. Provides foundational components for WebAssembly execution with emphasis on memory safety, deterministic behavior, and formal verification capabilities.
+A Rust implementation of a WebAssembly runtime focusing on the Component Model and WASI Preview 2. Designed with safety-critical systems in mind.
 
-## Features
+## Current Status
 
-- **Memory Operations**: Complete WebAssembly memory management with bounds checking
-- **Arithmetic Instructions**: Full implementation of WebAssembly numeric operations
-- **Type System**: Complete WebAssembly value types and validation infrastructure
-- **`no_std` Compatible**: Works in embedded and bare-metal environments
-- **Safety-Critical Design**: ASIL compliance framework and formal verification support
-- **Development Status**: Core execution engine and Component Model under development
+**Early Development** - Basic WebAssembly component execution is working:
 
-## Quick Start
+```bash
+# Run a Rust-compiled WASI Preview 2 component
+./target/debug/wrtd hello_rust.wasm --component
+# Output: Hello wasm component world from Rust!
+```
+
+### What Works
 
-For comprehensive installation instructions, see the [Installation Guide](docs/source/getting_started/installation.rst).
+- WebAssembly Component Model parsing and instantiation
+- WASI Preview 2 stdout/stderr output (`wasi:cli/stdout`, `wasi:io/streams`)
+- Core WebAssembly module execution
+- Basic memory management with bounds checking
+- `no_std` compatible foundation (for embedded use cases)
 
-### Prerequisites
+### In Progress
 
-- Rust 1.86.0 or newer
-- cargo-wrt (included in this repository)
+- Additional WASI Preview 2 interfaces (filesystem, environment, etc.)
+- Cross-component function calls
+- Full Component Model linking
 
-### Building from Source
+## Quick Start
 
 ```bash
-# Clone repository
+# Clone and build
 git clone https://github.com/pulseengine/wrt
 cd wrt
+cargo build --bin wrtd --features "std,wrt-execution"
 
-# Install cargo-wrt
-cargo install --path cargo-wrt
-
-# Build everything
-cargo-wrt build
-
-# Run tests
-cargo-wrt test
-
-# Run example (requires setup)
-cargo-wrt wrtd --test
-```
-
-### Usage
-
-**Note**: PulseEngine is currently available only as source code. Add it to your project:
-
-```toml
-[dependencies]
-wrt = { path = "path/to/wrt" }  # Point to local clone
-```
-
-Basic usage:
-
-```rust
-use wrt::prelude::*;
-
-// Note: Core execution engine under development
-// Current example shows memory and arithmetic operations
-let memory = WrtMemory::new(1024)?;
-let value = Value::I32(42);
-let result = ArithmeticOp::I32Add.execute(&[value, Value::I32(8)])?;
+# Run a WebAssembly component
+./target/debug/wrtd your_component.wasm --component
 ```
 
 ## Project Structure
 
-This is a multi-crate workspace:
-
-- **`wrt/`** - Main library facade
-- **`wrt-foundation/`** - Core types and bounded collections  
+- **`wrtd/`** - Runtime daemon (main executable)
 - **`wrt-runtime/`** - Execution engine
-- **`wrt-component/`** - Component Model implementation
+- **`wrt-component/`** - Component Model support
 - **`wrt-decoder/`** - Binary format parsing
-- **`wrtd/`** - Standalone runtime daemon
-- **`example/`** - Example WebAssembly component
+- **`wrt-foundation/`** - Core types and bounded collections
+- **`cargo-wrt/`** - Build tooling
 
-## Documentation
-
-- **[API Documentation](docs/source/)** - Complete API reference and specifications
-- **[Architecture Guide](docs/source/architecture/)** - System design and components
-- **[Developer Guide](docs/source/development/)** - Contributing and development setup
-
-Generate documentation:
+## Building
 
 ```bash
-# Build comprehensive documentation
-cargo-wrt docs --private
-
-# Open documentation in browser
-cargo-wrt docs --open
+# Install build tool (optional but recommended)
+cargo install --path cargo-wrt
 
-# API documentation only  
-cargo doc --workspace --open
+# Build runtime
+cargo build --bin wrtd --features "std,wrt-execution"
 
-# Generate and view coverage reports
-cargo-wrt coverage --html --open
+# Run tests
+cargo test --workspace
 ```
 
-## Development
-
-Setup development environment:
+## Usage
 
 ```bash
-# Check development tool dependencies
-cargo-wrt setup --check
-
-# Setup git hooks for code quality checks
-cargo-wrt setup --hooks
+# Basic component execution
+wrtd component.wasm --component
 
-# Setup all development tools
-cargo-wrt setup --all
+# With WASI support
+wrtd component.wasm --component --wasi
 
-# Manage tool version requirements
-cargo-wrt tool-versions check --verbose    # Check all tool versions
-cargo-wrt tool-versions generate           # Generate tool-versions.toml
+# Set resource limits
+wrtd component.wasm --component --fuel 100000 --memory 1048576
 ```
 
-See the [Developer Guide](docs/source/development/) for detailed development instructions.
+## Design Goals
 
-Common commands:
-
-```bash
-cargo-wrt --help             # Show all available commands
-cargo-wrt check              # Format code and run static analysis
-cargo-wrt ci                 # Run main CI checks
-cargo-wrt verify --asil d    # Run complete verification suite
-
-# Development commands
-cargo-wrt no-std             # Verify no_std compatibility
-cargo-wrt check --strict      # Strict code formatting and linting
-cargo-wrt coverage --html     # Generate code coverage
-cargo-wrt simulate-ci         # Simulate CI workflow locally
-```
+- **WASI Preview 2 focus** - Targeting the modern component-based WASI
+- **Safety-critical awareness** - Bounded allocations, deterministic behavior
+- **`no_std` support** - Usable in embedded/constrained environments
 
 ## License
 
-MIT License - see [LICENSE](LICENSE) file for details.
+MIT License - see [LICENSE](LICENSE) file.

wrt-component/README.md

@@ -1,138 +1,53 @@
 # wrt-component
 
-> WebAssembly Component Model implementation for WRT
+WebAssembly Component Model support for WRT.
 
-## Overview
+## Current Status
 
-Provides a complete implementation of the WebAssembly Component Model specification for WRT. This crate enables interoperability between WebAssembly components through standardized interfaces, type definitions, and linking mechanisms.
+**Early Development** - Basic component execution works:
 
-## Features
+- Component binary parsing
+- Core module extraction from components
+- Component instantiation
+- WASI Preview 2 interface resolution
 
-- **Component Model Specification** - Full implementation of WebAssembly Component Model
-- **Interface Types** - Support for rich interface type definitions (WIT format)
-- **Component Linking** - Runtime linking and composition of WebAssembly components
-- **WASI Integration** - Seamless integration with WASI (WebAssembly System Interface)
-- **Resource Management** - Safe handling of component resources and capabilities
-- **Async Execution** - Support for asynchronous component execution patterns
-- **no_std Compatible** - Works in embedded and constrained environments
-- **ASIL Compliance** - Safety-critical execution with ASIL-D support
+### In Progress
 
-## Quick Start
+- Full component linking
+- Cross-component calls
+- Resource management
 
-```toml
-[dependencies]
-wrt-component = "0.2"
-```
-
-```rust
-use wrt_component::prelude::*;
-
-// Load and instantiate a WebAssembly component
-let component_bytes = include_bytes!("example.wasm");
-let component = Component::from_bytes(component_bytes)?;
-
-// Create a component instance with specified limits
-let instance = ComponentInstance::new(component, ComponentLimits::default())?;
-
-// Call component exports
-let result = instance.call_export("example_function", &args)?;
-```
-
-## Architecture
-
-### Core Components
-
-- **Component**: Parsed WebAssembly component with metadata and interfaces
-- **ComponentInstance**: Runtime instance with memory, resources, and execution state
-- **Interface**: Type definitions and function signatures for component interfaces
-- **Linker**: Component composition and inter-component communication
-- **ResourceManager**: Safe management of component resources and capabilities
-
-### Component Model Features
-
-```rust
-use wrt_component::*;
-
-// Define component interfaces using WIT
-let interface = Interface::from_wit(r#"
-    interface example {
-        record point {
-            x: f32,
-            y: f32,
-        }
-        
-        transform: func(points: list<point>) -> list<point>
-    }
-"#)?;
-
-// Link components together
-let mut linker = ComponentLinker::new();
-linker.define_component("graphics", graphics_component)?;
-linker.define_component("math", math_component)?;
-```
-
-### ASIL-D Safety Features
-
-The component system provides safety-critical execution capabilities:
+## Usage
 
-```rust
-use wrt_component::safety::*;
+Components are executed through `wrtd`:
 
-// Create ASIL-D compliant component instance
-let safety_config = AsilConfig::asil_d()
-    .with_fuel_limit(10000)
-    .with_memory_limit(1024 * 1024)
-    .with_call_depth_limit(32);
-
-let instance = ComponentInstance::new_with_safety(component, safety_config)?;
+```bash
+wrtd my_component.wasm --component
 ```
 
-### Async Component Execution
-
-Support for asynchronous WebAssembly component execution:
+## Component Model Support
 
-```rust
-use wrt_component::async_::*;
+Parses and executes WebAssembly components following the Component Model specification. Currently supports:
 
-// Execute components asynchronously
-let async_instance = AsyncComponentInstance::new(component).await?;
-let future_result = async_instance.call_async("long_running_task", &args).await?;
-```
+- Component sections (types, imports, exports, modules)
+- Alias resolution
+- Canon lift/lower for host calls
+- WASI Preview 2 interface matching
 
-## Resource Management
+## WASI Preview 2
 
-The component system provides fine-grained resource control:
+Integrated support for WASI Preview 2 interfaces:
 
-```rust
-use wrt_component::resources::*;
+- `wasi:cli/stdout` - Standard output
+- `wasi:cli/stderr` - Standard error
+- `wasi:io/streams` - Stream operations
 
-// Configure resource limits per component
-let resource_config = ResourceConfig::new()
-    .with_max_handles(100)
-    .with_max_memory_per_resource(64 * 1024)
-    .with_filesystem_access(FilesystemAccess::ReadOnly("/safe/path"));
-
-let instance = ComponentInstance::with_resources(component, resource_config)?;
-```
+Additional interfaces in development.
 
 ## no_std Support
 
-This crate supports `no_std` environments using bounded collections from `wrt-foundation`:
-
-```toml
-[dependencies]
-wrt-component = { version = "0.2", default-features = false }
-```
-
-In `no_std` mode, all collections use compile-time capacity limits for deterministic memory usage, making it suitable for ASIL-D safety-critical applications.
-
-## See Also
-
-- [WebAssembly Component Model Specification](https://github.com/WebAssembly/component-model)
-- [WIT (WebAssembly Interface Types)](https://github.com/WebAssembly/component-model/blob/main/design/mvp/WIT.md)
-- [API Documentation](https://docs.rs/wrt-component)
-- [Component Development Guide](../docs/source/development/components.rst)
+Works in `no_std` environments using bounded collections from `wrt-foundation`.
 
 ## License
 
-Licensed under the MIT license. See LICENSE file in the project root for details.
+MIT License