1.0.0-alpha03

Drop-in from 1.0.0-alpha02 — additive changes and a metadata fix, no breaking changes.

Added

• katalyst-starter-observability — one dependency line adds the bounded in-process telemetry layer and the embedded TUI inspector to an app. It's kept out of katalyst-starter-core on purpose: telemetry's capturers reach into persistence, transactions, migrations, scheduler, events and Ktor, so folding it into core would force those modules onto every app's classpath regardless of the starters it chose. Add it explicitly when you want observability.
• katalyst-tui is now on Maven Central. The terminal inspector was previously resolvable only through a composite build or mavenLocal; external consumers can now depend on it directly. It's also the prerequisite for the observability starter above.
• Katalyst Initializr — a browser-based project generator. Pick a package, an engine and the feature starters you want, and download a ready-to-run service — generated entirely in the browser, no backend. Live at https://darkryh.github.io/katalyst/new/ with this release. (Tooling, not a dependency.)

Fixed

• Every published artifact's POM <name> and <description> now carry the real module name. $name inside the pom { } block was resolving to Maven's own unset name property instead of the project name, so artifacts — the BOM included — shipped with <name>Katalyst - property 'name'</name>. Metadata only, no code change, but it's what shows on Maven Central and in dependency insight.

Full changelog: v1.0.0-alpha02...v1.0.0-alpha03

1.0.0-alpha02

Second alpha of Katalyst: observability lands, packaging gets honest, and the terminal becomes the framework's default developer console.

Katalyst Inspector (terminal UI)

• With katalyst-tui on the runtime classpath, the backend running in a real terminal (java -jar, ssh, run.sh) boots straight into a full-screen inspector: paced boot splash, Command Deck dashboard, and one drill-down screen per subsystem — Boot, Wiring, HTTP, Scheduler, Persistence, Transactions, Migrations, Events, WebSockets, Config. No TTY → plain logs with a one-time notice. Opt out with -Dkatalyst.tui.enabled=false.
• One keyboard model everywhere: type to filter, arrows to move, Enter drills, Esc goes back. /exit detaches and leaves the server running; /shutdown stops everything.
• Idle 30s → the inspector hibernates: frame frozen, polling paused, caches released; any key wakes it instantly.

Telemetry

• New katalyst-telemetry-model (wire contract) and katalyst-telemetry (auto-loaded capture feature + loopback-only, token-guarded transport). Every subsystem feeds it: HTTP traffic, transaction outcomes, migrations, events, scheduler — including per-run job history with captured failure detail.
• WebSocket instrumentation through katalystWebSockets { }: live sessions, frame/byte counters, close outcomes. Existing route code compiles unchanged.
• Memory bounded by construction everywhere — fixed histograms, capped maps, overwrite rings. O(app shape), never O(traffic).

Packaging

• katalyst-starter-web no longer bundles Netty: pick exactly one engine starter (katalyst-starter-engine-netty | -jetty | -cio).
• New consumer Gradle plugin io.github.darkryh.katalyst wires kotlin.jvm + serialization + application for you.
• BOM refreshed; all 39 artifacts published to Maven Central as io.github.darkryh.katalyst:*:1.0.0-alpha02.

Tooling

• Dependency-graph analysis and the IntelliJ plugin now recognize @ConfigPrefix classes; a parity test guards the plugin's vendored contract against drift.
• CI gates: build/test, binary-compatibility (apiCheck), Kover coverage floor, Pitest mutation testing.

1.0.0-alpha01

This is the first 1.0.0 alpha. It's a milestone release that reworks how a Katalyst app is bootstrapped: dependency injection is no longer hard-wired to Koin, configuration sources are pluggable, and the application DSL is now fully explicit. Expect breaking changes — that's what the alpha is for.

Breaking changes — read this before upgrading

• You must now declare a bean engine explicitly. DI is no longer bound to Koin internally. Add the katalyst-koin-bean dependency and call beanEngine(KoinBeanEngine) in your katalystApplication { … } block. Internally this is backed by the new KatalystContainer / KatalystBeanEngine abstraction, so other engines can be plugged in.
• Configuration is no longer auto-installed. Install your source explicitly with enableYamlConfiguration(), then pull settings from it (e.g. database { fromConfiguration() }). ConfigProviderFactory has been removed and YamlConfigProvider is now YamlConfigurationSource, loaded through a new config SPI.
• Bootstrap is fully explicit. The startup flow is now engine(...) → beanEngine(...) → enableYamlConfiguration() → database { … } → scanPackages(...) → schema { … } → features { … }. There's no implicit config or bean wiring anymore. See the migrated sample and the docs for the full shape.
• Ktor route extensions renamed. KoinRouteExtensions is now KatalystRouteExtensions (KoinRouteExtensionsTest → container-based equivalents). Update imports accordingly.
• Engine modules no longer ship a Main.kt. The Netty/Jetty/CIO modules now expose embedded server objects (NettyServer/EmbeddedNettyServer, and the Jetty/CIO equivalents) that you pass to engine(...).

Added

• Spring Boot-style starters — katalyst-starter-core, -web, -persistence, -migrations, -scheduler, -websockets, and -test for one-line dependency setup.
• katalyst-bom — a BOM to keep all Katalyst modules on the same version.
• Pluggable bean engine — katalyst-koin-bean provides the Koin-backed KoinBeanEngine behind the new KatalystBeanEngine / KatalystContainer SPI.
• Pluggable configuration sources — a new katalyst-config-spi lets configuration formats be resolved via SPI; YAML is one implementation.
• katalyst-analysis — a static analysis layer that builds a graph of your application (components, routes, schedulers, events) for tooling, CLIs, and tests.
• IntelliJ IDEA plugin (katalyst-intellij-plugin) — gutter markers, DSL/event-handler/scheduler inspections, and cron expression inlay hints. Built as a separate composite (opt in with -PincludeIntellijPluginComposite=true).
• katalyst-conventions — a zero-dependency module holding shared conventions and contracts as a single source of truth.
• Graceful shutdown for Netty, plus configurable WebSocketOptions.
• Public API tracking — .api dumps across every module via the Kotlin binary-compatibility validator, so future breaking changes are caught at build time.
• A documentation site built with MkDocs (docs/): getting started, how-to guides, reference, and architecture/design-decision explanations.

Changed

• Documentation was restructured: the old documentation/ folder was replaced by the docs/ tree and an MkDocs site, and the README was rewritten around the explicit bootstrap workflow.
• Runtime modules (events, scheduler, transactions, persistence, websockets) were realigned around the container DSL.
• Dependency versions updated in gradle/libs.versions.toml.
• Samples migrated to the new explicit katalyst DSL.

Reliability

• Added extensive concurrency, load, soak, and resilience coverage — connection-pool saturation, transaction timeout/connection release, Postgres resilience, scheduler starvation/drain, event-bus backpressure and soak, plus JMH benchmarks for the event deduplication store.

Full changelog: v0.3.2-alpha...v1.0.0-alpha01

v0.3.2-alpha

Upgraded Exposed to 1.3.0.

Katalyst 0.3.1-alpha

Hotfix

This release fixes a startup regression in 0.3.0-alpha where automatic DI could validate an interface dependency as available but still instantiate the consumer before the discovered concrete implementation.

Fixed

• Secondary/interface dependencies are now normalized to their concrete provider nodes during component ordering.
• Cycle detection now follows secondary/interface provider edges, so cycles hidden behind interfaces are detected before runtime.
• Order validation now verifies the concrete provider order, not only direct class dependencies.
• Reflective constructor/function invocation now unwraps InvocationTargetException so startup logs show the real underlying error message instead of null.

Why this matters

Large applications can now inject interface-shaped services such, without manually forcing lazy/provider APIs or removing constructor parameters. Katalyst decides the safe eager order from the discovered graph.

Migration

No API migration is required from 0.3.0-alpha. Update the Katalyst version to 0.3.1-alpha.

Katalyst 0.3.0-alpha

Breaking changes

• Removed the public deferred constructor-injection API from Katalyst DI. Provider<T>, Katalyst Lazy<T> handling, and () -> T function-provider parsing are no longer part of the automatic wiring model. Use normal constructor or framework-function parameters instead.
• Removed deferred-injection modes from InjectionMode; the remaining mode is direct resolution.
• Removed legacy DI classes that were no longer part of the active workflow: Provider, KoinProvider, DiscoverySummaryLogger, ErrorFormatter, PostRegistrationValidationException, ValidationLogicException, and ScannerDIModule.
• Removed deferred-injection tests and docs that described the old provider/lazy workflow.
• Required scalar parameters such as Int, Long, Boolean, String, and enums now fail clearly unless they are supplied by Kotlin defaults, nullable parameters, named bindings, or explicit Koin/config bindings.

What changed

• Added a shared invocation layer for automatic injection: CallableInvoker and ParameterResolver now power constructor creation, Ktor route function installation, and scheduler method invocation with consistent parameter rules.
• Route functions can now declare injectable parameters directly, for example fun Route.authRoutes(service: AuthenticationService), and Katalyst fails fast if route wiring is invalid.
• Scheduler discovery/invocation now supports Kotlin default parameters and injectable config/service parameters, fixing scheduler startup crashes caused by optional primitive parameters.
• Added a planning boundary for DI bootstrap with DiscoverySnapshot, BindingPlan, BindingPlanBuilder, TypeKey, and InjectionStrategyResolver, making discovery/registration behavior easier to validate and evolve.
• Improved dependency diagnostics: fatal validation reports are rendered side-effect-free, startup emits one user-facing diagnostic instead of duplicated print/log output, and expected validation detail logs moved to debug.
• Reduced noisy transaction error logging for expected business/validation rollbacks; route/domain exception handlers now own the user-facing warning/error response.
• Updated the sample application to use direct route parameter injection and verified live endpoints against H2.
• Updated docs for the new auto-wiring model and added a detailed redesign plan in documentation/auto-injection-redesign-plan.md.
• Updated Exposed-related version catalogs to 1.2.0.

Migration notes

• Replace Provider<T>, Katalyst-specific Lazy<T>, or () -> T constructor dependencies with normal dependency parameters.
• For scalar values, prefer config objects, @InjectNamed bindings, nullable/default parameters, or explicit Koin bindings.
• For route and scheduler setup, declare services/config objects directly as function parameters and let Katalyst resolve them during startup.

0.2.0-alpha

0.2.0-alpha (Pre-release)

This alpha focuses on startup lifecycle correctness, reduced runtime noise, and safer configuration resolution.

Highlights

• Scheduler and runtime-ready hooks now execute strictly after Ktor signals server readiness (ServerReady).
• Bootstrap reporting moved from numeric phases to named lifecycle references for clearer operations/debugging.
• Transaction logging defaults are quieter while preserving actionable success/failure outcomes.
• Environment variable substitution is more robust for real shell-style values (including inline comment sanitization).

Fixed Issues

• #14 scheduler: always start tasks after Ktor readiness (remove pre-start mode)
• #13 transactions: reduce transaction phase log verbosity by default
• #12 transactions: classify expected business exceptions below ERROR
• #11 di: fix false feature classpath negatives in DependencyAnalyzer
• #10 scanner: avoid WARN on empty optional discovery results

Technical Changes

• Added explicit runtime-ready lifecycle orchestration and ordering after readiness.
• Improved startup/lifecycle telemetry and health detail reporting around lifecycle completion.
• Hardened transaction exception severity classification to better separate expected domain failures from unexpected failures.
• Refined dependency analyzer behavior to reduce false negatives/positives during feature detection.
• Updated env substitution and parser testability to support deterministic providers and broader edge-case coverage.

Upgrade Notes

• This is an alpha prerelease.
• transaction.logging.enabled is the canonical switch for transaction logging behavior.
• If you rely on startup log parsing, migrate consumers from phase-number parsing to lifecycle-reference parsing.

Full Changelog: v0.1.3-alpha...v0.2.0-alpha

0.1.3-alpha

0.1.3-alpha (Pre-release)

This alpha focuses on initializer API cleanup, bootstrap ergonomics, and scheduler registration correctness.

Highlights

• Breaking change: ApplicationInitializer now uses onApplicationReady() (no Koin parameter).
• Added DatabaseFactory.withStatement(...) helper API for custom bootstrap SQL execution.
• Fixed scheduler discovery bug where multiple scheduler methods in a single service could be silently overwritten.
• Improved scheduler diagnostics and deterministic candidate ordering.

Fixed Issues

• #9 katalyst-scheduler: only one scheduler method per service was being registered due to map overwrite.

Technical Changes / Breaking changes

• Refactored initializer lifecycle to constructor-injected dependencies + no-arg readiness hook.
• Updated InitializerRegistry and StartupValidator to new initializer contract.
• Updated SchedulerInitializer pipeline to preserve all (service, method) candidates.
• Hardened scheduler bytecode validation for Kotlin-mangled scheduler JVM method names.
• Added persistence extension:
  • DatabaseFactory.withStatement(autoCommit = true) { ... }
  • DatabaseFactory.withStatement(log, skipLabel, autoCommit = true) { ... }

Upgrade Notes

• This remains an alpha prerelease.
• Any custom ApplicationInitializer implementations must migrate from:
  • onApplicationReady(koin: Koin)
    to:
  • onApplicationReady()

0.1.2-alpha

0.1.2-alpha (Pre-release)
This alpha focuses on transaction correctness for startup

Highlights

• Rollback to Jvm 21 as base
• fixed problem on initialization schema was duplicated on start
• fix transaction timeout (from 30 to 60) on db migration process on startup validation (with longer timeout) in longer connections like supabase/remote the timeout triggers ONLY on bigger projects (multiple schema/tables)
• fixed initialization will be faster due to exposed batches option on schema/tables initialization

0.1.1-alpha

0.1.1-alpha (Pre-release)

This alpha focuses on transaction correctness for nullable results and reliability under retry/timeout paths.

Highlights

• Fixed nullable transaction result handling in katalyst-transactions.
• Real timeouts are now detected explicitly without conflating valid null returns.
• Preserved retry behavior for true timeout/transient failures.
• Added targeted unit + integration regression coverage.

Fixed Issues

• #8 katalyst-transactions: nullable transaction result was misclassified as timeout.

Technical Changes

• Replaced timeout sentinel logic (withTimeoutOrNull) with exception-based timeout mapping (withTimeout + TimeoutCancellationException -> TransactionTimeoutException).
• Kept transaction scope/workflow context lifecycle unchanged.
• Kept transient retry/backoff semantics unchanged for real timeout failures.

Validation

• :katalyst-transactions:test passed on Java 23.
• :katalyst-example:test --tests "*TransactionBoundaryReliabilityIntegrationTest" --rerun-tasks passed.
• Added regression tests for:
  • nullable transaction { null } returning null without retry
  • true timeout still retrying and failing as TransactionTimeoutException
  • timeout-first then nullable-success path
  • sample nullable repository lookup returning null without timeout misclassification

Upgrade Notes

• Maven version updated to 0.1.1-alpha.
• This remains an alpha prerelease.
• Validate in staging before production rollout.