Stratara.ServiceDefaults 4.0.1

• net10.0

  • Destructurama.Attributed (>= 5.3.0)
  • Microsoft.Extensions.Http.Resilience (>= 10.9.0)
  • Microsoft.Extensions.ServiceDiscovery (>= 10.9.0)
  • OpenTelemetry.Exporter.OpenTelemetryProtocol (>= 1.18.0)
  • OpenTelemetry.Extensions.Hosting (>= 1.18.0)
  • OpenTelemetry.Instrumentation.EntityFrameworkCore (>= 1.18.0-beta.1)
  • OpenTelemetry.Instrumentation.Http (>= 1.18.0)
  • OpenTelemetry.Instrumentation.Runtime (>= 1.18.0)
  • RabbitMQ.Client.OpenTelemetry (>= 1.0.0-rc.2)
  • Serilog.Extensions.Hosting (>= 10.0.0)
  • Serilog.Formatting.Compact (>= 3.0.0)
  • Serilog.Settings.Configuration (>= 10.0.1)
  • Serilog.Sinks.Async (>= 2.1.0)
  • Serilog.Sinks.Console (>= 6.1.1)
  • Serilog.Sinks.File (>= 7.0.0)
  • Serilog.Sinks.OpenTelemetry (>= 4.2.0)
  • Stratara.Shared (>= 4.0.1)

### Added

- **Bundles about one aggregate are now applied one at a time within a process, a handler can say
 "not yet", and the workers' parallelism is configurable.** The projection worker and the saga
 worker open one consumer per processor on a shared queue, so two bundles published milliseconds
 apart — the fact that creates an entity and the first fact about it — landed on two consumers and
 ran at the same time, and whichever finished first won. A projection that then found no row for
 the follow-up could only warn and acknowledge a fact it never applied, or throw and have the
 bundle discarded; either way the read model lost the fact until a replay. The command worker has
 never had this problem, because it takes a per-aggregate lock before it runs a command.

 Both workers now take the same lock, keyed on the streams the bundle's events belong to. Bundles
 about different aggregates still run in parallel; bundles about one aggregate queue behind each
 other. The guarantee is per process — two replicas consuming the same subscription do not
 serialise against each other — and the delivery guarantee now says so explicitly.

 The lock serialises but does not order, so the residual case gets a second chance:
 `PrecedingFactMissingException(streamId, eventTypeName)` in `Stratara.Abstractions` is the one
 exception the workers retry — five attempts from 100 ms doubling, about three seconds in all,
 under the new named policy `ResilienceNames.PrecedingFact`, with every aggregate lock released
 between attempts so the creating fact can land in the gap. Once the retries are exhausted the
 bundle fails as any unhandled failure does, and the warning logged on each attempt
 (`104_010` for projections, `110_005` for sagas) names the stream and the event type. Any other
 exception fails the bundle on the first attempt, as before.

 `Projections:DegreeOfParallelism` and `Sagas:DegreeOfParallelism` set the number of consumers each
 worker opens; a value that is not a positive number means the processor count, and `1` gives a
 worker that applies every bundle in the order the transport delivers it.

 A consumer that changes nothing gets the serialisation and the default parallelism it had. A
 consumer that implements `IMessageBus` itself is unaffected: the retry runs inside the worker
 before the transport sees an outcome. `BucketLockPool`, previously internal to the mediator, is
 now public in `Stratara.Abstractions` so that every worker takes the same lock from the same
 place; the mediator's own copy is gone.

### Changed

- **A published version now announces itself in the repository.** The release workflow gained a
 third job that creates the GitHub release entry for the tag once the packages have reached
 nuget.org, with the changelog section for that version as its notes — the same section the
 packages already carry as their release notes. A prerelease tag is marked as one, so it does not
 displace the current stable version. Until now the release list was maintained by hand and had
 fallen behind: 4.0.0 was on nuget.org while the repository still presented 3.4.0 as current.
 Nothing about what publishes, when, or on whose approval has changed.