7mind/izumi

Distage is a high-performance, multi-platform dependency injection framework for Scala that supports both JVM and Scala.js targets. It provides a type-safe DSL for defining modules, planning object graphs, and managing lifecycle resources, with deep integration for effect systems like Cats Effect and ZIO. The system features advanced capabilities such as compile-time plan verification, dynamic proxy generation for circular dependencies, and a modular plugin architecture for extensibility.

86 changes.

The project migrated its build infrastructure from sbt to Scala CLI, removing legacy plugin dependencies and updating core libraries to support Scala 3. This period focused on modernizing the distage dependency injection framework with subcontext support and non-sequential provisioning, while significantly expanding the Logstage logging library with structured rendering and multi-backend integration.

61 changes.

This period focused on expanding the framework's support for Scala.js and Scala Native, alongside deep integration with Cats Effect and ZIO through dedicated support modules and typeclass instances. Significant architectural improvements were made to the dependency injection engine, including robust circular dependency resolution via proxies, a new compile-time plan checker, and a refactored injector API. The logging subsystem was also modernized with strict, effect-agnostic APIs, while the test kit and Docker integration modules received substantial refactoring and feature additions.

72 changes.

This period focused on extending the Izumi ecosystem to support Scala 3 and Scala.js, implementing macro-based infrastructure for dependency injection, logging, and configuration across these new targets. Significant work included replacing CGLIB with ByteBuddy for dynamic proxies, adding comprehensive test coverage for the new platforms, and refactoring core modules to handle platform-specific constraints and reflection limitations.

15 changes.

This period focused on rewriting core macro implementations for Scala 3 and extending platform support to Scala.js across the LogStage, Distage, and Fundamentals libraries. Key developments included adapting dependency injection and testing toolkits for JavaScript environments, migrating build tooling to Scala CLI, and enhancing resource handling and argument extraction capabilities.

A new \functional\ package object has been added to \izumi.fundamentals.platform\, introducing \Identity\, \Identity2\, and \Identity3\ type aliases along with their corresponding companion objects. These aliases provide simplified type representations for single, two-parameter, and three-parameter contexts, which can be used to simplify type signatures in functional programming patterns within the library.

fundamentals/fundamentals-functional/src/main/scala/izumi/fundamentals · high confidence

New Scala 3-specific reflection utilities have been added to the platform, including \ReflectionUtil\ for analyzing type structures (such as checking for strong types, extracting intersection/union members, and reading DI annotations) and \TrivialMacroLogger\ to enable debug logging of macro expansions via the \izumi.debug.macro.rtti\ system property. These components provide the underlying support for Scala 3 macro-based reflection features within the library.

fundamentals/fundamentals-platform/src/main/scala-3/izumi/fundamentals/platform/reflection · high confidence

The library now supports Scala Native by introducing a new \IzJvm\ trait in the \.native\ source directory. This component provides platform information methods like \isHeadless\ and \terminalColorsEnabled\, which are currently deprecated in favor of \IzPlatform\, ensuring API consistency across JVM and Native targets.

fundamentals/fundamentals-platform/.native/src/main/scala/izumi/fundamentals/platform/jvm · high confidence

A new \IzJvm\ trait and companion object have been added to the Scala.js module, providing a platform abstraction that delegates to \IzPlatform\. This includes deprecated methods for checking headless mode and terminal color support, ensuring consistent platform information access across JVM and JavaScript environments.

fundamentals/fundamentals-platform/.js/src/main/scala/izumi/fundamentals/platform/jvm · high confidence

New platform-dependent support modules have been added for the Scala.js target to enable integration with Cats Effect IO and ZIO. The \CatsIOPlatformDependentSupportModule\ now provides bindings for \IORuntime\ and \ExecutionContext\ (cpu/io), while \ZIOPlatformDependentSupportModule\ binds the ZIO \Executor\ using the default runtime. These changes allow the distage framework to correctly manage runtime resources for these effect systems on Scala.js.

distage/distage-core/.js/src/main/scala/izumi/distage/modules/platform · high confidence

Introduces a new platform-specific trait for the Scala.js build of fundamentals-platform that provides JavaScript-native implementations for environment variable access (reading from Node.js process.env), returns empty sequences for JVM-specific runtime arguments and classpath, and configures the global execution context to use MacrotaskExecutor.

fundamentals/fundamentals-platform/.js/src/main/scala/izumi/fundamentals/platform · high confidence

This change introduces a new Scala.js source directory containing platform-specific implementations for the BIO effect system and utility classes. It provides \BlockingIO2\ and \UnsafeRun2\ traits that adapt ZIO and Cats Effect IO to asynchronous execution models suitable for JavaScript environments, where synchronous blocking is unsupported. It also adds \QuasiIORunner\ and \QuasiAsync\ shims to handle effect execution and parallel traversal on Scala.js, and implements \IzUUID\ generation using the Web Crypto API or Node.js crypto module to replace JVM-specific secure random sources.

fundamentals/fundamentals-bio/.js/src/main · high confidence

This change introduces platform-specific implementations for the distage-framework module to enable execution on Scala.js. It provides the necessary wiring and stubs for core framework components, including platform modules for dependency injection, bootstrap planning hooks, and configuration loading (which defaults to empty or no-op on JS due to runtime resource limitations). It also implements role-specific behaviors such as argument parsing, main entry point execution using Future-based effects, and late-stage logger initialization, along with tests verifying that role-based applications can successfully run on both cats.effect.IO and zio.Task platforms.

distage/distage-framework/.js · high confidence

The Logstage SLF4J sink module now includes a new \LogSinkLegacySlf4jImpl\ class that bridges Logstage entries to the SLF4J logging API. This implementation maps Logstage log levels (Audit, Crit, Error, Warn, Info, Debug, Trace) to corresponding SLF4J logger methods, utilizing a \RenderingPolicy\ to format messages and attaching file/line markers to log events. A corresponding test suite has been added to verify that the legacy backend functions correctly with the \IzLogger\.

logstage/logstage-sink-slf4j · high confidence

A new \IzPlatform\ implementation for Scala Native has been added, extending \AbstractIzPlatform\ to report the platform as \ScalaPlatform.Native\. This implementation defaults \isHeadless\, \terminalColorsEnabled\, and \isGraalNativeImage\ to false, providing the specific platform detection logic required for the native target.

fundamentals/fundamentals-platform/.native/src/main/scala/izumi/fundamentals/platform · high confidence

A new GraphDumpObserver class has been added to the Scala.js planning module, implementing the PlanningObserver interface to support graph dump observations during the dependency injection planning phase.

distage/distage-core/.js/src/main/scala/izumi/distage/planning · high confidence

A new SHA-256 hashing implementation (IzSha256Hash) has been added to the Scala Native platform module. This component provides the underlying cryptographic functionality required for hashing operations on native targets, ensuring parity with other supported platforms.

fundamentals/fundamentals-platform/.native/src/main/scala/izumi/fundamentals/platform/crypto · high confidence

The Logstage core library now includes platform-specific implementations for Scala.js, introducing a \TimeOps\ utility for timestamp conversion and a \ThreadingLogQueue\ for managing log entry buffering and flushing. These additions provide the necessary runtime support for logging operations on the JavaScript platform.

logstage/logstage-core/.js · high confidence

The distage testkit for Scala 2 now includes new macro-based assertion helpers for asynchronous effects. Users can now use \assertIO\ to assert on the results of \cats.effect.IO\ and \cats.effect.kernel.Sync\ effects, as well as \zio.ZIO\ effects, directly within ScalaTest specs. These macros allow for concise assertions on single or paired effects without manual flatMap chaining. Additionally, a \SpecWiring\ base class is provided to automatically verify dependency injection wiring at both compile-time and runtime.

distage/distage-testkit-scalatest/src/main/scala-2 · high confidence

New tools have been added to the \izumi.fundamentals.graphs.tools.random\ package to facilitate the creation of random graph structures for testing and experimentation. This includes a \Generator\ trait with an implicit \IntGenerator\ implementation for producing unique node identifiers, and a \RandomGraph\ object providing \makeDG\ and \makeDAG\ methods. These methods generate directed graphs and directed acyclic graphs respectively, allowing users to specify the number of nodes and maximum edges, with support for custom random sources.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/tools/random · high confidence

New sample files have been added to the documentation to assist with publishing workflows. The \credentials.sonatype-nexus.properties\ file provides a template for configuring Sonatype Nexus Repository Manager credentials, including host and authentication details. The \local.sbt\ file offers a configuration example for PGP signing, specifying passphrase handling, key ring paths, and GPG usage settings.

doc/samples · high confidence

The \Toposort\ tool object has been added to the \izumi.fundamentals.graphs.tools\ package, providing a \cycleBreaking\ method that performs topological sorting on an adjacency list. This implementation detects circular dependencies and resolves them by invoking a provided \ToposortLoopBreaker\ strategy, allowing users to process graph structures that may contain cycles without failing entirely.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/tools · high confidence

The \logstage-rendering-circe\ module now provides a \LogstageCirceRenderingPolicy\ that serializes log entries into JSON using the Circe library. This policy supports configurable pretty-printing and key hiding, and it handles log parameters, context, and metadata (such as timestamp, thread, and file location) as structured JSON fields. It also includes a codec system (\LogstageCirceCodec\) that allows custom types to be serialized via Circe Encoders, ensuring that complex objects and throwables are rendered as JSON objects rather than simple strings.

logstage/logstage-rendering-circe · high confidence

The \fundamentals-collections\ module now provides the \IzCollections\ trait and package-level type aliases to extend Scala's standard collection types with additional utility methods. Users can now access implicit conversions that enrich \IterableOnce\, \Map\, and \Iterable\ types with new capabilities via \IzTraversables\, \IzIterOnceMappings\, \IzMultiMaps\, \IzIterMappings\, and \IzIterable\. Additionally, convenient type aliases for \MutableMultiMap\ and \ImmutableMultiMap\ are exposed at the package level to simplify multi-map usage.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/collections · high confidence

Logstage now supports context-aware log routing, allowing logs to be directed to specific sinks based on dynamic context keys. This is implemented via the new \ConfigurableLogRouter\ and \AdaptiveLogConfigServiceImpl\, which intersect configured sinks with context-specific routes. Additionally, a \StaticLogRouter\ singleton is provided to bridge SLF4J configurations with Logstage's internal routing, ensuring consistent logging behavior when integrating with existing SLF4J setups.

logstage/logstage-core/src/main/scala/izumi/logstage/api/routing · high confidence

A new default implementation for the plugin loader, \PluginLoaderDefaultImpl\, has been added to the \izumi.distage.plugins.load\ package on the JVM platform. This class extends \PluginLoaderClassgraphImpl\ and provides a standard entry point for loading plugins, making the plugin loading mechanism more accessible and consistent for users relying on the default configuration.

distage/distage-extension-plugins/.jvm/src/main/scala/izumi/distage/plugins/load · high confidence

Logstage now provides a new \logstage.strict\ package that implements a strict (non-lazy) logging API, adding support for Cats Effect 3 and ZIO 2. This includes \LogIOStrict\ as the core trait, along with specific integrations for ZIO (\LogZIOStrict\) and Cats (\LogstageCatsStrict\). The new API allows users to access the implicit logger without naming a variable via \LogIOStrict.log\ and supports dynamic context injection for both ZIO and Cats effects.

logstage/logstage-core/src/main/scala/logstage/strict · high confidence

A new \IzStrictLogger\ is available that requires explicit \LogstageCodec\ instances for all logged values, causing compilation to fail if a codec is missing rather than falling back to \toString\. This logger also exposes a \raw\ method to access a \RawLogger\ for unformatted output.

logstage/logstage-core/src/main/scala/izumi/logstage/api/strict · high confidence

This change adds the foundational Scala 3 macro support for the dependency injection DSL. It introduces \AbstractBindingDefDSLMacro\, which provides the \make\[T\]\ method used to create bindings via the \MakeMacro\, and defines low-priority trait markers (\LifecycleTagLowPriority\, \ZIOEnvLifecycleTagLowPriority1\) to support type-class resolution for lifecycle management in Scala 3.

distage/distage-core-api/src/main/scala-3/izumi/distage/model/definition · high confidence

The logstage-core module now includes ConsoleSink and FallbackConsoleSink classes to handle log output to the console. ConsoleSink provides methods to render log entries using a specified RenderingPolicy and write them to System.out, with support for colored, simple, and rich formatting styles. FallbackConsoleSink offers a similar functionality but uses a TrivialLogger for output, providing a fallback mechanism for logging when standard console output is not available or suitable.

logstage/logstage-core/src/main/scala/izumi/logstage/sink · high confidence

The logging API now includes a new \IzLogger\ class that supports a \raw\ method for accessing raw log output, alongside a \withCustomContext\ method for extending log context. A companion \IzLoggerConvenienceApi\ trait provides factory methods for creating loggers with configurable thresholds, sinks, and buffers, as well as a \log\ accessor for implicit logger usage. Additionally, a \LogConfigService\ trait has been added to manage log level acceptability and configuration validation.

logstage/logstage-core/src/main/scala/izumi/logstage/api · high confidence

A new MirrorProvider trait and its default implementation have been added to the distage-core-api module, providing a centralized interface for runtime reflection tasks such as retrieving runtime classes, checking type compatibility, and determining if a type can be proxied. This change consolidates reflection logic previously scattered across the codebase into a dedicated component within the izumi.distage.model.reflection package, improving maintainability and separation of concerns for dependency injection model operations.

distage/distage-core-api/.jvm · high confidence

A new \PortCheck\ class has been added to the \izumi.fundamentals.platform.integration\ package to provide a mechanism for verifying port availability. This component accepts a \FiniteDuration\ timeout and exposes methods such as \checkPort\, \checkUrl\, and \checkAddress\ to validate connectivity to specific hosts and ports, returning a \ResourceCheck\ result. It is designed to be injected into the dependency injection graph to support resource initialization checks.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/integration · high confidence

The distage core API now includes a new proxy subsystem located in \izumi.distage.model.provisioning.proxies\ to support by-name dependency injection. This change introduces the \DistageProxy\ trait, which serves as a marker for proxy instances, and the \ProxyDispatcher\ interface with an \AtomicProxyDispatcher\ implementation that manages the lifecycle of proxy references. Specifically, a new \ByNameDispatcher\ class allows for the creation of lazy, by-name proxies that resolve to their underlying values on demand, throwing a \MissingRefException\ if accessed before initialization. This infrastructure enables the framework to handle by-name providers and \@Id\ annotations on by-name types more robustly, addressing previous issues with locator runs and activation discovery.

distage/distage-core-api/src/main/scala/izumi/distage/model/provisioning/proxies · high confidence

The \fundamentals-bio\ module now provides a new \BIO2\ effect type hierarchy (e.g., \Applicative2\, \Monad2\, \Async2\, \Concurrent2\) designed to handle effects with two type parameters for error and success types (\F\[+E, +A\]\). This new hierarchy includes comprehensive support for Cats Effect 3 via \CatsConversions\, allowing seamless implicit conversion between BIO2 instances and Cats Effect typeclasses like \Sync\, \Async\, and \Temporal\. The update also introduces new capabilities such as \FiberLocal2\ and \FiberRef2\ for fiber-local state, error-accumulating collection operators, and specific interrupt handling logic to align with ZIO 2 semantics.

fundamentals/fundamentals-bio · high confidence

This change introduces JVM-specific implementations for the BIO (Bi-Effect) abstraction, enabling proper execution of effects on the JVM. It adds \BlockingIO2\ to handle blocking operations via ZIO's blocking executors, \UnsafeRun2\ to provide ZIO-backed unsafe run methods (sync, async, interruptible) with configurable runtime layers, and \QuasiIORunner\ to bridge BIO and Cats Effect IO to standard Scala \Future\ and blocking execution models. Additionally, platform-specific utilities are added for \MiniBIO\ async scheduling, Java \CompletionStage\ interoperability, and UUID generation using local network addresses.

fundamentals/fundamentals-bio/.jvm/src/main · high confidence

The distage-extension-config module now includes a concrete, working implementation for the JVM platform, replacing previous stubs. This change introduces DIConfigMeta to provide type information for generated JSON schemas and DIConfigReader to handle configuration decoding using Pureconfig. Users on JVM can now benefit from automatic derivation of config readers for standard types (such as String, Int, Duration, URL, etc.) and collection types, enabling more robust and type-safe configuration binding within the dependency injection framework.

distage/distage-extension-config/.jvm/src/main/scala/izumi/distage/config/codec · high confidence

Added IzBoolean trait to the izumi.fundamentals.platform.basics package, providing lazy boolean evaluation via the LazyBool implicit conversion and utility methods all and any for short-circuiting logical operations. The LazyBool value class also includes a toInt method for converting boolean values to integers (1 or 0).

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/basics · high confidence

LogStage now provides a Scala 2-specific implementation of its logging macros, introducing compile-time message construction and argument extraction. This change adds new traits and macro methods (such as \MessageMat\, \AbstractMacroLogIO\, and \AbstractMacroLogger\) that enable efficient, type-safe logging with features like \logMethod\ and \logValues\, replacing or supplementing previous runtime-based approaches for Scala 2 users.

logstage/logstage-core/src/main/scala-2 · high confidence

The documentation microsite now includes a built-in dark color scheme. A new toggle button in the header allows users to switch between light and dark modes, with the preference persisted in the browser's localStorage so it is remembered on return visits. The dark theme is applied by default for visitors without JavaScript, falling back to the system's color-scheme preference, and the site's layout has been adjusted to ensure the header and navigation elements render correctly in both modes.

doc/microsite · high confidence

A new \ParserSchemaFormatter\ component has been added to the CLI model package to generate human-readable help documentation from parser schemas. This formatter supports terminal color output (when enabled by the platform) and structures the output to display global arguments, role-specific options, and free arguments with appropriate indentation and styling, improving the clarity of command-line help text for users.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/cli/model · high confidence

The distage-framework-docker module now includes specific health check implementations for verifying container states and service availability. Users can now use ExitSuccessCheck to validate that a container has exited with a specific code, HttpGetCheck to verify HTTP/HTTPS connectivity on a mapped port, PostgreSqlProtocolCheck to ensure a PostgreSQL instance is ready by sending a protocol startup message, and TCPContainerHealthCheck to verify that specified TCP ports are open and accessible. These checks provide more granular control over container readiness and lifecycle validation.

distage/distage-framework-docker/src/main/scala/izumi/distage/docker/healthcheck · high confidence

The distage core API now exposes new \Functoid\-based methods and implicit conversions to simplify binding dependencies. You can now use \makeClass\, \makeTrait\, \makeFactory\, and \makeHas\ (for ZIO environments) to derive constructors for classes, traits, and factories. Additionally, \ModuleDef\ now supports binding \cats.effect.Resource\, \zio.ZIO\, \zio.ZManaged\, and \zio.ZLayer\ values directly via implicit conversions, automatically handling lifecycle management. A new \todoProvider\ method allows creating placeholder bindings that throw a \TODOBindingException\ at runtime.

distage/distage-core-api/src/main/scala/izumi/distage/model/providers · high confidence

A new GraphDumpBootstrapModule has been added to the distage-core planning extensions, allowing users to enable GraphViz rendering of the dependency injection plan by adding this module to the Injector's parameters. This module registers a GraphDumpObserver as a PlanningObserver, facilitating debugging and visualization of the injection graph, although it is noted that this feature does not work on Scala.js due to file I/O limitations.

distage/distage-core/src/main/scala/izumi/distage/planning/extensions · high confidence

A new \GraphDumpObserver\ has been added to the planning module, enabling users to automatically generate Graphviz DOT files of the dependency injection plan after planning finishes. This observer writes a visualization file (e.g., \target/plan-last-aftergc.gv\) that maps DI keys to their operation types (such as instantiation, subcontext, lambda, or proxy) and highlights root keys, allowing users to visually inspect the structure and dependencies of their injected context.

distage/distage-core/.jvm/src/main/scala/izumi/distage/planning · high confidence

A new GraphQueries class has been added to the planning solver to handle core dependency graph operations. This component provides methods for identifying ignored activations, retrieving importing bindings based on activation contexts, calculating dependencies for instantiation operations (including handling of weak set members), and indexing executable operations. It serves as the foundational logic layer for traversing and resolving the dependency graph during the planning phase.

distage/distage-core/src/main/scala/izumi/distage/planning/solver · high confidence

A new \GraphVizDotML\ abstract class has been added to the \izumi.fundamentals.graphs.dotml\ package, enabling users to programmatically assemble, save, and render DOT source code for graph visualization. This component provides methods to define graph nodes and edges, apply attributes to graphs, nodes, and edges, and handle subgraphs, effectively exposing graph rendering capabilities within the fundamentals-collections module.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/dotml · high confidence

The IzFiles utility object now provides a comprehensive set of file management capabilities, including reading and writing UTF-8 strings, searching for executables by name across system paths (with Windows extension support), recursively removing directories, refreshing directories and symlinks, and retrieving file attributes like the last modified time. This consolidates various file system interactions into a single, easy-to-use interface.

fundamentals/fundamentals-platform/.jvm/src/main/scala/izumi/fundamentals/platform/files · high confidence

This update introduces a new Java Util Logging (JUL) adapter that bridges JUL log records to Logstage, allowing users to route existing JUL output through Logstage's routing and rendering policies. It also adds a new file-based logging sink, including support for file rotation, size-based limiting, and state restoration from existing log files, enabling persistent log storage with configurable rotation strategies.

logstage/logstage-core/.jvm · high confidence

The JVM-specific platform module now includes \IzClasspath\ and \IzJvm\ traits to provide detailed runtime information. \IzClasspath\ allows users to safely retrieve the full classpath sequence or string by recursively traversing the classloader hierarchy and decoding URLs, while \IzJvm\ exposes JVM uptime, start time, and temporary directory location via \java.lang.management\. These utilities consolidate platform-specific data access, with \IzJvm\ also retaining deprecated aliases for headless and terminal color checks that now delegate to the core \IzPlatform\.

fundamentals/fundamentals-platform/.jvm/src/main/scala/izumi/fundamentals/platform/jvm · high confidence

A new \LocatorRef\ class has been added to the recursive model package, allowing classes within the dependency injection object graph to summon a reference to the \Locator\. This reference is initialized after the provisioning process completes, meaning it cannot be dereferenced directly in a constructor. The class provides a safe \get\ method that throws a \MissingInstanceException\ if the locator is not yet ready, and an \unsafeUnstableMutableLocator\ method for accessing the underlying mutable locator state.

distage/distage-core-api/src/main/scala/izumi/distage/model/recursive · high confidence

A new exception class, PlanVerificationException, has been introduced in the distage-core module to handle errors occurring during static plan verification. This exception wraps the result of the plan verifier, exposing specific verification issues via an issues accessor, allowing users to inspect detailed reasons why a dependency injection plan failed verification.

distage/distage-core/src/main/scala/izumi/distage/model/exceptions · high confidence

A new \PlatformGuards\ trait has been added to the \izumi.fundamentals.platform.assertions\ package, providing \brokenOnScala3\ and \brokenOnScala2\ helper methods. These utilities allow code to conditionally execute assertions or logic only when running on specific Scala major versions (2 or 3), facilitating the management of known issues or progression tests that are specific to a particular Scala release.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/assertions · high confidence

The framework introduces a new role abstraction in the \izumi.distage.roles.model\ package, defining \AbstractRole\, \RoleService\ (for persistent background services with lifecycle management), and \RoleTask\ (for one-shot tasks). Additionally, a new \DIAppBootstrapException\ type has been added to handle application bootstrap errors.

distage/distage-framework-api/src/main/scala · high confidence

This change introduces a suite of new Scala 2 macros in the \fundamentals-platform\ module to capture build-time information and embed resources at compile time. The \BuildAttributes\ API allows applications to query runtime environment details (such as Java version, OS name, and build timestamp) via macro expansion. The \MacroParameters\ API enables the injection of custom build metadata (like project version, Git branch, and CI status) passed via \-Xmacro-settings\ compiler flags. Additionally, the \PortableResource\ API provides macros to embed source files and resources as string maps, with logic to chunk large contents to avoid constant-pool limits. Supporting utilities for reflection and macro logging are also added.

fundamentals/fundamentals-platform/src/main/scala-2 · high confidence

The distage core API now includes new Scala 2-specific macro implementations for class, trait, and factory constructors (ConstructorMacros.scala) alongside Scala 3 constructor utilities (ConstructorUtil.scala). These changes introduce the underlying macro infrastructure required to support Scala 3 compilation for the distage framework, enabling the library to generate constructor providers and handle trait/factory wiring in both Scala 2 and Scala 3 environments.

repository · high confidence

Added new Scala 3-specific macros in the \izumi.fundamentals.platform.build\ package that allow applications to inspect build-time and runtime environment details at compile time. \BuildAttributes\ provides inline access to JVM properties (such as Java version, vendor, and home), OS details, user information, and the exact build timestamp. \MacroParameters\ exposes build configuration metadata, including Scala and SBT versions, project group and artifact details, and Git repository state (branch, commit, cleanliness), all resolved via compiler macro settings. These changes enable more precise runtime diagnostics and build-aware behavior without requiring external configuration files.

fundamentals/fundamentals-platform/src/main/scala-3/izumi/fundamentals/platform/build · high confidence

The \distage/distage-framework-docker/src/main/scala/izumi/distage/docker/bundled\ package now includes ready-to-use Docker container definitions for Cassandra, DynamoDB, ElasticMQ, Kafka (including KRaft and dual-listener modes), Postgres, and Zookeeper. These definitions serve as templates that users can adopt or modify, with Postgres and ElasticMQ featuring health checks and Kafka configured to depend on Zookeeper. The Kafka and Zookeeper modules also establish a shared network to facilitate container communication.

distage/distage-framework-docker/src/main/scala/izumi/distage/docker/bundled · high confidence

The \distage/distage-framework\ now includes a new \BundledRolesModule\ that registers three built-in role commands: \:help\ displays usage information and available activations; \:all-tasks\ executes every non-bundled task with shared arguments; and \:all-roles\ executes every non-bundled service with shared arguments. These commands are automatically available when using the bundled roles module, providing a convenient way to inspect help or run all custom tasks/services in a single invocation.

distage/distage-framework/src/main/scala/izumi/distage/roles/bundled · high confidence

The platform now includes new utilities in the \izumi.fundamentals.platform.cache\ package to improve performance and code clarity. \SyncCache\ provides a thread-safe, synchronized in-memory cache for keys and values, supporting operations like get, put, and enumeration. Additionally, \CachedHashcode\ and \CachedProductHashcode\ traits allow classes to cache their computed hash codes for better performance, while \CachedRepr\ enables caching of string representations via \toString\.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/cache · high confidence

This change introduces new extension classes in the \izumi.fundamentals.collections.impl\ package that add utility methods to Scala collections. \IzIterOnceMappings\ provides methods to convert iterables into mutable or immutable multimaps (\toMultimapMut\, \toMultimapView\, \toMultimap\) and handles unique map conversion with conflict resolution (\toUniqueMap\). \IzIterable\ adds a \distinctBy\ method to filter elements based on a key function while preserving order. \IzTraversables\ introduces \maxOr\ and \minOr\ to safely retrieve the maximum or minimum element with a default value if the collection is empty, as well as \ifEmptyOr\ and \ifNonEmptyOr\ for conditional execution based on emptiness.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/collections/impl · high confidence

This release introduces a new static plan-checking API that allows users to validate their dependency injection plans at compile-time. The \CheckableApp\ trait and its implementations (\CoreCheckableApp\, \RoleCheckableApp\) provide the interface for apps to expose their configuration and roots to the checker. A new \PlanCheckException\ type handles verification failures, and \DebugProperties\ exposes system properties (like \izumi.distage.plancheck.check-config\) to control the behavior of the checker, such as enabling config validation or switching errors to warnings. This enables catching DI errors before runtime.

distage/distage-framework/src/main/scala/izumi/distage/framework · high confidence

The distage-extension-config module introduces a new way to integrate application configuration with the dependency injection container. Users can now use \ConfigModuleDef\ to bind configuration values directly into the DI graph via \makeConfig\ and \wireConfig\ methods, which leverage the new \DIConfigReader\ for automatic codec derivation using pureconfig. This replaces the previous circe-config backend, providing a more robust configuration loading mechanism that supports default values, named bindings, and JSON schema generation via \ConfigWriter\ and \ConfigDoc\ annotations.

distage/distage-extension-config/src/main · high confidence

Added CycleEraser and LoopBreaker components to the fundamentals-collections library to handle cyclic dependencies in graph structures. CycleEraser implements a topological sort algorithm that detects loops and attempts to break them using a provided LoopBreaker strategy, returning either a valid DAG or an error if loops cannot be resolved. LoopBreaker provides a trait for custom loop-breaking strategies, with a default terminating implementation that fails on any detected loops.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/tools/cycles · high confidence

The testkit now exposes Java system properties to control debug logging and caching behavior, including flags to enable debug messages, cache the test environment and default modules, force global memoization on Scala.js, and skip tests on Docker failures. Additionally, a new TestReporter API has been introduced to allow external tools to observe test execution lifecycle events such as scope, level, and suite boundaries, as well as individual test statuses.

distage/distage-testkit-core/src/main/scala/izumi/distage/testkit · high confidence

A new \DebugProperties\ object has been added to the Logstage core module, exposing four boolean configuration flags: \izumi.debug.macro.logstage\, \izumi.logstage.rendering.colored\, \izumi.logstage.rendering.colored.forced\, and \izumi.logstage.routing.log-failures\. These properties allow users to control macro debugging, colored output rendering (including forcing color regardless of terminal detection), and whether routing failures are logged.

logstage/logstage-core/src/main/scala/izumi/logstage · high confidence

The distage-extension-logstage module now provides \LogIOModule\, \LogIO2Module\, and \LogIO3Module\ to automatically wire Logstage's \LogIO\, \LogCreateIO\, and \UnsafeLogIO\ components into the distage container, alongside \LogstageModule\ for configuring the underlying \IzLogger\ and \LogRouter\. This allows users to seamlessly integrate Logstage's effect-agnostic logging capabilities with their distage-based application architectures.

distage/distage-extension-logstage/src/main · high confidence

The \izumi.fundamentals.platform.exceptions\ package now includes \IzStack\ and \IzThrowable\ to provide enhanced exception handling capabilities. \IzStack\ offers methods to retrieve the current stack trace, with an option to filter by accepted packages. \IzThrowable\ introduces implicit conversions to \IzThrowable\_Syntax\ and \IzThrowableStackTop\_Syntax\, enabling users to access detailed stack trace information, including all causes, messages, and class names. These utilities simplify debugging and error reporting by providing more granular control over stack trace data.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/exceptions · high confidence

This change introduces several new functional programming utilities to the \izumi.functional\ package. It adds \Lub\, a type representing a lower bound with \fst\ and \snd\ accessors, and \Value\, a wrapper class providing \map\, \mut\ (conditional mutation), and \eff\ (side-effecting) operations. Additionally, it introduces \Renderable\ and \WithRenderableSyntax\ to enable a \.render()\ extension method for any type with an implicit \Renderable\ instance, all implemented as \AnyVal\ for zero-allocation performance.

fundamentals/fundamentals-functional/src/main/scala/izumi/functional · high confidence

The library introduces new type-level graph properties (\DirectedGraph\, \DirectedAcyclicGraph\) in \GraphProperty.scala\ to enable compile-time guarantees about graph structure. Additionally, \GraphSyntax.scala\ adds extension methods to directed graphs, allowing users to remove specific nodes via \without\ or perform garbage collection on weak edges via \gc\. Support for displaying nodes is provided through the new \NodeShow\ trait with implicit instances for \Int\ and \String\, and a new \Tracer\ class in the \gc\ tools package implements the reachability logic used by the garbage collection feature.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs · high confidence

Added a new set of UI components in the \izumi.fundamentals.graphs.ui\ package to support visualizing directed graphs. This includes \PngWindow\ for displaying rendered graph images in a Swing window, \ImagePanel\ for rendering the image with support for saving via a right-click context menu, \LocationPolicy\ to manage window positioning on screen, and \SwingTheme\ to apply a dark Nimbus look-and-feel. Note that \GVR.scala\ is present but entirely commented out, so the rendering logic itself is not yet active.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/ui · high confidence

This release introduces several new utilities in the \izumi.fundamentals.platform.language\ package to enhance type safety and cross-version compatibility. It adds \LiteralBoolean\ and \LiteralString\ to enforce compile-time literal types, providing \True\/\False\ constants and a \compileTimeIf\ macro for Scala 2, while using native singleton types for Scala 2.13+. It also introduces a \newtype\ module with \Newsubtype\ and \NewtypeCustom\ for creating type-safe newtypes, and a \Quirks\ object offering \discard\ and \forget\ methods to explicitly handle unused values. Additionally, it provides \HigherKindedAny.AnyF\ as a compatibility shim for higher-kinded types across Scala 2 and 3, and deprecates the \@open\ annotation in favor of the Scala 3 \open\ keyword.

fundamentals/fundamentals-language/src/main · high confidence

Added \IzDNS\ and \IzSockets\ to the \izumi.fundamentals.platform.network\ package. \IzDNS\ provides a utility to parse endpoint strings into \InetSocketAddress\ objects, handling IPv4, IPv6, and hostname formats with default port fallback. \IzSockets\ offers utilities to find available local ports and addresses for both TCP and UDP, supporting loopback and specific network interfaces, which is useful for testing or dynamic service binding.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/network · high confidence

The planning module now includes new components to support advanced dependency injection features. AutoSetModule and AutoSetHook allow users to automatically collect implementations into summonable Sets, similar to MacWire's multi-wiring. SubcontextHandler introduces support for local contexts (subcontexts), enabling nested dependency graphs with specific activation and verification logic. Additionally, PlanningHookAggregate and PlanningObserverAggregate provide mechanisms to chain multiple planning hooks and observers, while PlannerDefaultImpl serves as the core implementation coordinating these new planning steps.

distage/distage-core/src/main/scala/izumi/distage/planning · high confidence

The library introduces a new \IzPlatform\ object and supporting classes in the \izumi.fundamentals.platform\ package to provide runtime detection of the execution environment. This includes identifying the Scala platform (JVM, Scala.js, or GraalVM Native Image), detecting headless modes based on system properties and environment variables (like \DISPLAY\ or \XDG\_SESSION\_TYPE\), and determining whether terminal colors should be enabled (checking for \COLORTERM\, \TERM\, or IntelliJ IDEA presence). Additionally, new platform-specific properties (\izumi.app.disable-terminal-colors\, \izumi.app.force-terminal-colors\, \izumi.app.forced-headless\) allow users to override these automatic detections, and a helper object \IzumiProject\ provides standardized bug report formatting.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform · high confidence

A new \preamble\ object has been added to the \izumi.fundamentals\ package, providing a single entry point that mixes in several platform-specific utility traits: \IzBoolean\, \IzBytes\, \IzCollections\, \IzEither\, \IzSerializable\, \IzString\, \IzThrowable\, and \IzTimeOrderingSafe\. This allows users to import all these common platform utilities via a single import statement rather than importing each trait individually.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals · high confidence

Added ReflectiveCall and TypeUtil to the reflection package. ReflectiveCall provides a helper for invoking methods by name on any object, while TypeUtil offers utilities for checking type assignability (including primitive wrappers), retrieving default values for types, identifying Scala singletons (MODULE$), finding zero-argument constructors, instantiating objects, and detecting anonymous classes with a workaround for Java 8.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/reflection · high confidence

The \fundamentals-collections\ module now includes a new set of traits and an implementation for resumable Directed Acyclic Graph (DAG) traversal. This addition introduces \AbstractDagTraverser\ and \ResumableDAGTraverser\ to support continuing traversal from a saved state, alongside \TraverseStrategy\ and \InterruptionStrategy\ to allow customizable marking logic and the ability to pause or interrupt the traversal process.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/traverse · high confidence

The \izumi.fundamentals.platform.strings\ package now provides a comprehensive set of extension methods for \String\, \Iterable\, and byte arrays. Users can convert strings to UTF-8 bytes or parse them as booleans and integers with fallback defaults. String formatting is enhanced with methods for shifting indentation, densifying whitespace, padding, ellipsing (left, right, and center), and converting between camelCase and snake\_case. Iterable syntax includes \niceList\ for formatted output and \smartStrip\ for cleaning up common leading whitespace. Additionally, new \IzByteArray\ and \IzByteBuffer\ wrappers allow reading Java objects from byte arrays and converting byte buffers to arrays.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/strings · high confidence

The \distage-core-api\ module now includes a comprehensive set of formatters (\BindingFormatter\, \OpFormatter\, \DIPlanCompactFormatter\, \DepTreeRenderer\, \LocatorFormatter\) that replace previous string representations with structured, color-coded, and minimized output. Users will see improved readability when debugging dependency injection plans, with features like key minimization to reduce verbosity, support for terminal colors, and clear visualization of dependency trees, binding origins, and locator states.

distage/distage-core-api/src/main/scala/izumi/distage/model/plan/repr · high confidence

The \distage-core\ module now includes dedicated support modules for several effect types, allowing users to easily integrate \distage\ with their chosen effect system. \ZIOSupportModule\ provides bindings for ZIO, including \ExecutionContext\ pools and ZIO runtime configuration. \CatsIOSupportModule\ and \AnyCatsEffectSupportModule\ add support for \cats.effect.IO\ and generic \cats-effect\ types via \QuasiIO\ instances. \IdentitySupportModule\ enables \distage\ to work with plain Scala functions (no effect type). Additionally, \unsafe.EitherSupport\ and \unsafe.TrySupport\ provide optional \QuasiIO\ instances for \Either\[Throwable, \_\]\ and \scala.util.Try\, allowing these standard types to be used seamlessly in \Injector\ and test kits.

distage/distage-core/src/main/scala/izumi/distage/modules/support · high confidence

The \izumi.fundamentals.platform.time\ package now includes a comprehensive set of value classes (\IzDate\, \IzDuration\, \IzZonedDateTime\, \IzLocalDateTime\, \IzOffsetDateTime\, \IzInstant\, \IzLongParsers\, \IzTimeParsers\) that provide ergonomic extensions for Java time types. These additions enable implicit conversions from standard types like \Long\, \String\, \Date\, and \Duration\ to rich APIs offering ISO formatting with nanosecond precision, epoch conversion helpers, and intuitive comparison operators (\\<\, \\>\, \\<=\, \\>=\).

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/time · high confidence

The platform abstraction for cryptographic hashing now includes concrete SHA-256 implementations for both JVM and JavaScript targets, alongside a new Distage module for the framework platform. On the JVM, \IzSha256HashFunction\ delegates to \java.security.MessageDigest\, while the JavaScript target uses the \hash.js\ library (via both global and imported bindings) to provide the same \IzHashFunction\ interface. Additionally, a new \DistagePlatformModule\ in the distage-framework module registers various platform-specific helpers (such as file, network, and OS utilities) as singletons in the dependency injection container.

distage/distage-framework/.jvm/src/main/scala/izumi/distage/framework/platform, fundamentals/fundamentals-platform/.js/src/main/scala/izumi/fundamentals/platform/crypto, fundamentals/fundamentals-platform/.jvm/src/main/scala/izumi/fundamentals/platform/crypto · high confidence

The compile-time plan checker capability is now available on Scala.js targets. This change introduces platform-specific resource loading logic for the JVM (\RoleCheckableAppPlatformSpecific\) and adds the necessary file-system abstraction traits (\IzFiles\, \FsGet\) for the Scala.js platform, enabling the framework to function correctly in JavaScript environments.

distage/distage-framework/.jvm/src/main/scala/izumi/distage/framework, fundamentals/fundamentals-platform/.js/src/main/scala/izumi/fundamentals/platform/files, fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/files · high confidence

The repository has been initialized with a Nix flake (flake.nix) that provides a development shell using JDK 25, Scala CLI, and sbt, alongside a flake.lock pinning dependencies. Build tooling scripts (fmt-all, sbtgen.sc, sbtgen.sc-setup-ide) have been added to use Scala CLI and Coursier for formatting and project generation. Configuration files include a new .scalafmt.conf (version 3.6.0, scala3Future dialect), .codecov.yml, .editorconfig, and .jvmopts with specific JVM flags. The project version is set to 1.3.0-SNAPSHOT in version.sbt. Legacy files like README.txt have been removed, and .gitignore has been expanded to exclude more IDE and build artifacts.

(repo-wide) · high confidence

The SLF4J adapter module now provides a concrete implementation of the SLF4J \ILoggerFactory\ and \Logger\ interfaces, allowing applications using SLF4J to route their log output through Logstage. The \LogstageLoggerFactory\ creates cached logger instances, while \LogstageSlf4jLogger\ translates SLF4J logging calls into Logstage entries, preserving message formatting, arguments, thread context, and SLF4J markers.

logstage/logstage-adapter-slf4j/src/main/scala · high confidence

The distage framework now provides a Scala 3-specific implementation of the \RoleModuleDef\ trait, introducing the \makeRole\ method for defining roles in Scala 3 projects. This change adds a new source file in the \scala-3\ directory that utilizes Scala 3 macros (\scala.quoted\) to replace the Scala 2 macro implementation, ensuring that role-based dependency injection works correctly on the Scala 3 platform.

distage/distage-framework-api/src/main/scala-3 · high confidence

This change introduces the Scala 3-specific implementation of the LogStage logger core, adding \AbstractMacroLogIO\ and \AbstractMacroLogger\ traits. These traits provide transparent inline methods for standard log levels (trace, debug, info, warn, error, crit, audit) and their sink-specific variants (e.g., \infoTo\), which utilize macros for efficient message creation and position materialization. Additionally, it adds \logValues\ for structured value logging and \logMethod\/\logMethodF\ for logging function execution details, including options to print types and implicits.

logstage/logstage-core/src/main/scala-3/izumi/logstage/api/logger · high confidence

This change introduces the Scala 3-specific macro implementations for the distage constructor system, replacing or supplementing the Scala 2 versions. It adds \ClassConstructorMacro\, \FactoryConstructorMacro\, \TraitConstructorMacro\, and \ZEnvConstructorMacro\ to handle the derivation of constructors for concrete classes, factory traits, wireable traits, and ZIO environments respectively. The \MakeMacro\ coordinates these derivations within the \make\ DSL, while \FunctoidMacro\ and its associated methods enable the conversion of functions and blocks into \Functoid\ providers, including support for implicit parameter discharge via \DischargeDummyMacro\. These macros leverage Scala 3's quote-based metaprogramming to generate the necessary wiring code at compile time.

distage/distage-core-api/src/main/scala-3/izumi/distage/constructors · high confidence

The Scala 3 testkit now includes new assertion macro traits for Cats Effect (IO and Sync), ZIO, and the generic IO2 typeclass, allowing users to write inline assertions that evaluate effects and return standard ScalaTest Assertion results. Additionally, the SpecWiring abstract class has been re-added for Scala 3, enabling compile-time and optional runtime wiring checks for applications that implement CheckableApp.

distage/distage-testkit-scalatest/src/main/scala-3 · high confidence

The ModuleDef DSL now allows binding lifecycle-managed resources from Cats Effect and ZIO directly via the \.fromResource\ method. This change introduces \LifecycleAdapters\ that automatically convert \cats.effect.Resource\, \zio.ZIO\ (scoped), \zio.managed.ZManaged\, and \zio.ZLayer\ into the framework's internal \Lifecycle\ type, enabling seamless integration of these effect-system resources during dependency injection.

distage/distage-core-api/src/main/scala/izumi/distage/model/definition/dsl · high confidence

The distage library now allows users to bind functions that accept implicit parameters by converting them into explicit dependency injection parameters. In Scala 3, the new \bindImplicits\ and \bindAllImplicits\ methods transform lambdas, code blocks, and method references containing implicit arguments (such as \implicitly\[Double\]\) into Functoids that accept those values as explicit parameters resolved from the object graph. This enables cleaner dependency injection for functions that previously relied on the implicit scope, while \bindAllImplicits\ offers a more aggressive conversion that may also capture global implicits like \ClassTag\.

distage/distage-core-api/src/main/scala-2/izumi/distage/model/providers, distage/distage-core-api/src/main/scala-3/izumi/distage/model/providers · high confidence

The distage-testkit ScalaTest integration is now available for Scala.js. This adds platform-specific implementations for the test runner runtime, class reflection, and annotation handling, enabling the testkit to function on the JavaScript platform alongside the existing JVM support.

distage/distage-testkit-scalatest/.jvm · high confidence

The \CoreClass\ from the core library, along with \UtilClass\ and its associated test \AnotherTestClass\ from the test utilities, have been removed. Additionally, several classes within the test library (\LibClass\, \ExposedClass\, and \PrivateClass\) were deleted, eliminating the underlying code and test fixtures that these components previously provided.

lib/corelib, lib/test-util, lib/testlib · high confidence

The sbt-izumi module has been completely removed, deleting all associated Scala source files including the main plugin definitions (BuildPlugin, CompilerOptionsPlugin, GitStampPlugin, NestedTestScopesPlugin, PublishingPlugin, ResolverPlugin, TestingPlugin) and the internal DSL infrastructure (ExtendedProjects, ExtendedProjectsGlobalDefs, Extender, GlobalSettings, Properties, and ExtendedProjectMacro). This eliminates the custom project definition macros, global settings management, and specialized test scope handling previously provided by the plugin.

sbt-izumi · high confidence

The distage-core module now provides a unified \Distage\ trait and an accompanying \package.scala\ that consolidate type aliases and companion objects for core DI concepts. This change exposes key types such as \Injector\, \ModuleDef\, \Lifecycle\, \Subcontext\, and various constructor types (e.g., \ClassConstructor\, \TraitConstructor\) directly in the \distage\ package, simplifying imports and ensuring consistent access to the library's foundational definitions.

distage/distage-core/src/main/scala/distage · high confidence

The reflection macro implementation in \distage-core-api\ has been restructured to improve modularity and isolation. New files introduce dedicated macro implementations for \Functoid\, \ClassConstructor\, \FactoryConstructor\, \TraitConstructor\, and \ZEnvConstructor\, replacing or refactoring previous monolithic logic. A new \ReflectionProvider\ abstraction and \StaticDIUniverse\ trait centralize type inspection and wiring logic, while \DIUniverseLiftables\ handles AST serialization. This change isolates the constructor generation logic, making the reflection layer easier to maintain and extend, particularly for handling complex dependency injection scenarios like factory methods and trait wiring.

distage/distage-core-api/src/main/scala-2/izumi/distage/reflection · high confidence

The \fundamentals-orphans\ module now includes \OrphanDefs.scala\, which implements 'no more orphans' type providers for various Cats and Cats Effect typeclasses (such as \Functor\, \Monad\, \Sync\, \Async\, and \IO\). These abstract classes and their companion objects act as guards that provide optional instances only if the corresponding library (e.g., \cats-effect\) is already on the classpath, without requiring it as a direct dependency. This prevents implicit resolution conflicts and orphan warnings when integrating with libraries that bring in these typeclasses transitively.

fundamentals/fundamentals-orphans · high confidence

Introduced \PlanCheckConfig\ to configure compile-time plan checking behavior specifically for Scala 2.12 users. This component allows users to define options such as which roles to check, which activations to exclude, and whether to abort compilation on errors or only warn. It addresses a known Scala 2.12 compiler bug regarding implicits in class-parameter scope by requiring configuration to be defined in a separate val or early initializer, a workaround not needed in Scala 2.13+.

distage/distage-framework/src/main/scala-2.12 · high confidence

This change introduces Scala 2.12-specific implementation files to ensure compatibility with older Scala versions. It adds \OrderedSetShim\ to provide an ordered set abstraction using \Seq\ and \Set\ operations compatible with Scala 2.12's collection API. Additionally, it adds \NonEmptyListInstances\ and \NonEmptySetInstances\ traits that define \Factory\ implementations for \NEList\ and \NESet\, enabling these non-empty collection types to be constructed via standard collection builder patterns in Scala 2.12.

fundamentals/fundamentals-collections/src/main/scala-2.12 · high confidence

The \fundamentals-literals\ module now includes a dedicated Scala 3 implementation of \LiteralCompat\ alongside the existing Scala 2 version. This change enables the library to support literal types in Scala 3 by using transparent inline macros to parse string and character literals into their corresponding constant types, ensuring compatibility across both Scala 2 and Scala 3 versions.

fundamentals/fundamentals-literals · high confidence

The injector's own bootstrap environment is now constructed using the dependency injection system itself, rather than being assembled manually. A new \BootstrapLocator\ object handles this by creating a \Planner\, \PlanInterpreter\, and \OperationExecutor\ from a \BootstrapContextModule\. This allows users to customize the injector's internal behavior by providing \BootstrapModule\ overrides, such as adding members to the \PlanningHook\ set, during the bootstrap phase.

distage/distage-core/src/main/scala/izumi/distage/bootstrap · high confidence

The distage config extension for Scala.js has been implemented to replace the previous stub, enabling users to read dependency injection configuration from JSON sources using the Circe library. This change introduces platform-specific codecs that automatically derive decoders for case classes and sealed traits, allowing configuration values to be mapped directly to Scala types. Users can now utilize the same config-reading capabilities on Scala.js that were previously available only on the JVM, with configuration data being handled as Circe JSON objects rather than the JVM's HOCON format.

distage/distage-extension-config/.js · high confidence

The distage-extension-config module now provides a new auto-derivation mechanism for Scala 2 that customizes how Pureconfig reads configuration. Specifically, it forces CamelCase field names (overriding Pureconfig's default kebab-case) and changes how sealed traits are encoded to use a Circe-like single-key object format instead of a type discriminator field. This ensures that configuration files match the expected structure for these types without requiring manual codec definitions.

distage/distage-extension-config/.jvm/src/main/scala-2 · high confidence

The Distage dependency injection error handling has been refactored to use non-empty lists (NEList) for representing multiple issues, replacing previous collection types. A new DIFailureInterpreter class now processes these NEList\[DIError\] collections to generate specific error messages for conflicts, loop resolutions, and inconsistencies, ensuring that error diagnostics are always provided for at least one issue.

distage/distage-core-api/src/main/scala/izumi/distage/model/definition/errors · high confidence

The implicit \AnyConstructor\ type alias and companion object have been deprecated in the \izumi.distage.constructors\ package. Users relying on the previous default behavior where \make\[T\]\ implicitly generated constructors for traits and abstract classes must now explicitly use \ClassConstructor\, \TraitConstructor\, or \FactoryConstructor\. This change aligns with the updated default behavior introduced in version 1.2.0, which restricts implicit constructor generation to concrete classes only, thereby requiring more explicit configuration for abstract types.

distage/distage-core-api/src/main/scala/izumi/distage/constructors · high confidence

The \ExposedTestScope\ annotation is now deprecated and acts as a no-op, signaling that the inherited test scope functionality it previously enabled has been removed. Additionally, a new \package.scala\ file introduces a \findProjectRoot\ utility within the \izumi.fundamentals.platform.build\ package, which recursively searches for a \build.sbt\ file to locate the project root directory.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/build · high confidence

A new reference configuration file (docker-reference.conf) is provided for the distage Docker framework, establishing default settings for container reuse (enabled by default), remote Docker daemon connectivity (Unix socket by default), and Docker registry authentication. This file serves as a template for users to configure global reuse policies, remote host connections, and per-registry credentials.

distage/distage-framework-docker/src/main/resources · high confidence

The distage-docker module has been refactored to provide a cleaner API for defining and managing Docker containers. Container definitions now extend a new \ContainerDef\ trait that exposes \Container\ and \Config\ type aliases, simplifying usage within \ModuleDef\ by allowing direct reference to \.Container\ and \.Config\. The underlying resource management has been updated to use \Lifecycle\ and \Functoid\ instead of the previous \DIResourceBase\ and \ProviderMagnet\ patterns, ensuring immutable accumulation of Docker dependencies. Additionally, a new \DebugProperties\ object exposes the \izumi.distage.docker.reuse\ Java property to control container reuse behavior, and \DockerClientFactory\ now explicitly constructs clients using the \ZerodepDockerHttpClient\.

distage/distage-framework-docker/src/main/scala/izumi/distage/docker · high confidence

On the Scala.js platform, dynamic proxy creation is now explicitly disabled. Attempting to use features that require dynamic proxies will result in a clear error indicating that proxies are not supported, rather than failing with a generic or confusing runtime exception.

distage/distage-core/.js/src/main/scala/izumi/distage/bootstrap · high confidence

The dynamic proxy provider now attempts to instantiate the ByteBuddy-based strategy class at runtime and, if it cannot be found (for example, if the \distage-core-proxy-bytebuddy\ module is not on the classpath), it returns a failing implementation that reports a clear error rather than throwing an exception. This ensures that users who have removed the ByteBuddy dependency or are running on environments where it is unavailable receive a specific, actionable error message instead of a generic failure.

distage/distage-core/.jvm/src/main/scala/izumi/distage/bootstrap · high confidence

The Functoid reflection macros have been isolated into a dedicated \fundamentals-functoid\ module, introducing new infrastructure for handling named dependencies. This includes the \Identifier\ type and \IdContract\ typeclass, which enable the DSL's \.named\ method to accept identifiers beyond just Strings (such as Ints). The macros now properly extract JSR-330 \@Named\ annotations alongside Distage's own \@Id\ annotations to resolve these identifiers. Additionally, the Scala 3 macro implementation has been updated to use \Expr.asInstanceOf\ instead of \asExprOf\ to avoid unnecessary type checks, and the Scala 2 macro now correctly preserves parameter annotations when analyzing method references.

fundamentals/fundamentals-functoid · high confidence

LogStage now correctly extracts argument names in Scala 3 by introducing a new \ArgumentNameExtractionMacroBase\ that handles macro-specific tree structures. Additionally, the library provides clearer warnings when users pass constant expressions or unexpected code patterns to the logger, guiding them toward proper string interpolation usage.

logstage/logstage-core/src/main/scala/izumi/logstage/macros · high confidence

The dependency injection planning engine now uses a new sequential implementation to handle circular dependencies more robustly. When a loop is detected, the system automatically introduces proxy operations (MakeProxy and InitProxy) to break the cycle, allowing dependent components to be resolved correctly without manual intervention. Additionally, a new sanity checker validates the final plan, ensuring that proxy operations are correctly paired and that all references are valid, which helps catch configuration errors early.

distage/distage-core/src/main/scala/izumi/distage/planning/sequential · high confidence

The Injector trait in distage-core has been refactored to provide a cleaner, more ergonomic API for creating and running object graphs. The previous \planUnsafe\ usage has been removed, and new convenience methods are now available: \produceRun\ for executing a function with the object graph and automatically deallocating it upon completion, \produceEval\ for running a function while keeping the graph alive for further use, and \produceGet\ for retrieving a specific root component from the graph. These changes simplify common patterns where users need to instantiate dependencies, run logic, and manage lifecycle resources without manual boilerplate.

distage/distage-core/src/main/scala/izumi/distage/model · high confidence

The Docker support module has been refactored into a new \DockerSupportModule\ that provides two distinct initialization modes: \default\, which binds a \Docker.ClientConfig\ with sensible defaults, and \config\, which uses \makeConfigWithDefault\ to load configuration from a \docker\ section in the application config, falling back to defaults if the section is absent. This change allows users to explicitly opt into configuration-driven Docker client setup while maintaining backward-compatible default behavior.

distage/distage-framework-docker/src/main/scala/izumi/distage/docker/modules · high confidence

The plugin loading mechanism now uses a new \PluginLoader\ trait and a \PluginLoaderClassgraphImpl\ that scans the classpath via ClassGraph to discover \PluginBase\ implementations. This change introduces configurable package filtering (enabled/disabled packages) and adds a caching layer for scanned packages to improve performance. Users relying on the previous plugin discovery method will now benefit from explicit control over which packages are scanned and faster subsequent loads due to caching.

distage/distage-extension-plugins/src/main/scala/izumi/distage/plugins/load · high confidence

The logstage-core module introduces a new rendering infrastructure in the \izumi.logstage.api.rendering.logunits\ package, replacing or refactoring the previous rendering logic. This change adds \Extractor\ and \Renderer\ traits to handle the decomposition of log entries into structured components (such as thread name, timestamp, level, source position, and message) and their subsequent assembly. It also introduces \LogFormat\, which manages the formatting of log messages, including support for rich formatting with tags, customizable string representations, and the new \hideKeys\ option to control whether parameter names are displayed in the output. This architectural shift enables more flexible and customizable log output styles while maintaining backward compatibility with existing logging configurations.

logstage/logstage-core/src/main/scala/izumi/logstage/api/rendering/logunits · high confidence

The logstage rendering subsystem has been refactored to support structured log output and customizable console styling. A new \ConsoleColors\ object maps log levels to specific ANSI colors (e.g., Trace to Magenta, Error to Yellow), enabling colored terminal output. The core rendering logic is now driven by \RenderingPolicy\ and \StringRenderingPolicy\, which use a new \LogstageWriter\ trait to build structured data (lists, maps, scalars) rather than just plain strings. This allows for richer formatting options, including a 'rich' policy that accepts custom stylesheets, and supports a 'messageOnly' mode for simplified output.

logstage/logstage-core/src/main/scala/izumi/logstage/api/rendering · high confidence

The distage-extension-config module now includes a concrete implementation of the configuration abstraction for the JVM platform. This new package.scala file defines the \DistageConfigImpl\ type alias and companion object, providing specific methods for handling Typesafe Config instances such as resolving, checking paths, and managing fallbacks. This change establishes the functional backend for configuration handling on JVM targets, replacing previous stubs or missing implementations.

distage/distage-extension-config/.jvm/src/main/scala/izumi/distage/config · high confidence

The distage plugin system now supports a configurable strategy for merging multiple module definitions. A new PluginMergeStrategy trait and its default SimplePluginMergeStrategy implementation allow users to define how sequences of ModuleBase instances are combined, replacing the previous implicit or fixed merging behavior with an explicit, extensible approach.

distage/distage-extension-plugins/src/main/scala/izumi/distage/plugins/merge · high confidence

A new \MirrorProvider\ implementation for Scala.js has been added to handle runtime class reflection. This change works around a Scala 3+ JavaScript compiler bug (lamp epfl/dotty\#17542) by providing a platform-specific fallback for type inspection, ensuring that \distage\ can correctly resolve runtime classes and compatibility checks on the JS platform despite upstream compiler limitations.

distage/distage-core-api/.js · high confidence

Added \IzPlatformUtil\ and its subtypes (\IzPlatformPureUtil\, \IzPlatformSyntax\, \IzPlatformFunctionCollection\, \IzPlatformEffectfulUtil\) to categorize helper collections and extensions. These marker traits define the structure for organizing platform-specific utilities, with \IzPlatformEffectfulUtil\ specifically noting that such helpers should be injected via the DI context rather than accessed as singletons.

fundamentals/fundamentals-basics · high confidence

The distage core library introduces a new Subcontext DSL, implemented via SubcontextImpl, which allows users to create isolated local contexts with declared external keys and a specific plan, enabling more granular control over dependency injection scopes and inheritance from a parent locator. This change is accompanied by internal refactoring of the Injector bootstrap process: InjectorDefaultImpl now explicitly manages its own reflection module and bootstrap locator dependencies, while InjectorFactory exposes new methods like inheritWithNewDefaultModule to allow recreating the default module without reusing existing instances from a parent locator. Additionally, a new DebugProperties object provides runtime toggles for debugging the injector's bootstrap environment, interpreter stacktraces, and plan verification.

distage/distage-core/src/main/scala/izumi/distage · high confidence

The JVM-specific implementation of the platform abstraction now explicitly defines behavior for environment variables, classpath retrieval, JVM argument inspection, and the global execution context. This ensures that JVM users receive standard system-level data and the default global execution context, distinct from the Scala.js implementation.

fundamentals/fundamentals-platform/.jvm/src/main/scala/izumi/fundamentals/platform · high confidence

The distage core library now includes new JVM-specific platform support modules that provide default bindings for execution contexts and runtime environments for Cats Effect IO, Monix, and ZIO. For Cats Effect IO, a dedicated module configures separate 'io' and 'cpu' execution contexts, creating a work-stealing compute pool sized to the available processors and handling the IORuntime construction with manual cycle-breaking to ensure reliable initialization. For ZIO, a new module binds a default Executor for the 'cpu' context, creating isolated pools rather than relying on the global executor for safety. Monix support modules are present but currently commented out, indicating preparation for future integration. These changes ensure that effect types have properly configured, isolated execution resources by default on the JVM.

distage/distage-core/.jvm/src/main/scala/izumi/distage/modules/platform · high confidence

The distage core library now includes a platform-specific implementation for creating proxies to resolve circular dependencies on the JVM. This new \ProxyStrategyDefaultImplPlatformSpecific\ class handles the logic for instantiating proxy objects by fetching existing dependencies from the object graph or filling constructor arguments with nulls, ensuring that cyclic references can be broken effectively during provisioning. This change is specific to the JVM platform, as the code explicitly checks for and rejects proxy creation on other platforms like Scala.js.

distage/distage-core/.jvm/src/main/scala/izumi/distage/provisioning · high confidence

The distage framework now includes platform-specific implementations for the JVM to handle role application initialization. This adds a module that configures the default strategy for loading and merging configuration files from the local file system, and another module that enables GraphViz context dumping via a command-line flag. Additionally, JVM-specific runtime behaviors are defined, including the use of asynchronous shutdown strategies and terminating failure handlers.

distage/distage-framework/.jvm/src/main/scala/izumi/distage/roles · high confidence

The Locator API has been updated so that lookups for the Locator itself now return the instance, enabling nested injection patterns where a component can directly access the container. Additionally, the Subcontext feature introduces an \unsafeModify\ method to allow unsafely substituting the root Functoid, while deprecating \produceRunSimple\ in favor of the standard \produceRun\ with Identity effects, providing more explicit control over resource lifecycles and type safety.

distage/distage-core-api/src/main/scala/izumi/distage · high confidence

The LogStage macro implementation has been rewritten from the ground up to use Scala 3's native \scala.quoted\ macros, replacing the previous Scala 2 implementation. This change introduces new macro files (\ArgumentNameExtractionMacro\, \LogMessageMacro\, \LogMethodMacro\, \LogValuesMacro\, and \EncodingModeExtractors\) that handle argument name extraction, message formatting, and logging method execution using Scala 3 reflection. The rewrite ensures compatibility with Scala 3's macro system and improves the reliability of argument name extraction and implicit search for codecs.

logstage/logstage-core/src/main/scala-3/izumi/logstage/macros · high confidence

The logstage-core module has been restructured to consolidate the logging API, introducing \LogIO\, \LogCreateIO\, and \UnsafeLogIO\ traits to replace the previous \LogBIO\/\LogF\ hierarchy. This change provides a unified abstraction for logging across different effect types, including specific integrations for ZIO (\LogZIO\) and Cats (\LogstageCats\). Users gain new capabilities such as context propagation via \withCustomContext\, dynamic context support, and the ability to access the implicit logger directly via \LogIO.log\ without naming a variable. The \LogStage\ trait and package object now serve as the central hub for these types, streamlining the API surface.

logstage/logstage-core/src/main/scala/logstage · high confidence

The sbtgen build-generation script has been migrated from SBT to Scala CLI, utilizing the \//\> using\ directives in \project.scala\ to specify the Scala version (3.7.4) and the \sbtgen\ dependency. This change updates the tooling used to generate the project's SBT build files, replacing the previous SBT-based generator with a Scala CLI-based entry point defined in \Deps.scala\.

sbtgen · high confidence

A new \InjectorFailed\ exception class has been added to the \izumi.distage.model.exceptions.planning\ package. This exception extends \DIException\ and is designed to wrap a list of \DIError\ instances, providing a structured way to report multiple dependency injection planning failures during injection.

distage/distage-core-api/src/main/scala/izumi/distage/model/exceptions/planning · high confidence

The distage-extension-plugins module now provides \PluginDef\ and \BootstrapPluginDef\ abstract classes that allow users to define plugins using \ModuleDef\ and \BootstrapModuleDef\ syntax while ensuring compile-time checks re-run when the source code changes. These classes integrate with the \ForcedRecompilationToken\ mechanism to support incremental compilation and static plan checking, replacing the previous approach where mixing with other classes or using traits would bypass recompilation checks. Additionally, \PluginBase\ and \BootstrapPlugin\ traits are introduced as alternatives for users who prefer trait-based composition without compile-time recompilation guarantees.

distage/distage-extension-plugins/src/main/scala · high confidence

This change introduces new Scala 2-specific macro support within the distage core API to enhance the dependency injection DSL. It adds \AbstractBindingDefDSLMacro\ to provide a \make\[T\]\ method for creating bindings via macros, and implements \LifecycleTagMacro\ along with low-priority implicit traits (\LifecycleTagLowPriority\, \ZIOEnvLifecycleTagLowPriority1\) to resolve \Lifecycle\ tags. These macros serve as a workaround for IntelliJ IDEA highlighting issues and ensure proper error trace display when implicit resource tags are missing, improving the developer experience for Scala 2 users defining lifecycle-aware dependencies.

distage/distage-core-api/src/main/scala-2/izumi/distage/model/definition · high confidence

A new exception class, UnsupportedWiringException, has been added to the distage-core-api module to handle specific reflection-related wiring failures. This exception extends the existing DIException base class and captures both an error message and the specific MacroSafeType involved, allowing users to identify which type caused the unsupported wiring operation.

distage/distage-core-api/src/main/scala-2/izumi/distage/model/exceptions · high confidence

The distage library introduces four new exception classes to provide more specific error reporting: \InvalidFunctoidModifier\ and \LocatorDefUninstantiatedBindingException\ in the DSL package, and \TraitInitializationFailedException\ and \UnsupportedDefinitionException\ in the macros package. These exceptions extend the existing \DIException\ base class and carry specific context (such as the affected \Binding\ or \SafeType\) to help users diagnose configuration and definition issues more precisely.

distage/distage-core-api/src/main/scala/izumi/distage/model/exceptions/dsl, distage/distage-core-api/src/main/scala/izumi/distage/model/exceptions/macros · high confidence

The distage API now exposes explicit \TraitConstructor\, \FactoryConstructor\, and \ZEnvConstructor\ types to handle dependency injection for traits, factory-like interfaces, and ZIO environments respectively. This change introduces dedicated mechanisms for summoning constructors for abstract types and ZIO's \ZEnvironment\, moving away from implicit trait construction which is now forbidden in favor of these explicit definitions. Users can now explicitly bind these constructor types in their module definitions to ensure clearer and more robust dependency resolution for abstract and environment-based dependencies.

distage/distage-core-api/src/main/scala-2/izumi/distage/constructors · high confidence

The planning subsystem in distage-core-api now exposes four new traits that allow users to extend or observe the dependency injection planning process. ForwardingRefResolver enables custom logic for resolving circular references during plan execution. PlanningHook allows intercepting and modifying definitions before they are processed. PlanningObserver provides a lifecycle hook to run side-effects (such as logging or graph dumping) when planning finishes. SanityChecker allows validating the final plan against custom rules before it is executed. These changes shift planning extensibility from internal, hardcoded logic to pluggable interfaces.

distage/distage-core-api/src/main/scala/izumi/distage/model/planning · high confidence

The \izumi.distage.model.provisioning\ package now exposes new core abstractions that refine how the DI framework handles resource validation and key lookups. \AbstractCheck\ and \IntegrationCheck\ traits allow the planner to prioritize and validate external resources, enabling automatic test skipping or startup halting when dependencies are unavailable. Additionally, \ProvisioningKeyProvider\ and \OperationExecutor\ provide explicit interfaces for resolving DI keys (including by-name proxies and parent locator chains) and executing provisioning operations, forming the API foundation for the new just-in-time, non-sequential plan interpreter.

distage/distage-core-api/src/main/scala/izumi/distage/model/provisioning · high confidence

The distage core API now exposes a set of new traits in the \izumi.distage.model.provisioning.strategies\ package to handle specific provisioning operations. These include \EffectStrategy\ for executing effects, \ImportStrategy\ for handling dependency imports, \InstanceStrategy\ for using instances or references, \ProviderStrategy\ for calling providers, \ProxyStrategy\ for creating and initializing proxies, \ResourceStrategy\ for allocating resources, \SetStrategy\ for creating sets, and \SubcontextStrategy\ for preparing subcontexts. Each strategy defines methods that operate within an effectful context \F\[\_\]\ (requiring \QuasiIO\ and \TagK\ constraints) and return either a sequence of new object operations or a \ProvisionerIssue\.

distage/distage-core-api/src/main/scala/izumi/distage/model/provisioning/strategies · high confidence

The CLI platform now includes a new implementation for parsing command-line arguments that supports role-based applications. This change introduces \CLIParserImpl\, \MultiModalArgsParserImpl\, and \ParserFailureHandler\ to handle multi-modal arguments (distinguishing between global options and role-specific arguments using the \:role-name\ syntax) and provide structured error handling for issues like duplicated roles. Users benefit from a more robust and flexible argument parsing mechanism that separates primary arguments from role-specific configurations.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/cli · high confidence

The distage core API now introduces a set of specific runtime exception classes to provide clearer error reporting during dependency injection. These include \IntegrationCheckException\ for resource check failures, \MissingInstanceException\ with helper methods to suggest similar bindings when a dependency is not found, \MissingRefException\ for unresolved references, \ProvisioningException\ for general provisioning issues, \ProxyAlreadyInitializedException\ for proxy state errors, \TODOBindingException\ for unimplemented bindings, \ToposortFailed\ for plan rendering errors, and \UndeclaredKeyException\ for invalid keys. A \NonCriticalIntegrationFailure\ trait is also added to mark non-critical integration issues.

distage/distage-core-api/src/main/scala/izumi/distage/model/exceptions/runtime · high confidence

The distage-core library now includes dedicated modules in the \izumi.distage.modules.typeclass\ package to automatically provide typeclass instances for various effect systems. \BIOInstancesModule\ adds aliases for \bio\ typeclasses (such as \Monad2\, \Bracket2\, and \Concurrent2\) based on available \Async2\ and \Temporal2\ bindings. \CatsEffectInstancesModule\ provides standard Cats Effect typeclasses (like \Monad\, \Sync\, and \GenTemporal\) derived from an \Async\ instance. Additionally, \ZIOCatsEffectInstancesModule\ specifically bridges ZIO and Cats Effect by supplying \Async\ and \Parallel\ instances for \ZIO\[R, Throwable, +\_\]\ using the \zio.interop.catz\ library, ensuring these interop bindings are available when the interop library is on the classpath.

distage/distage-core/src/main/scala/izumi/distage/modules/typeclass · high confidence

The non-empty collection types in the \izumi.fundamentals.collections.nonempty\ package have been renamed from \NonEmptyList\, \NonEmptySet\, \NonEmptyMap\, and \NonEmptyString\ to the shorter \NEList\, \NESet\, \NEMap\, and \NEString\. The old names are retained as deprecated aliases in the \package.scala\ file to ensure backward compatibility, but users should migrate to the new \NE\*\ names. The new types provide the same non-empty guarantees and API surface as before.

fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/collections/nonempty · high confidence

The provisioning engine in distage-core has been refactored to support a non-sequential, just-in-time plan interpreter. This change replaces the previous sequential execution model with a new \PlanInterpreterNonSequentialRuntimeImpl\ that processes operations based on dependency readiness, allowing for more flexible and potentially parallel provisioning. The new implementation includes a dedicated \OperationExecutorImpl\ to handle specific operation types (such as wiring, proxy creation, and resource allocation) and introduces \ProvisionMutable\ to manage the state of the provisioning context during execution. This shift enables the framework to resolve dependencies as they become available rather than waiting for a strict linear order, improving performance and flexibility in complex dependency graphs.

distage/distage-core/src/main/scala/izumi/distage/provisioning · high confidence

The distage-testkit-core module now includes distinct platform-specific implementations for JVM and Scala.js. On JVM, the testkit uses local file-system access for configuration loading and supports runtime plugin discovery via package scanning. On Scala.js, file-system access is unavailable, so configuration is loaded from an empty default loader (requiring users to provide config via TestConfig.configOverrides), and runtime plugin discovery is disabled in favor of compile-time plugin configuration. Both platforms share the same test runner interface and module provider structure, ensuring consistent test behavior across environments while respecting platform constraints.

distage/distage-testkit-core/.jvm · high confidence

The default implementations for provisioning strategies (Effect, Instance, Provider, Proxy, Resource, Set, and Subcontext) have been refactored to operate within the \QuasiIO\ abstraction. This change ensures that resource allocation, effect execution, and proxy initialization are handled uniformly across different effect types, allowing the dependency injection engine to manage side effects and lifecycle resources consistently without being tied to a specific runtime.

distage/distage-core/src/main/scala/izumi/distage/provisioning/strategies · high confidence

On Scala.js, the dependency injection framework no longer attempts to create proxy instances for dependencies. Instead, it immediately fails with a specific error message stating that cglib proxies are unsupported on this platform and suggesting the use of by-name parameters as an alternative. This ensures that users encounter a clear, actionable error rather than a silent failure or runtime crash when proxying is attempted in a Scala.js environment.

distage/distage-core/.js/src/main/scala/izumi/distage/provisioning · high confidence

The distage-testkit-scalatest module has been refactored to replace the previous exception-based test execution model with a value-based approach, where test results are returned as values rather than throwing exceptions. This change introduces new abstract test suite classes (Spec1, Spec2, SpecIdentity, SpecZIO) that extend DistageScalatestTestSuiteRunner and integrate with ScalatestAbstractDistageSpec, enabling more flexible dependency injection in tests. The core test registration mechanism now uses the WithTestRegistration trait to collect test definitions as values, and the ScalatestAbstractDistageSpec provides specialized wrappers (DSWordSpecStringWrapper, DSWordSpecStringWrapper2, DSWordSpecStringWrapperZIO) for different effect types (monadic, bifunctor, and ZIO respectively). Additionally, new assertion utilities (WiringAssertions) and placeholder files for Monix assertions have been added to support the updated testing paradigm.

distage/distage-testkit-scalatest/src/main/scala/izumi · high confidence

The application startup logic in the roles framework has been restructured into dedicated modules (boot args, logger, and platform-specific config) to improve modularity and support Scala.js. A new \DebugProperties\ object exposes several runtime configuration flags, allowing users to control behavior such as ignoring unknown activation axes, suppressing warnings for mismatched effect types, forcing JSON logging, and managing how reference configs are merged or ignored. The boot sequence now explicitly handles early and late logging phases, registers the log router for SLF4J compatibility, and validates modules before planning.

distage/distage-framework/src/main/scala/izumi/distage/roles · high confidence

The framework's internal service layer has been restructured to improve modularity and configuration management. A new \ConfigFilteringStrategy\ and \ConfigMerger\ now handle the loading, filtering, and merging of shared and role-specific configuration files, introducing support for the \--ignore-all-reference-configs\ flag to exclude default reference configs. The \ModuleProvider\ has been updated to explicitly pass through essential context components (such as \RolesInfo\, \RoleAppArgs\, and \ActivationInfo\) into the application's DI scope without inheriting the entire outer context, and it now automatically registers \AutoSet\ modules for custom roles and tasks. Additionally, \ActivationChoicesExtractor\ was added to validate axis choices and detect conflicts early, while \PlanCircularDependencyCheck\ now provides specific warnings when circular dependencies are resolved via proxies.

distage/distage-framework/src/main/scala/izumi/distage/framework/services · high confidence

The configuration loading logic in the distage framework has been restructured into distinct, modular services: \ConfigLoader\, \ConfigLocationProvider\, and \ConfigMergerPlatformSpecific\. This change replaces the previous monolithic approach with a more explicit pipeline where \ConfigLoader\ handles resource and file loading, \ConfigLocationProvider\ defines the default precedence of config files (e.g., role-specific vs. common, reference vs. dev), and \ConfigMergerPlatformSpecific\ manages the final merging of system properties and environment variables. Users benefit from clearer separation of concerns in how configuration is discovered, merged, and overridden, with explicit support for environment variable overrides controlled by \enableConfigEnvOverrides\.

distage/distage-framework/.jvm/src/main/scala/izumi/distage/framework/services · high confidence

The launcher module now introduces a dedicated LateLoggerFactory to manage the creation of the final LogRouter and optional JUL interception as a lifecycle resource, ensuring these components are initialized late in the startup process. Additionally, a new PreparedAppSyntaxPlatformSpecific trait provides a run() method that executes the application's tasks and roles in a blocking manner, simplifying the entry point for standard execution flows.

distage/distage-framework/.jvm/src/main/scala/izumi/distage/roles/launcher · high confidence

The logging API in \logstage-core\ has been restructured to introduce \AbstractLogIO\ and \AbstractLogger\ as core base traits, replacing previous implementations. This change adds \LogIORaw\ and \RawLogger\ to support raw encoding modes, and introduces \RoutingLogger\ to explicitly forward log entries to a \LogRouter\ with custom context handling. New supporting components like \LogQueue\ (with an \Immediate\ mode) and \LogSink\ have been added to decouple log buffering and output destinations, while \EncodingAwareAbstractLogIO\ and \EncodingAwareAbstractLogger\ provide type-safe context management for encoded logs.

logstage/logstage-core/src/main/scala/izumi/logstage/api/logger · high confidence

The role-based application launcher has been restructured into distinct, focused components to improve maintainability and behavior. The \ActivationParser\ now explicitly merges default, additional, configuration-based, and command-line activations, providing clearer warnings when activation choices are unspecified. A new \AppShutdownStrategy\ introduces robust, pluggable shutdown mechanisms (blocking, immediate, and async) that properly handle JVM shutdown hooks and ensure graceful termination. The \RoleProvider\ now strictly validates role IDs to prevent clashes and checks for effect-type compatibility during role discovery. Additionally, the \RoleAppEntrypoint\ manages the execution lifecycle of roles and tasks, while \AppFailureHandler\ and \CrashLogRouterRef\ ensure that fatal errors are reported via the configured logging router even if the application context is torn down.

distage/distage-framework/src/main/scala/izumi/distage/roles/launcher · high confidence

The testkit runner's internal service layer has been restructured to introduce dedicated components for configuration loading, parallel test execution, status conversion, and logging. TestConfigLoader now memoizes configuration loading to optimize startup, while the new ParTraverseExt service enables configurable parallelism (unlimited, fixed N, or sequential) for test groups. TestStatusConverter provides granular mapping of provisioning and runtime exceptions to specific test statuses (e.g., EarlyIgnoredByPrecondition, Cancelled), addressing previous underreporting of failures. These changes collectively improve test execution performance and the accuracy of failure diagnostics.

distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/runner/impl/services · high confidence

The distage-testkit-scalatest module has been refactored to replace exception-based error handling with a value-based model, resulting in more reliable test reporting. A new DistageScalatestReporter now explicitly handles test lifecycle events, ensuring that test cancellations (such as those from integration checks) attach a Throwable to the TestCanceled event, which allows IDEs like IntelliJ to display the specific reason for cancellation rather than a generic message. Additionally, the reporter now safely handles cases where a Throwable's getMessage is null to prevent crashes, and wraps output in ScalatestLinearizedTestReporter to ensure accurate test counts in JUnit XML reports even during parallel execution.

distage/distage-testkit-scalatest/src/main/scala/org · high confidence

The dynamic proxy implementation in the ByteBuddy proxy module has been rewritten to use ByteBuddy instead of the previous CGLIB-based approach. This change introduces new internal classes (ByteBuddyAtomicRefDispatcher, ByteBuddyNullMethodInterceptor, and DynamicProxyProvider) to handle proxy creation and method interception, including specific logic for handling uninitialized proxies and classloading edge cases. For users, this ensures better compatibility with modern Java versions (specifically Java 17+) and resolves classloading issues that previously occurred in environments like mdoc, while maintaining the same proxy behavior for dependency injection.

distage/distage-core-proxy-bytebuddy · high confidence

The subcontext definition DSL has been renamed from LocalContext to Subcontext, and the new LocatorDef API allows defining bindings directly on a locator instance. This change introduces new Module, BootstrapModule, and BootstrapContextModule types to streamline module creation and composition, while also adding the @impl annotation to document auto-traits and auto-factories.

distage/distage-core-api/src/main/scala/izumi/distage/model/definition · high confidence

The Scala.js build of distage now explicitly prevents runtime plugin scanning. If a configuration attempts to enable package scanning on this platform, the application will throw a clear error indicating that this feature is unsupported, ensuring users are immediately aware of the platform limitation rather than encountering ambiguous failures.

distage/distage-extension-plugins/.js/src/main/scala/izumi/distage/plugins/load · high confidence

The SLF4J adapter now includes a new \StaticLoggerServiceProvider\ that implements the SLF4J 2.0 SPI (\org.slf4j.spi.SLF4JServiceProvider\), enabling compatibility with SLF4J 2.0+ applications. This change is accompanied by the addition of legacy binder classes (\StaticLoggerBinder\, \StaticMDCBinder\, \StaticMarkerBinder\) to support older SLF4J 1.x APIs, ensuring the adapter works across both major versions of the SLF4J logging facade.

logstage/logstage-adapter-slf4j/src/main/java · high confidence

This change introduces the Scala 2-specific implementation for the distage plugin system. It adds a \ForcedRecompilationToken\ macro to ensure that compile-time plan checks re-run when plugin definitions change, addressing incremental compilation issues in IDEs. It also provides \StaticPluginLoader\ and \PluginConfigStatic\ macros that scan packages at compile-time to discover \PluginBase\ implementations, along with a \DistagePlugins\ trait and package object to expose these types and values for Scala 2 users.

distage/distage-extension-plugins/src/main/scala-2 · high confidence

The distage-extension-config module now uses Scala 3 macros to automatically derive configuration codecs for case classes and sealed traits, replacing the previous Scala 2 implementation. This change introduces new derivation logic in MetaAutoDerive, MetaInstances, and PureconfigAutoDerive that leverages Scala 3's Mirror API. For users, this means config reading and metadata extraction are now handled via Scala 3-specific macros, which may affect compilation behavior and potentially change how field names and sealed trait structures are serialized (e.g., sealed traits use a wrapper object format similar to circe rather than a type field).

distage/distage-extension-config/.jvm/src/main/scala-3 · high confidence

This change introduces Scala 3-specific implementations for the distage plugin system, including \StaticPluginLoader\, \PluginConfig\, and \ForcedRecompilationToken\. The \StaticPluginLoader\ now scans for plugins at compile-time using Scala 3 macros, while \ForcedRecompilationToken\ implements a workaround for incremental compilation bugs in IDEA and Zinc by encoding a unique compiler session ID into the plugin's type structure to force recompilation when plugin definitions change. These changes ensure that compile-time plugin checks remain accurate and responsive during development on Scala 3.

distage/distage-extension-plugins/src/main/scala-3 · high confidence

LogStage now includes Scala 3-specific API traits for constructing log messages via string interpolation. The new \MessageMat\ trait provides a standard implicit conversion that delegates to the \LogMessageMacro\, while the new \StrictMessageMat\ trait enforces strict formatting rules by passing a \true\ flag to the macro. This allows Scala 3 users to opt into stricter message validation during log construction.

logstage/logstage-core/src/main/scala-3/izumi/logstage/api · high confidence

The \PortableResource\ API now supports embedding resources larger than 64KB by automatically splitting oversized string contents into smaller chunks during compile-time embedding. This change allows users to include large files in their portable resource maps without hitting constant-pool size limits, as the chunks are re-joined at runtime.

fundamentals/fundamentals-platform/src/main/scala-3/izumi/fundamentals/platform/resources · high confidence

The \PortableResource\ implementation in \fundamentals-platform\ now supports embedding resources larger than 64KB. This is achieved by splitting resource contents into chunks that fit within the JVM's constant-pool string literal limit (65535 bytes) and reading them via \ClassGraph\ or file system walks, allowing users to include larger assets in their portable resource maps without hitting bytecode size restrictions.

fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/resources · high confidence

The testkit runner has been refactored to use a generic effect type F\[\_\] instead of being hardcoded to the Identity effect. This change, implemented in the new TestkitRunnerModule, allows tests to run within arbitrary effect contexts (such as async effects) rather than blocking the thread for synchronous execution. Users benefit from better integration with asynchronous test frameworks and more flexible test execution models.

distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/runner · high confidence

The distage-testkit runner implementation has been rewritten to support generic effect types (G\[\_\]) instead of being hardcoded to identity, allowing better integration with various effect systems including Scala.js. The new runner architecture introduces dedicated components like DistageTestRunner, IndividualTestRunner, and TestTreeRunner to handle test planning, execution, and reporting. A key behavioral improvement fixes unmemoized weak elements of unmemoized sets being forcibly shared across tests, ensuring proper isolation. The runner now uses QuasiIO for effect handling and provides more detailed logging of merged environments and planning times.

distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/runner/impl · high confidence

The \IzEither\ trait in \fundamentals-collections\ has been consolidated into a single file, introducing a suite of implicit extension methods for \Either\ types that support error accumulation across collections. This includes operators like \biSequence\, \biTraverse\, and \biFlatTraverse\ which aggregate errors into a \NEList\ (Non-Empty List) rather than failing fast, alongside utility methods such as \ifThenFail\ and \ifThenElse\. These changes provide a consistent API for handling multiple errors in functional programming workflows.

fundamentals/fundamentals-collections/src/main/scala/izumi/functional · high confidence

The distage-core-api module introduces a unified \Plan\ type, replacing the previous distinct types (\DIPlan\, \OrderedPlan\, \SemiPlan\, \AbstractPlan\) which are now deprecated aliases. This change is accompanied by the introduction of new \Planner\ and \Producer\ traits that define the core interfaces for transforming module definitions into plans and executing those plans to produce locators, respectively. The \Planner\ trait provides methods for planning with specific inputs and roots, while the \Producer\ trait offers methods for producing locators with support for custom effect types and identity execution, marking a shift in how the dependency injection lifecycle is structured and accessed.

distage/distage-core-api/src/main/scala/izumi/distage/model · high confidence

The \WithCirce\ abstract class in the \fundamentals-json-circe\ module has been updated to provide native support for Scala 3. The Scala 3 implementation now uses by-name implicits (\=\> DerivationDerivedCodec\) and lazy vals for the codec, resolving compatibility issues where Scala 3 required both a by-name implicit and a lazy val to function correctly. This change ensures that automatic JSON codec derivation for case classes and sealed traits works reliably on Scala 3, while maintaining the existing Scala 2 implementation in a separate source directory.

fundamentals/fundamentals-json-circe/src/main · high confidence

Added Cats Effect law tests for BIO implementations; Added Cats IO platform-dependent test support for JavaScript; Added JVM test infrastructure for BIO laws; Added JVM-specific garbage collection tests for circular dependencies; Added JVM-specific injector tests for circular dependencies, proxies, and ZIO integration; Added JVM-specific tests for BIO type conversions and ZIO workarounds; Added JVM-specific tests for FiberLocal and FreeMonad; Added JVM-specific tests for error-accumulating operations; Added Scala 3 trait and fixture test cases; Added Scala 3-specific test coverage for trait construction and implicit bindings; Added Scala.js-specific test infrastructure for BIO; Added ScalaTest discipline integration for property-based testing; Added compatibility tests for distage-testkit-scalatest; Added comprehensive test coverage for the distage injector; Added comprehensive test suite for LogStage API; Added generic test suites for multiple effect types; Added performance benchmark and static DSL validation tests; Added test configuration resources for distage-testkit-scalatest; Added test coverage for SLF4J adapter integration; Added test coverage for collection utilities and prefix tree logic; Added test coverage for fundamentals-platform utilities; Added test fixtures for DI resource lifecycle and memoization; Added test fixtures for Docker container reuse and health checks; Added test fixtures for distage-core dependency injection scenarios; Added test fixtures for plugin scanning; Added test fixtures for role-based application bootstrapping and plugin configuration; Added test fixtures for roles framework validation; Added test for Functoid with over 22 arguments in Scala 3; Added test for SBT module filtering; Added test for SourcePackageMaterializer; Added test for sequential test execution ordering; Added test for transitive plugin enumeration; Added test infrastructure traits for the distage testkit; Added test manifest file for JVM platform tests; Added test resources for Docker-based Flyway migration testing; Added test resources for config loading and minimization; Added test to verify SBT module filtering isolation; Added tests for Cats Effect and ZIO resource compatibility; Added tests for Docker container lifecycle, reuse, and platform-specific pulls; Added tests for IzEither collection operators; Added tests for JSON flattener identity and empty collection handling; Added tests for Lifecycle instances and SafeType equality; Added tests for LogStage sink implementations and formatting; Added tests for Scheduler retry policies with ZIO; Added tests for WithCirce derivation support; Added tests for ZIO logging context management; Added tests for cats integration and ZIO runtime utilities; Added tests for compile-time plan checking capabilities; Added tests for config codec metadata derivation and optional dependency resolution; Added tests for config resolution in distage-extension-config; Added tests for context-aware adaptive log routing; Added tests for distage autosets compatibility and logstage implicits; Added tests for garbage collection behavior in the injector; Added tests for graph traversal, cycle detection, and garbage collection; Added tests for logstage logger injection; Added tests for platform utility classes; Added tests for plugin loading and ZIO ZManaged integration; Added tests for role launcher lifecycle and configuration handling; Added tests for skipping tests based on integration resource checks; Added tests for static plugin loading and custom plan verification; Added tests for tagged axes in forced roots; Added tests for the conflict resolution logic in the planning solver; Added tests for the distage DSL and LocatorDef; Added unit tests for bootstrap context, Functoid annotation handling, and DI key equality.

The build system has been upgraded from sbt 1.0.2 to sbt 1.12.8, accompanied by a comprehensive update of project dependencies and plugins. Key library versions have been bumped, including Cats Effect to 3.6.3, ZIO to 2.1.24, Circe to 0.14.14, and ScalaTest to 3.3.0-alpha.2. Plugin versions have also been updated, such as sbt-mdoc to 2.7.2, sbt-scoverage to 2.4.4, and sbt-scalajs to 1.21.0. Additionally, a version scheme override for scala-xml has been introduced to resolve conflicts between scoverage and coursier on Scala 2.12.

project · high confidence

The project's build definition has been replaced with an auto-generated \build.sbt\ produced by the \sbtgen.sc\ script, and the legacy \sbt-izumi\ build module has been removed. This migration shifts the build tooling from sbt to Scala CLI, updating the organization to \io.7mind.izumi\ and configuring cross-compilation for Scala 2.12, 2.13, and 3.7.4 with specific compiler flags and dependency versions (e.g., ScalaTest, kind-projector) managed through the new generation process.

(dependencies) · high confidence

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

• CAI 59 → 58 (-1.3)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 90 → 90 (+0.0)
• Architecture 99 → 96 (-3.2)
• Maturity 55 → 55 (+0.0)
• Readiness 50 → 49 (-0.3)
• Security 62 → 62 (+0.0)

• Documentation: no installation or build instructions (README.md)
• Hotspot: distage/distage-framework-docker/src/main/scala/izumi/distage/docker/impl/ContainerResource.scala (distage/distage-framework-docker/src/main/scala/izumi/distage/docker/impl/ContainerResource.scala)
• Off-boarding risk: anonymized user #1

• Off-boarding risk: anonymized user #1

• Unchanged — 0 containers · 1 contexts · 0 edges

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

7mind/izumi 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.