# Changelog

## Score

- CAI 56 → 56 (+0.3)

## Lenses

- Code Health 54 → 54 (+0.0)
- Architecture 97 → 97 (+0.0)
- Maturity 57 → 57 (+0.0)
- Readiness 60 → 71 (+10.4)
- Security 63 → 63 (+0.0)
- Domain Modelling 60 → 60 (+0.0)
- Event-Driven 83 → 83 (+0.0)
- Performance 54 → 54 (+0.0)

## Resolved (7)

- Overloaded `CloneWith` methods with different parameter types (array vs IEnumerable). This creates redundancy as an array can be passed as an IEnumerable.
- Overloaded `Failed` methods with different parameter types (none, IEnumerable, array). This is a common pattern but can be inconsistent if not all variations are supported or if the distinction is unclear.
- Overloaded `With` methods with different parameter types. Similar to `CloneWith`, this creates redundancy.
- Overloaded methods with different parameter types (object vs string) for the same operation 'SucceedWith'. While technically distinct, using an object for one and a string for the other can be confusing if the intent is to represent a command in both cases.
- Redundant or confusingly named operations for event emission. `Emit` and `EmitAll` perform the same core action (emitting events), but the distinction between single and multiple is not immediately obvious from the names alone, and `EmitAll` is a common pattern that could be unified or clearly distinguished.
- Typo in test class name: 'Comitted' instead of 'Committed'. The correct spelling 'Committed' is used elsewhere (e.g., CommittedEvent, CommittedSnapshot).
- redundant comment (examples/web/Akkatecture.Examples.Api/Controllers/Models/ResourceResponseModel.cs)

## New (5)

- Both 'AggregateEventUpcaster' and 'DomainEventReadAdapter' have a 'FromJournal' method that takes an object and a string manifest. This suggests a shared responsibility for deserializing/describing journal events, but the return types (IEventSequence vs IEventSequence) and the context (upcasting vs reading) are slightly different. The naming 'FromJournal' is used in both, but one is for upcasting and one is for reading, which might be confusing.
- Inconsistent naming for event emission. One method is named 'Emit' (singular) and the other 'EmitAll' (plural). While distinct in arity, the naming convention for the singular case ('Emit') vs the plural case ('EmitAll') is slightly inconsistent with common patterns like 'Emit' and 'EmitBatch' or 'EmitRange'. However, the primary inconsistency is that 'Emit' takes a generic type parameter and a specific event, while 'EmitAll' takes an array of the interface. A more consistent API might use 'Emit' for single and 'EmitMany' or 'EmitBatch' for multiple, or ensure the naming convention is parallel.
- Inconsistent parameter types for result creation. 'SucceedWith' accepts either an ICommand or a string (commandId). 'FailWith' accepts either an ICommand or a string (commandId). This creates two different ways to create success/failure states, which can be confusing. It is unclear if passing the command object is preferred over the ID.
- The namespace 'Akkatecture.Configuration.DependancyInjection' contains a typo in the word 'Dependency' (spelled as 'Dependancy').
- redundant comment (examples/cluster/Akkatecture.Examples.Seed/Program.cs)

## API surface

- Unchanged — 5 HTTP endpoints

## Architecture

- Unchanged — 0 containers · 2 contexts · 1 edges