docs: add roadmap and link from README

- Create doc/roadmap.md with 9 planned features: concurrent batch
  generation, conditional components, structured serialization,
  generation statistics, generic components, EnTT integration,
  Python/Node.js/.NET wrappers
- Add roadmap link to README

Author: dasmig

README.md

@@ -99,3 +99,5 @@ auto seeded = eg::instance().generate(42);
 ```
 
 For the complete feature guide — component dependencies, custom types, seed signatures, batch generation, groups, weights, validation, event hooks, and more — see the **[Usage Guide](doc/usage.md)**.
+
+For planned features — concurrent generation, conditional components, structured serialization, EnTT integration, and more — see the **[Roadmap](doc/roadmap.md)**.

doc/roadmap.md

@@ -0,0 +1,39 @@
+# Roadmap
+
+Planned features for the entity-generator library. Items are not in priority order.
+
+## Concurrent Batch Generation
+
+`generate_batch_async(count)` generates entities in parallel while preserving deterministic seeding. The approach: pre-derive N entity seeds from the engine sequentially (cheap), then dispatch N independent generation calls concurrently — each with its own pre-computed seed. Same seeds produce the same entities regardless of thread scheduling. Returns `std::vector<entity>` in seed order.
+
+## Conditional Components
+
+A component can declare `bool should_generate(const generation_context& ctx)` (default `true`). The generator checks this before producing the value. Unlike weights (probabilistic), this is logic-driven — e.g., "only generate `stats` if `class` is `Warrior`". Zero-cost default: the virtual returns `true`.
+
+## Structured Serialization
+
+`entity::to_map()` returning `std::map<std::wstring, std::wstring>` for easy integration with JSON/XML serializers. Optionally `entity::from_map()` with a component registry for deserialization/replay.
+
+## Generation Statistics
+
+A built-in observer (or standalone stats struct) that tracks: entities generated, components skipped (weight), retries per component, validation failures. Accessible via `eg::stats()` or as a reusable observer. Useful for tuning weights and retry limits.
+
+## Generic Components
+
+A library of ready-made, reusable component templates for common patterns — e.g., `choice_component<T>` (pick from a list), `range_component<T>` (uniform random in a range), `constant_component<T>` (fixed value). Reduces boilerplate for simple components that don't need custom logic.
+
+## EnTT Integration
+
+An adapter layer that bridges entity-generator with the [EnTT](https://github.com/skypjack/entt) ECS library. Generated component values are automatically assigned as EnTT components to an entity in a registry, enabling direct use in ECS-based game loops without manual mapping.
+
+## Python Wrapper
+
+A Python binding (via pybind11 or nanobind) exposing the entity-generator API to Python. Components are defined as Python classes inheriting from a base, registered with the generator, and entities are returned as typed Python objects. Enables rapid prototyping and scripting of entity generation logic.
+
+## Node.js Wrapper
+
+A Node.js addon (via node-addon-api / N-API) providing the entity-generator API to JavaScript/TypeScript. Components are defined as JS classes, entities are returned as plain objects. Supports both synchronous and async generation for server-side and tooling use cases.
+
+## .NET Wrapper
+
+A .NET binding (via C++/CLI or P/Invoke) exposing the entity-generator API to C# and other .NET languages. Components are defined as C# classes implementing an interface, entities are returned as strongly-typed objects. Targets integration with Unity and other .NET game frameworks.