kubuszok/hearth
62.3
Adequate · 7 November 2026
60.6k
lines of production code
Scala
primary language
4
measurements over time
What this system is
Features
ANSI syntax highlighting for tree printers
The tree printer now supports colored output via a new \SyntaxHighlight\ strategy. Users can use \prettyPrint\ to render Scala trees, types, and expressions with ANSI colors (keywords, types, literals, etc.), or \plainPrint\ for uncolored output. This is implemented through a new \Constants\ object for configuration and a \StringBuildingTerminated\ exception to handle string builder limits.
hearth-better-printers/src/main/scala · high confidence
Added configurable logging settings for Cross-Quotes debugging
Introduced \CrossQuotesSettings\ to allow users to enable or filter compiler plugin logging. This new component parses settings to support enabling logging globally or restricting it to specific file locations and line/column ranges, with separate parsing logic for Scala 2 and Scala 3 to handle differences in how the compiler passes arguments.
hearth-cross-quotes/src/main/scala · high confidence
Added support for Scala 3 opaque types and immutable arrays (IArray)
This update introduces two new macro extensions for Scala 3: \IsValueTypeProviderForOpaque\ enables the library to recognize and handle opaque types by resolving their underlying runtime classes and smart constructors, while \IsCollectionProviderForIArray\ adds support for Scala's immutable arrays by treating them as \Iterable\ collections with appropriate factory and builder implementations.
hearth/src/main/scala-3/hearth/std · high confidence
Auto-derivation of TypeName type class for Scala 2 and 3
Users can now automatically derive the TypeName type class for their types without manual implementation. This change introduces Scala 2 macro-based derivation (via implicit def) and Scala 3 inline given derivation, allowing the system to automatically determine type names at compile time for both Scala versions.
hearth/src/main/scala-2/hearth/typename, hearth/src/main/scala-3/hearth/typename · high confidence
Automated execution of documentation code snippets
A new script (scripts/test-snippets.scala) has been added to automatically run code examples found in the documentation (docs/user-guide). This tool parses the MkDocs configuration, interpolates template variables (such as the current hearth version), applies default Scala versions where needed, and executes the snippets to ensure they remain valid and up-to-date.
scripts · high confidence
Expanded standard macro extensions for Scala types
The standard library now includes new macro extensions that provide first-class support for additional Scala types, including arrays, iterators, strings, Options, Eithers, and Tries. These extensions allow the framework to treat these types as collections or value types, enabling features like smart constructors for Options (validating at most one element) and optimized zero-closure folding for Eithers. Additionally, support for AnyVal types with single-parameter constructors has been added, and existing collection providers have been refined to handle specific Scala built-ins like arrays and iterators more robustly.
hearth/src/main/scala/hearth/std/extensions · high confidence
Improved Scala 2 type and code printing with syntax highlighting and runtime awareness
The Scala 2 tree printer now includes \RuntimeAwareTypePrinterScala2\ and \ShowCodePrettyScala2\, enabling syntax-highlighted code output and the ability to print type names with runtime-provided type arguments substituted. This improves the readability of generated code and error messages for users relying on Scala 2 macro extensions.
hearth-better-printers/src/main/scala-2 · high confidence
Improved error reporting and macro extension system
Hearth now distinguishes between internal bugs and user API misuse via new HearthAssertionError and HearthRequirementError types, providing detailed context (Hearth/Scala/JDK versions, platform) to help diagnose issues. The macro expansion entry point (runToExprOrFail) now supports configurable log rendering, error-failing modes, and global timeouts with flame-graph capture for performance profiling. Additionally, a new MacroExtension API allows third-party code to extend Hearth's derivation capabilities via ServiceLoader, with priority-based ordering for controlling extension application sequence.
hearth/src/main/scala/hearth · high confidence
Introduce Hearth Data model and Diff utilities for test assertions
This change adds the core \Data\ type and \Diff\ utilities to the \hearth.data\ package for both Scala 2 and Scala 3. The \Data\ type provides a JSON-like structure (supporting null, primitives, lists, and maps) with optional accessors (e.g., \asInt\, \asMap\) and update methods (e.g., \updateAsString\). It also includes a \diff\ method that produces a structured \Diff\ (a list of \DiffEntry\) for comparing values, which backs the \\<==\>\ assertion operator used in Hearth tests. This allows fixtures to emit multiple results as a single, easily diffable structure.
hearth/src/main/scala-2/hearth/data, hearth/src/main/scala-3/hearth/data · high confidence
Introduce micro-fp library with functional programming type classes
The \hearth-micro-fp\ module adds a lightweight functional programming library to the project, introducing core type classes including \Functor\, \Applicative\, \Parallel\, and \Traverse\ along with their corresponding syntax extensions. It provides a \DirectStyle\ abstraction for executing effects in a direct, imperative style while preserving error handling and logging, and includes pre-built instances for standard Scala types such as \Id\, \Option\, \Try\, \List\, \Vector\, and \Either\ (with \List\ or \Vector\ error accumulation).
hearth-micro-fp/src/main/scala/hearth/fp · high confidence
Introduce rule-based derivation and standard macro extension SPI
Added a new \Rules\ utility in \hearth/std\ that allows combining a sequence of rules into a single application result, supporting both pure and effectful contexts with a first-match-wins strategy. Also added \StandardMacroExtension\, a trait serving as a registration SPI for standard type providers (such as \IsCollection\, \IsOption\, and \IsValueType\) to teach built-in shape companions about specific types.
hearth/src/main/scala/hearth/std · high confidence
Introduces Scala 3 compiler plugin for Cross-Quotes compatibility
Adds a new Scala 3 compiler plugin (\CrossQuotesPlugin\) that rewrites Hearth's \Expr.quote\, \Expr.splice\, and \Type.of\ calls into native Scala 3 quoted syntax (\'{ }\, \${ }\, \scala.quoted.Type.of\). This enables the Cross-Quotes library to function on Scala 3 by injecting necessary \Quotes\ contexts and handling type constructor bindings, effectively extending the existing Scala 2 macro-based functionality to the Scala 3 platform.
hearth-cross-quotes/src/main/scala-3 · high confidence
Introduces Scala 3 tree printer and runtime-aware type printing
Adds new Scala 3-specific implementations for the better-printers module: \RuntimeAwareTypePrinterScala3\ enables printing type names at runtime by substituting overridden type arguments with runtime expressions, while \ShowCodePrettyScala3\ provides indented tree printers (\FormattedTreeStructure\ and \FormattedTreeStructureAnsi\) with syntax highlighting and support for complex types like unions and intersections.
hearth-better-printers/src/main/scala-3 · high confidence
Introduction of UntypedExpr API for source-code recovery
Added the UntypedExpr trait and its associated methods to the untyped package, providing a platform-agnostic representation for macro expressions that do not require full type information. This change introduces the ability to retrieve the original source text of an expression via the new sourceCode method, which is particularly useful for assert-style macros that need to echo the failing expression back to the user.
hearth/src/main/scala/hearth/untyped · high confidence
Introduction of compile-time TypeName type class for flexible type name printing
A new \TypeName\ type class has been added to the \hearth.typename\ package, providing four distinct methods for printing type names: \prettyPrint\ (ANSI colored, fully qualified), \plainPrint\ (fully qualified), \simplePrint\ (short name with type parameters), and \shortPrint\ (short name only). This functionality is implemented via a macro-based derivation system (\TypeNameMacros\) that automatically generates instances at compile time. The implementation includes performance optimizations such as caching of derived instances and lazy evaluation, and it supports runtime-aware type printing by replacing abstract type parameters with runtime values found in the implicit scope. This feature is available since version 0.3.0.
hearth/src/main/scala/hearth/typename · high confidence
New data comparison and rendering utilities
Added \DataCommons\ and \DiffEntry\ to the core data package, introducing capabilities to parse string representations into structured Data, compare Data instances to produce detailed mismatch reports (Diff) with path tracking, and render Data structures for debugging or display.
hearth/src/main/scala/hearth/data · high confidence
New debug utilities for inspecting macro expansions and types in IDE
Added \Debug\ and \DebugOps\ utilities in the \hearth.debug\ package that allow developers to inspect macro behavior directly in their IDE. These tools enable previewing the final expanded code, the Abstract Syntax Tree (AST), and the inferred types of expressions or summoned implicits without altering runtime behavior. This aids in debugging complex macro expansions by providing immediate feedback on what the compiler sees and generates.
hearth/src/main/scala-3/hearth/debug · high confidence
New debug utilities for printing AST, code, and inferred types in IDE output
Added DebugMacros to the hearth.debug package, providing utilities that report the final code, final AST, and inferred types of expressions directly to the IDE/compilation output. These tools assist developers in debugging macro expansions by exposing internal representation details during compilation.
hearth/src/main/scala/hearth/debug · high confidence
New hearth-munit testing artifact with custom suite traits
A new \hearth-munit\ artifact has been extracted, providing \hearth.Suite\, \hearth.MacroSuite\, and \hearth.ScalaCheckSuite\ traits for writing Hearth tests. \hearth.Suite\ extends MUnit to offer grouped test nesting, platform/Scala-version conditional ignoring, and Hearth-specific assertions like \\<==\>\ for structural \Data\ diffs. \MacroSuite\ adds utilities to assert on compilation error messages, while \ScalaCheckSuite\ integrates ScalaCheck properties into the Hearth test hierarchy.
hearth-munit · high confidence
New macro extensions for Java collection types
Added standard macro extensions to treat several Java collection types as Hearth collections, enabling them to be used seamlessly with Hearth's collection operations. The new providers include support for java.util.BitSet, java.util.Dictionary (including Properties), java.util.Enumeration, java.util.Iterator, java.util.Map (including EnumMap), java.util.Optional, and java.util.Stream. Each provider converts the Java type to a Scala Iterable, provides a Factory for building instances, and registers with the IsCollection system. Notable details: EnumMap detection uses symbolic type comparison rather than Class.forName to avoid issues with enums defined in the same compilation run; EnumSet handling uses Class.forName strings to survive Scala 2's quote re-typechecking; and Java Map providers emit code requiring JDK 9+ at runtime (java.util.Map.entry).
hearth/src/main/scalajvm/hearth/std · high confidence
New macro-based debug utilities for inspecting code, ASTs, and types in IDEs
Added \Debug\ and \DebugOps\ utilities in the \hearth.debug\ package that allow developers to inspect macro expansions, abstract syntax trees (ASTs), and inferred types directly within their IDE. These tools provide both functional (\Debug.withFinalCodeInIDE\) and extension-method (\expr.withFinalCodeInIDE\) interfaces to help understand how code is transformed and typed during compilation, aiding in debugging and development workflows.
hearth/src/main/scala-2/hearth/debug · high confidence
New micro-FP library with stack-safe macro effects and structured logging
Adds the \hearth-micro-fp\ artifact, providing a lightweight functional programming library designed for macro-time execution. This includes \MIO\, a stack-safe, JVM-only effect system for managing macro-side state, errors, and logging without external dependencies like Cats; \MEval\ for pure, stack-safe evaluation; and \MLocal\ for managing scoped mutable state within \MIO\ computations. The library also introduces structured logging via \Log\ and \LogRendering\, allowing macros to build hierarchical log trees that are filtered and rendered at the end of expansion, as well as a \FlameGraph\ renderer for performance profiling. Additionally, it provides immutable, non-empty collection types (\NonEmptyList\, \NonEmptyVector\, \NonEmptyMap\) with \Traverse\ and \ParallelTraverse\ instances, and a \NaturalLanguageOrdering\ for comparing strings by numeric value.
repository · high confidence
New source-code position utilities for macros
Added \SourceMacros\ and associated types (\MethodName\, \Line\, \File\, \FileName\, \Text\) to the \hearth.source\ package. These macros allow compile-time access to the enclosing method name, line number, file path, and file name, and provide a \Text\[T\]\ materializer that captures the source code representation of an expression. This enables assert macros and other compile-time checks to report precise source locations and original code snippets in error messages.
hearth/src/main/scala/hearth/source · high confidence
New typed macro API with cross-version quote/splice support
This release introduces a new \hearth.typed\ package providing a portable, cross-version API for compile-time code generation and type reflection. It adds \Expr.quote\ and \Expr.splice\ for quoting and splicing expressions, and \Type.of\ for materializing type representations, all rewritten by a Cross-Quotes plugin to work consistently on both Scala 2 and Scala 3. The package also includes comprehensive \TypeCodec\ and \ExprCodec\ implementations for standard types, tuples, and IArrays, along with runtime-aware type printing capabilities.
hearth/src/main/scala-3/hearth/typed · high confidence
Scala 2 reflection implementation for untyped expressions, methods, and types
This change introduces the Scala 2-specific implementations for the library's core reflection abstractions, providing the concrete logic for handling untyped expressions, method parameters, and type metadata on the Scala 2 platform. It ensures consistent behavior across Scala 2 and 3 by normalizing vararg types to \Seq\, resolving synthetic case accessor visibility, and correctly mapping type bounds and companion objects, enabling the library to inspect and manipulate code structures at compile time on Scala 2.
hearth/src/main/scala-2/hearth/untyped · high confidence
Scala 2 support for typed expressions and type codecs
This change adds the Scala 2 implementation layer for Hearth's typed API, enabling cross-platform functionality previously limited to Scala 3. It introduces \Expr.quote\ and \Expr.splice\ macros that rewrite code into native Scala 2 quasiquotes, allowing users to generate typed ASTs with IDE support. It also provides \Type.of\ to materialize type information using \WeakTypeTag\, and implements \TypeCodec\ and \ExprCodec\ for primitives, tuples, and case classes via semi-automatic derivation. This allows users to use Hearth's reflection and code-generation features on Scala 2.12 and 2.13.
hearth/src/main/scala-2/hearth/typed · high confidence
Semi-automatic derivation for ExprCodec with override maps and improved error reporting
The typed module now supports semi-automatic derivation of \ExprCodec\ for case classes, sealed traits, and singletons via \ExprCodec.derived\. This feature introduces \semiQuote\ and \semiEval\ utilities that accept override maps, allowing users to customize how specific types are encoded or decoded during macro expansion. Additionally, when derivation fails for an unsupported type, the macro now reports a clean, positioned compiler diagnostic instead of throwing an opaque \AssertionError\, making it easier to identify and fix issues in user code.
hearth/src/main/scala/hearth/typed · high confidence
Source code capture utilities for Scala 2 and 3
Added source-code capture utilities (Method, Line, File, FileName, and Text) for both Scala 2 and Scala 3. These utilities allow runtime access to the source text of values at the call site, enabling more informative error messages and debugging output in assert macros and other library features.
hearth/src/main/scala-2/hearth/source, hearth/src/main/scala-3/hearth/source · high confidence
Behavioural changes
Add platform-specific service loader and version compatibility layers
The library now includes platform-specific implementations for service loading and version tracking across Scala.js, JVM, and Scala Native. This introduces \loaderJs\, \loaderJvm\, and \loaderNative\ files that define how \ServiceLoader\ is instantiated on each platform, with Scala Native using a reflection-based workaround to bypass runtime limitations. Additionally, \versionsJs\, \versionsJvm\, and \versionsNative\ files expose the target platform (\Platform.Js\, \Platform.Jvm\, or \Platform.Native\) via a \byHearth\ value, enabling the library to identify its compilation target at runtime.
hearth/src/main/scalajs, hearth/src/main/scalajvm/hearth, hearth/src/main/scalanative · high confidence
Build system refactored to use sbt-kubuszok and new source generation plugins
The build configuration has been consolidated by replacing individual plugins (sbt-git, sbt-scalafmt, sbt-projectmatrix, sbt-commandmatrix, sbt-pgp, sbt-mima-plugin, sbt-ide-settings, sbt-welcome, sbt-scalajs, sbt-scala-native) with the single sbt-kubuszok plugin (0.2.3). Additionally, new auto-plugins (SourceGenPlugin, ServiceResourceGenPlugin) and generators (TypeConstructorsGen, CrossQuotesMacrosGen, CrossCtorTestGen, ArityGen) have been introduced to automate the generation of arity-based type constructor code, cross-quotes macro implementations, and test fixtures, while sbt has been upgraded to 1.13.0.
project · high confidence
Direct-style execution and flexible log rendering in MIO
The MIO effect system now supports a direct-style execution mode via DirectStyleExecutor, which runs code in a separate thread (using JDK 17+ virtual threads with a fallback) to prevent stack overflow errors during recursive operations and handles termination signals (Ctrl+C) via TerminationObserver. Additionally, log rendering has become more flexible, allowing users to render logs as trees filtered by level or as speedscope-compatible JSON flame graphs for performance profiling.
hearth-micro-fp/src/main/scala/hearth/fp/effect · high confidence
Scala 2 macro implementation for cross-quotes, environments, and version detection
This change introduces the Scala 2-specific implementation layer for Hearth's macro infrastructure, enabling features that were previously Scala 3-only or incomplete. It adds \EnvironmentCrossQuotesSupport\ to strip free type symbols from expression trees, preventing compiler rejections when using \Expr.splice\ with local type parameters. It implements \EnvironmentsScala2\ to provide accurate source-position reporting (including corrections for macro parameter lists) and builds the lexical enclosure chain (\enclosingScope\), which allows dependency injection to resolve local \val\s within method bodies. Additionally, it provides \MacroCommonsScala2\ to wire these components together and \versionsScala2\ to detect the Scala and JDK versions at compile time via macros.
hearth/src/main/scala-2/hearth · high confidence
Scala 3 macro infrastructure and cross-quote context management
This change introduces the core Scala 3 implementation for Hearth's macro system, including \MacroCommonsScala3\ and platform-specific environment handling. It adds \withQuotes\ and \passQuotes\ utilities to correctly manage \scala.quoted.Quotes\ context when nesting \Expr.quote\ and \Expr.splice\ calls, and introduces \withMacroEntryCtx\ to fix scope exceptions (\#317/\#318) when derivations run inside splices. The update also implements \enclosingScope\ to expose lexical enclosures (methods, classes, objects) for dependency injection, and provides compile-time macros to detect the current Scala and JDK versions.
hearth/src/main/scala-3/hearth · high confidence
Scala 3 untyped macro implementation and vararg normalization
This change introduces the Scala 3-specific implementations for untyped macro expressions and method parameter handling. It adds \UntypedExprsScala3\ to bridge typed and untyped expression representations and \UntypedMethodsScala3\ to parse method signatures. A key behavioral update is the normalization of vararg parameters: raw repeated-parameter types (such as \scala.\<repeated\>\[A\]\ or \Seq\[A\] @Repeated\) are now converted to \scala.collection.immutable.Seq\[A\]\ to ensure consistent type metadata across Scala 2 and 3. The implementation also correctly resolves by-name parameters and implicit/given flags by inspecting the owning method's signature, addressing previous issues where these properties were incorrectly detected.
hearth/src/main/scala-3/hearth/untyped · high confidence
Updated scalafmt to 3.11.5 and refined formatting configuration
The project's code formatter has been upgraded from version 3.9.4 to 3.11.5. This update includes expanded file path overrides to explicitly apply the Scala 3 dialect to new source directories (scala-lts-3, scala-next-lts-3, scala-next-3) and test suites, ensuring consistent formatting across all Scala 3 variants. Additionally, the configuration now excludes specific generated files and test specs from formatting checks, enables standard library strip margin handling, and enforces import sorting and modifier ordering.
(repo-wide) · high confidence
Test coverage
Added Java example classes and Scala 2 macro fixtures for Hearth tests; Added cross-version sandwich tests for typed macros; Expanded test coverage for macro behavior and type system features.
Dependencies
Update build dependencies and add documentation requirements
The build configuration has been updated to use Scala 3.3.8 and Scala 2.13.16, dropping support for Scala 2.12. Several library dependencies have been upgraded, including munit to 1.3.6, scalacheck to 1.20.0, scala-xml to 2.5.0, and kind-projector to 0.13.4. The build system now utilizes the sbt-kubuszok plugin for simplified configuration and regression testing tiers. Additionally, a new docs/requirements.txt file has been added to specify MkDocs, the MkDocs Macros plugin, and MkDocs Material for documentation generation.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 53 → 62 (+9.4)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 57 → 57 (+0.1)
- Architecture 85 → 83 (-1.3)
- Maturity 40 → 66 (+25.4)
- Readiness 62 → 62 (+0.0)
- Security 76 → 67 (-9.4)
- Performance 78 → 100 (+22.3)
Resolved (42)
- CrossQuotesPhase.run (cognitive 80) (hearth-cross-quotes/src/main/scala-3/hearth/cq/CrossQuotesPlugin.scala)
- CrossQuotesPhase.run (cyclomatic 74) (hearth-cross-quotes/src/main/scala-3/hearth/cq/CrossQuotesPlugin.scala)
- Duplicated block (12–13 lines × 2) (hearth/src/main/scala-3/hearth/std/extensions/IsCollectionProviderForIArray.scala)
- Duplicated block (14 lines × 2) (hearth/src/main/scala-3/hearth/std/extensions/IsCollectionProviderForIArray.scala)
- Duplicated block (14 lines × 22) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (45 lines × 2) (hearth-cross-quotes/src/main/scala-2/hearth/cq/CrossQuotesMacros.scala)
- Duplicated block (5 lines × 2) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (5 lines × 3) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (5–6 lines × 12) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (5–6 lines × 15) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (5–6 lines × 18) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (5–6 lines × 9) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (5–7 lines × 6) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (6 lines × 2) (hearth-better-printers/src/main/scala-3/hearth/treeprinter/RuntimeAwareTypePrinterScala3.scala)
- Duplicated block (6 lines × 20) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (7–8 lines × 12) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (7–8 lines × 16) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (7–8 lines × 4) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (7–8 lines × 8) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (8–9 lines × 20) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- …and 22 more
New (43)
- Change coupling: ClassesFixtures.scala ↔ classes.scala (hearth-tests/src/main/scala-2/hearth/typed/ClassesFixtures.scala)
- Change coupling: ClassesFixtures.scala ↔ classes.scala (hearth-tests/src/main/scala-3/hearth/typed/ClassesFixtures.scala)
- CrossQuotesTreeMap.transform (cognitive 23) (hearth-cross-quotes/src/main/scala-3/hearth/cq/CrossQuotesPlugin.scala)
- CrossQuotesTreeMap.transform (cyclomatic 29) (hearth-cross-quotes/src/main/scala-3/hearth/cq/CrossQuotesPlugin.scala)
- Duplicated block (11–12 lines × 2) (hearth/src/main/scala-3/hearth/std/extensions/IsCollectionProviderForIArray.scala)
- Duplicated block (12 lines × 2) (hearth/src/main/scala-3/hearth/std/extensions/IsCollectionProviderForIArray.scala)
- Duplicated block (37 lines × 2) (hearth-cross-quotes/src/main/scala-2/hearth/cq/CrossQuotesMacros.scala)
- Duplicated block (5 lines × 2) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (8–9 lines × 11) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (8–9 lines × 15) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (8–9 lines × 19) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (8–9 lines × 7) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Duplicated block (9 lines × 2) (hearth/src/main/scala-3/hearth/std/extensions/IsCollectionProviderForIArray.scala)
- Duplicated block (9 lines × 3) (hearth/src/main/scala-3/hearth/typed/ExprsScala3.scala)
- Edited copy of a member (12 corresponding lines) (hearth/src/main/scala-2/hearth/typed/TypesScala2.scala)
- Edited copy of a member (20 corresponding lines) (hearth/src/main/scala-2/hearth/typed/ExprsScala2.scala)
- Edited copy of a member (25 corresponding lines) (hearth/src/main/scala-2/hearth/typed/ExprsScala2.scala)
- Hotspot: hearth/src/main/scala-2/hearth/untyped/UntypedMethodsScala2.scala (hearth/src/main/scala-2/hearth/untyped/UntypedMethodsScala2.scala)
- Hotspot: hearth/src/main/scala-3/hearth/untyped/UntypedMethodsScala3.scala (hearth/src/main/scala-3/hearth/untyped/UntypedMethodsScala3.scala)
- Hotspot: hearth/src/main/scala-3/hearth/untyped/UntypedTypesScala3.scala (hearth/src/main/scala-3/hearth/untyped/UntypedTypesScala3.scala)
- …and 23 more
Changes since last survey
- 26 commits — 26 feature/other, 0 fixes
By area
- hearth-tests/src — 12 commits
- (root) — 4 commits
- docs/user-guide — 2 commits
- hearth/src — 2 commits
- project/CrossCtorTestGen.scala — 2 commits
- docs/contributing — 1 commit
- docs/mkdocs.yml — 1 commit
- hearth-better-printers/src — 1 commit
- project/build.properties — 1 commit
Notable commits
- change: Add Environment.enclosingMethodParameters
- change: Add Type.isFunction/isContextFunction/functionComponents; document fqcn
- change: Add Type.pseudoCompanionObject for newtype encodings
- change: Add VarArgs.toIterableOption to detect splatted varargs
- change: Add code comment guidelines to AGENTS.md
- change: Align markdown tables
- change: Apply the comment guidelines to the codebase
- change: Attempt to use Scala Next
- change: Bump Scala 3 versions
- change: Bump Scala 3 versions in docs
- change: Cross-quotes (Scala 2): CtorN.of/CtorK1.of on the macro method's own type parameter
- change: Cross-quotes (Scala 3): scope imported Type givens from the import onwards
- change: CtorN.of unapply (Scala 3): read type arguments off the base type of subtypes
- change: CtorN.of unapply (Scala 3): widen singleton types before matching
- change: Docs: add llms.txt, document missing APIs, highlight integrate-once extensions
- change: Docs: make clear Hearth is worth it for single-version macros too
- change: Exclude test examples from coverage
- change: Fix formatting of newtype test stubs
- change: Keep ShowCodePrettyScala3 case arrows unaligned (no code-line churn)
- change: Keep method bodies under Scala 3.3.9's coverage instrumentation limit
- …and 6 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
kubuszok/hearth 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.
About this page
- The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 2925fae6030234489fc4235080a59f180c8799fe — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-5f8314471808.