Roadmap

The process model as data, with two syntaxes building the same model.

• Done
  Process model as data (Process, StepNode, AwaitNode) with structural equality
• Done
  Fluent syntax, and the opt-in pipe syntax (>>)
• Done
  Extension member literals such as 15.Minutes and 3.Times
• Done
  Result<TOk, TError>, the [Union] marker, Mermaid rendering

Slices with pure decisions and a deterministic in-memory runtime.

• Done
  Slices with a static pure Decide, and state via IState
• Done
  Explicit correlation with StartOn and Await
• Done
  Deterministic InMemoryRuntime with a virtual clock: retries, reverse compensation, timeouts, duplicates, correlation
• Done
  samples/Shop and library scaffolding (CI on 3 operating systems)

Commands, domain events and integration events as different things, enforced at build time.

• Done
  Message taxonomy, contracts split from slices, explicit publication mapping
• Done
  Runtime rules: one owner per command, only integration events published from outside
• Done
  Analyzers WYRD0001 to WYRD0004, contract snapshots with breaking-change detection (WYRD0200 to WYRD0204) and a code fix
• Done
  Multi-version publishing and upcasters for subscribers

A message-driven engine that behaves like a distributed system while staying deterministic.

• Done
  Steps as command messages with Accepted / Rejected / Faulted replies; everything crosses the queue as JSON
• Done
  One transaction per message (state, inbox, outbox, timers) behind a storage port, with an in-memory store
• Done
  Retries with backoff, early events parked, projections with redelivery protection
• Done
  Process outcomes as commands (.OnCompensated), Wyrd.Testing Given/When/Then
• Done
  Source-generated JSON with analyzers WYRD0300 to WYRD0302, and Native AOT checked in CI

Failure simulation with shrinking, explicit retry semantics, suspension, the structure fingerprint, steps that read earlier events and ordered read models.

• Done
  Skuld.SimulateAsync: seeded futures with faults, redelivery and reordering, invariants, replay by seed
• Done
  Engine fixes found by Skuld: attempt-aware replies, unknown-outcome steps compensated, thread-safe type registry
• Done
  Typed invokers in the pipe syntax; only steps that read earlier events are invoked dynamically (Native AOT-compatible)
• Done
  Analyzers WYRD0011 (how a step is undone), WYRD0012 (await without .Within), WYRD0013 (process style), WYRD0020 (exhaustive union switch)
• Done
  Retry semantics: every step declares .Retry(...) or .NoRetry("why") (WYRD0014); undos and the outcome always insist; WYRD0010 removed
• Done
  Suspend instead of guessing, with ResumeAsync / CompensateAsync and opt-in .OrCompensate()
• Done
  Process structure fingerprint per instance: a changed definition suspends in-flight instances
• Done
  Steps that read the events of earlier steps (and awaited events), checked before the first message
• Done
  Ordered projections per stream
• Done
  Shrinking: reduce a failing future to the fewest perturbations that still break the invariant

Capture in-memory instance histories and replay them against today’s process definition with Urd.

• Done
  dotnet wyrd asyncapi
• Done
  dotnet wyrd diagram
• Done
  Process instance history capture
• Done
  dotnet wyrd replay <history.json> --as-test

The durable runtime, the only place with real I/O, and services that talk over a broker.

• Done
  Integrations (Integration<TCommand, TEvent, TError>): the only I/O, with idempotency keys and recorded outcomes
• Done
  IWyrdRuntime and IWyrdBuilder<T>: the same application code and modules on every host
• Done
  EF Core host (PostgreSQL, SQL Server): state, inbox, outbox, timers and read models in one transaction, the database as the queue
• Done
  One retry layer, operators (resume, compensate) and a hardened queue with health metrics
• Done
  Explicit retention for everything a host keeps, and a history archive
• Done
  RabbitMQ transport between services (Wyrd.RabbitMq)
• Done
  OpenTelemetry with process-level traces
• Done
  Catching up a projection added to a store that already has data

Teaching the mental model matters as much as the code.

• Done
  Guide: From classic DDD to Wyrd
• Done
  Guidance on shared invariants living on the state or in pure domain policies
• Done
  Rich aggregate in samples/Shop (Order, OrderLine, Money)
• Done
  Guide: modelling read models for screens and reports
• Done
  Guide: running durable, with retention and operators
• Done
  Docs site with the mental model first, API reference second

Everything needed to run Wyrd with confidence.

• Open
  Process versioning: a snapshot of every process, with breaking changes failing the build until in-flight instances are migrated
• Done
  Native AOT verified end to end
• Done
  dotnet wyrd CLI and an MCP server for agents