endless4s/endless

Endless is a Scala library that provides abstractions for building event-sourced and durable entities using tagless-final algebras. It supports deployment on both Akka and Apache Pekko clusters, handling sharding, passivation, and coordinated shutdowns. The system includes built-in serialization protocols for Protocol Buffers and Circe JSON, along with example applications demonstrating booking and vehicle management domains.

18 changes.

The project was rebranded to 'Endless' and rebuilt on Scala 2.13, introducing a new core event-sourcing library with foundational abstractions for durable entities. This period saw the removal of legacy persistence components, the addition of Pekko runtime support, and the implementation of serialization protocols for Circe and Protobuf. A comprehensive example application and extensive test coverage were also established to demonstrate the new architecture.

8 changes.

This period focused on introducing a new Pekko runtime module to support cluster-sharded entity deployment alongside the existing Akka infrastructure. The work included adding Pekko-specific configurations, serializers, and deployment traits, while expanding the example application to demonstrate both Akka and Pekko backends with new HTTP endpoints and domain models.

The \circe\ module now provides a set of classes (\CirceCommandProtocol\, \CirceEncoder\, \CirceDecoder\, \CirceIncomingCommand\, \CirceOutgoingCommand\) that integrate the Circe library into the core command protocol. This allows users to serialize and deserialize commands and replies using Circe's JSON encoders and decoders, replacing the need for manual or alternative serialization implementations within this module.

circe/src/main · high confidence

The example application now includes a dedicated Pekko implementation (PekkoApp.scala and Main.scala) in addition to the existing Akka implementation. This allows users to run the same domain logic (Bookings and Vehicles) using the Apache Pekko actor framework, demonstrating support for multiple runtime backends within the same codebase structure.

example/src/main/scala/endless/example/app/pekko · high confidence

The example application now includes protobuf definitions and Scala adapters for booking and vehicle entities. New protocol buffer schemas define commands, events, replies, and state for both domains, enabling structured communication for operations like placing or canceling bookings and managing vehicle speed and position. Corresponding adapter classes in the Scala adapter layer handle serialization and deserialization between internal domain objects and the protobuf journal formats, supporting durable entity persistence for these new capabilities.

example/src/main/protobuf, example/src/main/scala/endless/example/adapter · high confidence

The example application now includes core domain data structures in the \endless.example.data\ package, introducing \Booking\ and \Vehicle\ entities along with supporting types like \LatLon\, \Speed\, and \BookingEvent\. These models define the shape of booking requests (including origin, destination, and status) and vehicle state (position, speed, and recovery count), providing the foundational data layer for the example's vehicle endpoints and durable entity logic.

example/src/main/scala/endless/example/data · high confidence

The example application now includes concrete protocol handlers for Booking and Vehicle domains. BookingCommandProtocol implements the client-side interface for placing, retrieving, modifying, and cancelling bookings, mapping protobuf messages to domain algebra operations. VehicleCommandProtocol provides both server-side decoding and client-side sending for vehicle commands such as setting speed/position and retrieving vehicle state, enabling the example to demonstrate durable entity interactions with these specific command/reply patterns.

example/src/main/scala/endless/example/protocol · high confidence

A new reference.conf file has been added to the pekko-runtime module, establishing default configurations for the Pekko actor system. This includes setting the actor provider to cluster, defining custom serializers for Command and Reply data types, and binding these serializers to specific classes. Additionally, the configuration enables the JVM to exit automatically when the cluster performs a coordinated shutdown after a split-brain resolver decision.

pekko-runtime/src/main/resources · high confidence

The example application now includes dedicated configuration files (akka.conf and pekko.conf) that allow it to run on either the Akka or Apache Pekko actor framework. These configurations set up cluster providers, remote transports on distinct ports (61000 for Akka, 51000 for Pekko), and enforce message serialization using ScalaPB for specific domain events like BookingEvent and VehicleStateV1. A unified application.conf includes both, and logback.xml is configured to provide detailed DEBUG-level logging for cluster sharding components to aid in development and debugging.

example/src/main/resources · high confidence

The \logo\ directory now contains the project's official branding assets, including a full logo (\logo.svg\), a symbol-only variant (\logo-symbol-only.svg\), and an Open Graph image (\logo-open-graph.svg\). These SVG files provide the visual identity for the project across documentation, social sharing previews, and general use.

logo · high confidence

The documentation site is now bootstrapped with a new HTML template (\page.st\) that includes Open Graph meta tags for better social sharing and updated assets for the Paradox Material Theme. The site content has been expanded to include comprehensive guides on core abstractions (Entity, DurableEntity, Effector, Deployer), a getting-started section with dependency instructions, and an example application walkthrough featuring sequence diagrams.

documentation · high confidence

The library has been rebranded from Akka Persistence Tagless to Endless, with core types and packages migrated from \akka.persistence.tagless\ to \endless.core\. This release introduces the foundational abstractions for building event-sourced and durable entities, including \Entity\ and \DurableEntity\ traits for state management, \Deployer\ and \DurableDeployer\ for assembling repository runtimes, and \EntityT\/\DurableEntityT\ monad transformers for interpreting command handlers. It also provides the protocol layer (\CommandProtocol\, \CommandSender\) for distributed entity communication, interpreters for behavior and side-effects, and helper utilities like \StateReaderHelpers\ and \EventsFolder\ to streamline entity logic.

core/src/main/scala/endless · high confidence

This release adds a new \pekko-runtime\ module that provides the infrastructure to deploy and run entities using Apache Pekko Cluster Sharding. It includes Protobuf definitions and serializers for inter-node command and reply transport, a \ShardingCommandSender\ for routing commands to sharded entities, and an \EntityPassivator\ to manage entity lifecycle and passivation. The module exposes \PekkoDeployer\ and \PekkoDurableDeployer\ traits to wire up event-sourced and durable-state behaviors into Pekko actors, along with a \PekkoCluster\ resource for managing the actor system and coordinated shutdown. Users can now leverage Pekko's clustering and persistence capabilities through the existing Endless deployment abstractions.

akka-runtime/src/main/scala, pekko-runtime/src/main/scala · high confidence

Adds a new set of Scala components in the protobuf module that enable serializing and deserializing commands and replies using Protocol Buffers (via scalapb). This includes a ProtobufCommandProtocol trait for sending and handling commands, ProtobufEncoder and ProtobufDecoder objects for byte conversion, and specific command wrappers (ProtobufOutgoingCommand, ProtobufIncomingCommand). A test suite with a dummy proto definition validates the end-to-end flow of sending a command and receiving a reply.

protobuf · high confidence

Adds the initial example application code in the logic package, implementing domain-specific behaviors for bookings and vehicles. This includes \BookingEntityBehavior\ and \BookingEventApplier\ to handle booking state transitions (placing, changing origin/destination, canceling, accepting/rejecting), and \BookingSideEffect\ to manage post-recovery availability checks and passivation. Similarly, \VehicleEntityBehavior\ and \VehicleSideEffect\ provide logic for updating vehicle speed and position, tracking recovery counts, and enforcing aggressive passivation. The setup also includes sharding wrappers (\ShardedBookings\, \ShardedVehicles\) to expose these entities via a sharded actor model.

example/src/main/scala/endless/example/logic · high confidence

The example application now includes a new HttpServer component that exposes REST endpoints for managing bookings and vehicle telemetry. Users can create, retrieve, update, and cancel bookings, as well as query and set vehicle speed, position, and recovery counts via an HTTP4s server backed by Blaze.

example/src/main/scala/endless/example/app · high confidence

The example application now includes a set of new algebraic interfaces in the \endless.example.algebra\ package to define the core domain capabilities. \AvailabilityAlg\ provides a method to check capacity availability for a given time and passenger count. \BookingAlg\ defines the operations for managing individual bookings, including placing, retrieving, modifying origins/destinations, cancelling, and receiving capacity notifications, along with associated error types like \BookingAlreadyExists\ and \CancelError\. \BookingsAlg\ serves as a factory to retrieve specific booking algebras by ID. Similarly, \VehicleAlg\ exposes methods to control vehicle speed and position, retrieve current state, and manage recovery counts, while \VehiclesAlg\ acts as the factory for vehicle algebras by ID. These traits establish the functional interfaces used by the example's durable entities.

example/src/main/scala/endless/example/algebra · high confidence

The core persistence algebra and its runtime integration have been removed. This includes the deletion of the \EntityT\ and \RepositoryT\ interpretation layers, the \EventsFolder\ and \Folded\ data structures, and the \Entity\, \Repository\, \Command\, and \Partitioner\ typeclasses. The \ShardPartitioner\ runtime implementation for Akka Cluster Sharding has also been removed, along with the \Bookings\ example application that demonstrated these capabilities.

core/src/main/scala/akka, example/src/main/scala/akka, runtime · high confidence

A new reference configuration file has been added for the Akka runtime, defining cluster actor provider settings and custom serializers for Command and Reply data types. It also explicitly sets coordinated-shutdown.exit-jvm to on, ensuring the JVM exits when the cluster removes a node after a split-brain resolver decision.

akka-runtime/src/main/resources · high confidence

The application now defines specific implementation traits in the \app.impl\ package to wire together core domain components. The \Availabilities\ trait provides a mock availability check that logs status and simulates a delay, while the \Bookings\ and \Vehicles\ traits establish the necessary implicit protocols, entity name providers, ID codecs, and event/state adapters required for their respective command handling. This structure supports the underlying goal of enabling multiple concurrent runtime instances.

example/src/main/scala/endless/example/app/impl · high confidence

The project has been rebranded as 'endless', a Scala library for describing event-sourced entities using tagless-final algebras with implementations for Akka and Pekko. The build configuration has switched from Scala 3 to Scala 2.13 (updating .scalafmt.conf and README badges), and the documentation site has been bootstrapped with new contributing guidelines, a code of conduct, and updated release processes.

(repo-wide) · high confidence

Added test coverage for CirceCommandProtocol; Added test coverage for the example application; Added test suites for Effector and StateReaderHelpers; Added tests for EntityT and DurableEntityT interpretation; Added tests for Pekko protobuf serialization with Scala 3 support.

The project has significantly upgraded its core libraries and build infrastructure. Key dependency updates include Akka to 2.6.21, Cats to 2.13.0, Cats-Effect to 3.7.1, http4s to 0.23.37, and Circe to 0.14.16. The build system has been upgraded from sbt 1.5.4 to 1.13.0, with corresponding updates to plugins such as sbt-wartremover (2.4.16 to 3.6.1), sbt-scoverage (1.8.2 to 2.4.4), and the addition of sbt-version-policy and sbt-ci-release. Additionally, ScalaPB support has been added via the sbt-protoc plugin.

project · high confidence

The build system has been updated to support Scala 2.13.18 and Scala 3.9.0, replacing the previous Scala 2.13.3 baseline. A new \pekko-runtime\ module has been introduced alongside the existing \akka-runtime\, allowing users to choose between Akka and Pekko for persistence backends. The project structure has also been expanded with new helper modules for Circe and Protobuf, and the core library now includes additional test dependencies like \cats-effect\ and \munit\.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 57 → 58 (+0.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 96 (-3.7)
• Architecture 100 → 97 (-2.7)
• Maturity 55 → 49 (-5.8)
• Readiness 61 → 56 (-5.1)
• Security 46 → 58 (+12.5)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Off-boarding risk: anonymized user #1
• Test reliability not included
• complexity unreadable for .scala — churn × complexity hotspots could not be measured

• AkkaCluster.createCluster (cognitive 21) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/AkkaCluster.scala)
• AkkaCluster.managedResource (cognitive 31) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/AkkaCluster.scala)
• Documentation: no usage examples (README.md)
• Duplicated block (11 lines × 4) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/DurableShardedRepositoryDeployer.scala)
• Duplicated block (17 lines × 2) (example/src/main/scala/endless/example/app/akka/AkkaApp.scala)
• Duplicated block (17–18 lines × 4) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/DurableShardedRepositoryDeployer.scala)
• Duplicated block (20 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/ShardingCommandSender.scala)
• Duplicated block (21 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/DurableShardedRepositoryDeployer.scala)
• Duplicated block (21 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/serializer/ReplySerializer.scala)
• Duplicated block (21–22 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/EventSourcedShardedRepositoryDeployer.scala)
• Duplicated block (24 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/EntityPassivator.scala)
• Duplicated block (24 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/EventSourcedShardedRepositoryDeployer.scala)
• Duplicated block (29 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/AkkaCluster.scala)
• Duplicated block (32 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/serializer/CommandSerializer.scala)
• Duplicated block (33 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/DurableShardedRepositoryDeployer.scala)
• Duplicated block (36 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/protobuf/ScalaPbSerializer.scala)
• Duplicated block (5 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/AkkaCluster.scala)
• Duplicated block (5 lines × 3) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/DurableShardedRepositoryDeployer.scala)
• Duplicated block (6 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/EventSourcedShardedRepositoryDeployer.scala)
• Duplicated block (7 lines × 2) (akka-runtime/src/main/scala/endless/runtime/akka/deploy/internal/EventSourcedShardedRepositoryDeployer.scala)
• …and 21 more

• 6 commits — 5 feature/other, 1 fixes

• .github/workflows — 4 commits
• (root) — 1 commit
• documentation/src — 1 commit

• fix: Fix the dead links in the README and the documentation site
• change: Describe the release process as it actually works
• change: Give Codecov the token its uploads have been failing without
• change: Give the docs deploy the history it needs to know its version
• change: Refresh the dependency and toolchain set
• change: Stop checkout credentials hijacking the docs deploy

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

endless4s/endless was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.