Submodule capabilities at a glance.

Can do now

• Define typed decision flows with Axon/Transition/Outcome contracts, explicit Bus wiring, and `Never` error type for infallible pipelines. 71 published examples covering all 12 crates, with support tiers tracked in `.ranvier-examples-manifest.json`. `try_outcome!` macro converts `Result<T, E>` to `Outcome` with early return for ergonomic error handling in transitions, and `Outcome::from_result()` / `Outcome::and_then()` / `Outcome::map_fault()` combinators enable functional composition.
• Run protocol-agnostic core circuits through HTTP ingress adapters with dynamic routing, request extractors, lifecycle controls, middleware composition, and per-path policy overrides. `QueryParams` is automatically injected into Bus from URI query strings with typed extraction via `get_parsed::<T>()`. `RouteGroup` scopes shared path prefixes and guards with up to 2-level nesting, `post_json_out` provides bodyless POST→JSON endpoints, and `PageParams`/`Paginated<T>` offer built-in pagination with automatic clamping.
• Apply HTTP security/policy stacks with `ranvier-guard` crate (15 Guards: Cors, AccessLog, SecurityHeaders, IpFilter, RateLimit, Compression, RequestSizeLimit, RequestId, Auth, ContentType, Timeout, Idempotency + advanced feature: Decompression, ConditionalRequest, Redirect) — pipeline-first middleware visible in Schematic, with `HttpIngress::guard()` auto-wiring, per-route `guards![]` composition, `GuardIntegration` trait for Bus↔HTTP bridging, RateLimitGuard bucket TTL with stale bucket lazy cleanup, and TrustedProxies XFF anti-spoofing with trusted proxy chain validation. `CorsGuard::permissive()` provides a one-line CORS configuration for development environments.
• Generate OpenAPI docs and Swagger UI from request/response contracts via `ranvier-openapi`. `post_typed::<T>()` auto-captures request body JSON Schema via schemars, and path parameters (`:id`) are auto-documented as OpenAPI parameters. With the `validation` feature, `ValidatedJson<T>` plus `post_validated_json_out`/`put_validated_json_out`/`patch_validated_json_out` apply DTO semantic validation as stable 422 field-error responses.
• Serve static directories and SPA fallback with expanded MIME support (18 types), ETag-based 304 Not Modified, directory index, immutable cache detection, pre-compressed serving (.br/.gz priority), Range request support (206 Partial Content), and render Askama HTML templates via feature-gated `TemplateResponse<T>`.
• Handle WebSocket/SSE real-time flows and inject connection/session context into Bus.
• Build LLM-as-Transition pipelines for AI classification, content moderation, and policy enforcement.
• Write in-process HTTP integration tests with `TestApp/TestRequest/TestResponse` and runtime path assertions with `AxonTestKit`/`Timeline`.
• Store and query traces with `ranvier-inspector` TraceStore (VecDeque ring buffer with configurable TTL), secure endpoints with BearerAuth (release build warning for unauthenticated Inspector), and route alerts via AlertHook/AlertDispatcher.
• Run session/job/persistence patterns and resume faulted workflows from checkpoints with PersistenceStore and compensation hooks.
• Validate API compatibility and detect structural drift with cargo-semver-checks and schematic diff/policy CLI commands.
• Monitor per-node metrics (throughput, latency percentiles, error rate), inspect in-transit payloads, manage dead letters, set conditional breakpoints, and detect stalled nodes through the built-in Inspector REST + WebSocket server. DebugControl uses parking_lot::Mutex + AtomicBool/AtomicU8 for panic safety. Extract execution lineage from stored traces (`GET /api/v1/lineage/:trace_id`) and structurally diff two traces (`GET /api/v1/traces/diff?a=&b=`) to reveal path divergence, outcome differences, and latency deltas.
• Register JSON Schema on circuit nodes via `.with_input_schema::<T>()` builder API or `#[transition(schema)]` macro attribute. Inspector serves schema-enriched route metadata (`GET /api/v1/routes`), relays HTTP requests into running circuits (`POST /api/v1/relay`), and generates empty templates or random sample payloads from schema (`POST /api/v1/routes/schema`, `POST /api/v1/routes/sample`).
• Configure production infrastructure with `RanvierConfig` (`ranvier.toml` + env overrides + profile system), structured logging (`init_logging()` with JSON/pretty/compact), and optional TLS via `rustls`.
• Return RFC 7807 Problem Details error responses with `ProblemDetail`/`IntoProblemDetail`, retry faulted transitions with `RetryPolicy` (fixed/exponential backoff) via `Axon::then_with_retry()`, enforce execution time limits with `Axon::then_with_timeout()`, and recover from transition panics via `Axon::catch_unwind()` converting panics to `Outcome::Fault`.
• Provide quantitative performance baselines with criterion micro-benchmarks (Axon latency, Bus operations, Transition chains) and Axum/Actix-web comparison servers.
• Demonstrate real-world patterns through three reference applications: Todo API (CRUD + JWT auth), Chat Server (multi-room WebSocket), and E-commerce Order Pipeline (4-stage Saga compensation + audit trail + multi-tenancy).
• Automate version migration with `ranvier migrate --from 0.20 --to 0.25` for import path replacement, crate dependency swaps. TOML-based migration rules (text_replace, rename_import, warn) with --dry-run mode.
• Export Prometheus exposition metrics from Inspector `/metrics` endpoint, auto-initialize OTLP TracerProvider via TelemetryConfig, log HTTP requests with AccessLogGuard path redaction, persist audit events to PostgreSQL with PostgresAuditSink hash-chain integrity, rotate audit logs with FileAuditSink (BySize/ByDate/ByBoth policies), auto-register OpenAPI SecurityScheme (bearerAuth) with ProblemDetail (RFC 7807) error responses, build Merkle audit trees over event batches with `MerkleAuditSink` (feature-gated `merkle`) — SHA-256 binary tree, `MerkleProof` inclusion proofs, pluggable `AnchorService` for external root anchoring — and compose audit logging into Axon chains with `AuditLog<S>` Transition (pass-through with non-blocking sink writes, `AuditAction`/`AuditActor` typed events). Safe dynamic SQL `QueryBuilder` patterns are documented through cookbook/example/app-local helpers rather than a public `ranvier-db` crate.
• Understand framework design philosophy through PHILOSOPHY.md ('Opinionated Core, Flexible Edges' principle) and architecture decision rationale via DESIGN_PRINCIPLES.md (ADR format covering Paradigm Test, Tower Separation, and Opinionated Core enforcement).
• Implement authentication via Transition-based (Bus context, Schematic visualization) or Tower integration (AsyncAuthorizeRequest) approaches, with auth-comparison guide covering 7-feature table, benchmarks, decision tree, and migration paths.
• Define inline pipeline steps with `Axon::then_fn()` closure-based Transitions and inject type-safe HTTP request bodies via `post_typed::<T>()` / `put_typed::<T>()` / `patch_typed::<T>()` with `Axon::typed::<In, E>()` typed-input pipelines — automatic JSON deserialization with compile-time type guarantees. `post_json()` / `put_json()` / `patch_json()` provide JSON body deserialization without requiring `JsonSchema` derive, and `Axon::execute_simple()` eliminates the `&()` argument for `Res=()` pipelines.
• Diagnose pipeline faults with `TransitionErrorContext` — automatically injected into Bus on `Outcome::Fault` with pipeline name, transition label, and zero-based step index.
• Write concise pipeline tests with `ranvier-test` crate: `TestBus` fluent builder, `TestAxon` single-call executor, and `assert_outcome_ok!` / `assert_outcome_err!` assertion macros with optional value inspection closures.
• Build streaming pipelines with `StreamingTransition` trait producing `Stream<Item>` instead of single `Outcome`. `StreamingAxon` runtime type, `Axon::then_stream()` / `then_stream_with_timeout()` terminal builders, SSE HTTP endpoints via `post_sse()` / `post_sse_typed()`, stream timeouts (init/idle/total), `TestAxon::run_stream()` + `assert_stream_items!` for testing, `#[streaming_transition]` macro for boilerplate-free definition, and `StreamingAxon::map_items()` for per-item stream transforms (PII filtering, token counting, format conversion).

Current limitations

No active limitation items.

Product boundaries

• Token/claim-to-role mapping for inspector auth headers is not built into core runtime and depends on deployment gateway policy. deployment-gateway

Can do now

• Inspect command surface and usage quickly with `ranvier --help`.
• Export schematic artifacts from workspace examples.
• Compare schematic changes across git refs with `ranvier schematic diff`.
• Run structural policy checks from TOML rules and fail with non-zero exit on violations.
• Validate schematic schema-version compatibility before processing input artifacts.
• Generate trace projection artifacts from schematic/timeline/example inputs.
• Scaffold new projects from macro-first templates via `ranvier new`.
• Run version migration workflows via `ranvier migrate` with dry-run/verbose/JSON modes.
• Browse and fetch example schematics from remote or local catalogs via `ranvier catalog list/fetch/verify`.
• Execute API test collections headlessly via `ranvier test` — sequential HTTP execution with assertion evaluation (10 operators), capture chaining, environment interpolation, glob support, and output in text/JSON/JUnit XML formats for CI integration.
• Scaffold new projects interactively via `ranvier new` with dialoguer-based template selection (16 templates including domain-specific saga/llm-agent/compliance/webhook-delivery/multi-tenant-api/notification-hub), dependency chooser (DB/Auth/Observability), auto-generated `.ranvier/collections/` and `.env.example`.
• Generate self-contained HTML status pages from Schematic JSON via `ranvier status build` and `ranvier status from-schematic`. Restored from ranvier-status crate consolidation in v0.21.
• Scaffold pattern-focused projects via `ranvier new --template saga/screening/pipeline`. Existing `compliance`→`screening` and `llm-agent`→`pipeline` renamed with deprecated alias support.

Current limitations

No active limitation items.

Product boundaries

No explicit boundary items.

Can do now

• Render schematic node/edge graphs in 3D space with layer separation (Guard/Transition/Compensation) using Bevy 0.18 GPU-accelerated renderer.
• Navigate large DAG graphs with Orbit/Fly/TopDown camera modes (1/2/3/T/R) and Ctrl+F search with Focus camera integration.
• Visualize real-time data flow on edges with outcome-based pulse animation (green=success, red=error, yellow=slow) and directional arrowheads.
• Track real-time Axon execution via WebSocket events with node state visualization (Running/Completed/Faulted/Stalled/Paused) and throughput-based scaling.
• Inspect payload JSON in tree view (F key) from CapturedEvents when Inspector runs with CAPTURE_PAYLOADS=full mode.
• Set breakpoints via CRUD panel (B key) or right-click context menu, and control execution flow with Debug bar (Resume/Step/Pause).
• Inspect service internals via Bus Inspector, Circuit Explorer, Routes, DLQ viewer, Relay Proxy, and Trace Timeline (zoom/scroll).
• Persist settings (Inspector URL, token, refresh intervals) to ~/.ranvier-studio.toml via Settings panel (S key).

Current limitations

No active limitation items.

Product boundaries

• Studio is not the primary IDE surface for inline source navigation (VSCode extension scope). studio
• Cannot run in mobile or web browsers — desktop native only. studio

Can do now

• Built with Ranvier framework (dogfooding) using bus_injector, Guards (CORS, AccessLog, SecurityHeaders, RequestId), and Axon pipelines.
• Proxy all 28 Inspector API endpoints via generic Relay Transition pattern (GET/POST/PATCH/DELETE with path param substitution).
• Serve SvelteKit 5 + @xyflow/svelte static dashboard (8 pages) via serve_dir() with SPA fallback for browser-based team monitoring.
• Display service health status (operational/degraded/down), node/circuit/route summaries, and DLQ alerts on the dashboard home.
• Show KPI summary cards (total throughput, avg latency, error rate sum, node/circuit counts) with per-node metrics and configurable auto-refresh (2/5/10/30s).
• Visualize circuit topology in a SvelteFlow interactive schematic with node selection, detail panel, and breakpoint toggle (create/remove).
• Monitor events with type dropdown filter, text search, real-time polling (2s), and new event highlight animation.
• Display trace timeline with slow request detection (>200ms), Gantt chart color legend (OK/Slow/Fault/Active), and auto-refresh.
• Manage dead letter queue items with expandable JSON payloads, Retry and Discard actions, and item count badges.
• Deploy via Docker (multi-stage Dockerfile with Node.js frontend build + Rust binary) and docker-compose.

Current limitations

No active limitation items.

Product boundaries

• No 3D GPU-accelerated visualization — that capability is in the Studio (Bevy) desktop app. studio
• No WebSocket live streaming — uses HTTP polling-based refresh. studio

Can do now

• Render circuit graphs from `schematic.json` and sync them with the `Ranvier Circuit Nodes` panel.
• Jump to source locations from selected circuit nodes when mappings are available.
• Highlight mapped circuit nodes from the active editor file/line context.
• Project `diagnostics.json` results into webview, sidebar, and VSCode Problems.
• Reveal the mapped circuit node from the current editor line via command palette.
• Navigate next/previous node-linked issues with commands and default shortcuts.
• Provide localized EN/KO UX and keybinding override templates for team adoption.
• Auto-connect to Inspector servers and visualize per-node metrics with real-time heatmap overlays (traffic/latency/errors/none).
• Monitor Inspector lifecycle events in the event stream panel with node/type/text filters.
• Visually alert on stalled nodes exceeding thresholds with pulsing glow animations.
• Insert 6 Rust code snippets (rvtransition, rvroute, rvaxon, rvbus, rvtest) for rapid Ranvier development.
• Browse and run any example from catalog.json via the integrated terminal (`ranvier.runExample` command).
• Test API endpoints through the Circuit-Aware API Explorer sidebar — auto-discover routes from Inspector, compose requests with headers/params/body/auth tabs, view response with status/duration/circuit trace, and navigate offline with cached schemas.
• Manage request collections in `.ranvier/collections/` with save, duplicate, rename, delete, filter, sort, and group-by operations. Auto-save execution history with configurable retention policy.
• Generate empty body templates and faker-filled sample data from JSON Schema (server-first via Inspector, client-side fallback). Save named presets per request and interpolate `{{variable}}` from `.ranvier/environments/` files.
• Export collections to `.ranvier-bundle.json` or single requests to `.ranvier-request.json` with secret redaction (auto-detect sensitive patterns). Import with conflict detection and resolution dialog.
• Execute batch requests with sequential progress tracking, assertion evaluation (10 operators, JSON path targets), body validation against JSON Schema, and JUnit-compatible result summary. Keyboard chord shortcuts (Ctrl+R prefix) for send, template, and faker actions.
• Test WebSocket endpoints with bidirectional message log, connect/disconnect lifecycle, auto-reconnect, subprotocol headers, and message filtering (text/JSON, keyword search).
• Test SSE endpoints with event stream log (type, data, id, retry), event-type filtering, Last-Event-ID reconnection support, and session history.
• Visualize streaming pipeline nodes in the Schematic viewer with dashed purple borders, stream icons, and animated edges distinguishing `StreamingTransition` from regular `Transition` nodes.
• Consolidate auxiliary extension tools (Circuit, Toolbox, Features, API) into a unified, tabbed sidebar view powered by Svelte 5 for fast and seamless context switching.
• Ensure stable rendering and avoid runtime/CSP conflicts during Vite/Svelte 5 initialization across API Explorer, Toolbox, and Feature Hub panels.
• Provide 4 Complex Workflow snippets (Saga Compensation, Cascade Screening, Typed Pipeline, Branch Routing) and pattern-based learning paths in the Toolbox category.

Current limitations

No active limitation items.

Product boundaries

No explicit boundary items.