wvlet/airframe

This system is a comprehensive Scala framework providing dependency injection, reactive programming primitives, and multi-platform support for JVM, Scala.js, and Scala Native. It includes a suite of utilities for configuration management, structured logging, and high-performance serialization via JSON and MessagePack. Additionally, it offers robust HTTP and gRPC client/server implementations with code generation capabilities, alongside tools for SQL parsing and UI rendering.

66 changes.

This period focused on expanding the Airframe ecosystem with new modules for JDBC, SQL parsing, JMX monitoring, and high-performance canvas buffers, while migrating core libraries like codec and msgpack to pure-Scala implementations. Significant effort was dedicated to ensuring cross-platform compatibility across JVM, Scala.js, and Scala Native, alongside a comprehensive overhaul of the testing framework and documentation infrastructure.

80 changes.

This period established the foundational airframe-rx reactive library and expanded airframe-http to support gRPC, Scala.js, and JDK 11. It introduced new modules for HTML rendering, metrics, and logging while implementing comprehensive Scala 3 compatibility across the codebase.

40 changes.

This period focused on extending Airframe's compatibility to Scala 3 and Scala Native across multiple modules, including HTTP, logging, and configuration. Significant work also involved refactoring the HTTP client architecture with new standard interfaces, adding a Netty backend, and implementing comprehensive test coverage for these new platforms and features.

A new gallery demo has been added to the examples/rx-demo/gallery location, providing a web-based showcase for Airframe Rx. The entry point (index.html) loads Bootstrap 4.4.1 and highlight.js v9.17.1 to render code snippets with syntax highlighting. Custom styles in overwrite.css apply an 'Ocean' color theme to the highlighted code and adjust the navbar appearance. The demo is wired to the Scala.js compiled output (gallery-fastopt.js) and initializes the gallery view and code highlighting on load.

examples/rx-demo/gallery · high confidence

A new CorsFilter has been added to the Finagle HTTP backend, allowing users to apply Cross-Origin Resource Sharing policies to their services. The filter wraps Finagle's standard Cors.HttpFilter and exposes a convenient unsafePermissiveFilter for development, enabling easier handling of cross-origin requests in Finagle-based applications.

airframe-http-finagle/src/main/scala/wvlet/airframe/http/finagle/filter · high confidence

Introduces a new example project demonstrating how to use Airframe RPC with Scala. The change adds the GreeterApi interface, defining a simple 'hello' method that logs incoming requests and returns a greeting, along with the corresponding RxRouterProvider configuration to expose this service.

examples/rpc-examples/hello-rpc/api · high confidence

The airframe-benchmark module now includes new benchmark suites for HTTP and gRPC performance. This adds a Protobuf definition for a Greeter service, generated Java protobuf classes, and Scala implementations for gRPC clients and servers (including Netty-backed servers and async/sync clients). It also introduces HTTP benchmark components for testing synchronous and asynchronous client interactions, alongside existing JSON parsing benchmarks that compare Airframe against Circe and json4s-jackson.

airframe-benchmark/src/main · high confidence

Scala Native applications can now make HTTP requests using the Airframe HTTP client. This change introduces a new compatibility layer and a libcurl-based backend (NativeHttpClientBackend) that provides both synchronous and asynchronous client capabilities. The implementation handles standard HTTP methods, custom headers, request bodies, timeouts, automatic redirects, and decompression, while managing platform-specific details like URL encoding and RPC context.

airframe-http/.native · high confidence

This change introduces three new internal Scala files for the JVM implementation of airframe-http. LocalRPCContext provides a ThreadLocal-based mechanism to manage RPC context across threads, supporting attach and detach operations to preserve context state. LogRotationHttpLogger implements an asynchronous HTTP logger that writes access logs to files with automatic rotation based on size and file count, using a custom formatter that excludes exception stack traces. TLSSupport adds a trait for managing thread-local storage maps, allowing key-value pairs to be set, retrieved, and cleared within the current thread's context.

airframe-http/.jvm/src/main/scala/wvlet/airframe/http/internal · high confidence

Introduces new \TimeStampFormatter\ and \package.scala\ components in the JVM metrics module to handle timestamp formatting and timezone resolution, alongside comprehensive test suites (\TimeParserTest\, \TimeVectorTest\, \TimeWindowTest\) that validate the parsing of human-friendly time ranges, duration offsets, and timezone-aware date strings.

airframe-metrics/.jvm · high confidence

This change introduces the JSLogger, LogEnv, and LogTimestampFormatter components for the airframe-log library on the Scala.js platform. JSLogger exposes setDefaultLogLevel and setLogLevel functions to JavaScript via @JSExportTopLevel, allowing external JS code to control logging levels. LogEnv provides the Scala.js-specific environment configuration, utilizing JSConsoleLogHandler for output and handling class name resolution differences inherent to Scala.js. LogTimestampFormatter adapts timestamp formatting to use JavaScript's Date object. Additionally, the test suite has been refactored to specifically test the JSConsoleLogHandler functionality.

airframe-log/.js · high confidence

The airframe-rx-widget module now includes a Scala.js facade for the Monaco code editor, enabling rich code-editing capabilities within reactive UIs. Additionally, it introduces a set of Twitter Bootstrap UI components, including alert styles (primary, secondary, success, etc.) and layout helpers (rows, columns, containers, flexbox), along with extension methods for styling RxElements with Bootstrap classes like borders, rounded corners, and shadows.

airframe-rx-widget/src/main · high confidence

Users can now use OkHttp as the underlying HTTP client implementation for airframe-http by calling \OkHttp.client\. This new module provides an \HttpClientBackend\ and \HttpChannel\ that wrap the OkHttp library, supporting both synchronous and asynchronous requests via Rx, configurable timeouts, and optional enforcement of HTTP/1.1.

airframe-http-okhttp/src/main · high confidence

A new RPC example project has been added to the examples directory, demonstrating how to build an RPC service using Scala and Scala.js. The example includes a server component and a Scala.js-based UI, with instructions to compile the frontend using \sbt ui/fastLinkJS\ and start the server via \sbt server/run server\, accessible at http://localhost:8080/ui/index.html.

examples/rpc-examples/rpc-scalajs, examples/rpc-examples/rpc-scalajs/server · high confidence

The website now includes new React components for the English documentation site, specifically adding pages for the home index, user showcase, and help/support sections. These pages utilize the site's CompLibrary to render structured content, including feature callouts, community links, and user logos, replacing or supplementing the previous static documentation structure.

website/pages · high confidence

Added a new example project in examples/rpc-examples/hello-rpc that demonstrates how to use RPC with Netty and Scala 3. The example includes a GreeterMain application that supports starting an RPC server and sending client requests, along with configuration files for formatting and documentation.

examples/rpc-examples/hello-rpc · high confidence

New Scala 3-specific source files (HtmlCompat.scala, common.scala) have been added to the airframe-rx-html module to support Scala 3 syntax and type classes. This includes a placeholder for extracting RxElement source code for demo purposes and the definition of implicit conversions and type classes (EmbeddableAttribute, EmbeddableNode) required to render HTML nodes and attributes in Scala 3.

airframe-rx-html/src/main/scala-3 · high confidence

This change introduces core logging infrastructure for Scala 3 and Scala.js. It adds a macro (LoggerMacros) to capture source location information at compile time and provides platform-specific logger components for JavaScript, including JSLogger for exporting log level settings to the JS environment, LogEnv for configuring JS-specific defaults and handlers, and LogTimestampFormatter for formatting timestamps using JavaScript Date objects.

airframe-core-base, airframe-core/.js · high confidence

New platform-specific compatibility files have been added to the airframe-codec and airframe-control modules to support Scala Native builds. In the codec module, the native shim provides default message codec finding and instant parsing, but explicitly disables binary UUID reading by throwing an exception, ensuring the library compiles and runs on Native while clearly marking unsupported binary operations. In the control module, the native shim delegates sleep operations to the standard Java Thread.sleep, allowing existing control logic to function on the Native platform.

airframe-codec/.native, airframe-control/.native · high confidence

The airframe-di module now includes Scala Native-specific implementations for lifecycle management. New files in the .native source directory provide no-op handlers for shutdown hooks and JSR-250 lifecycle events, ensuring the library compiles and runs correctly on Scala Native targets where these platform-specific features are not supported.

airframe-di/.native · high confidence

This change introduces the \airframe-log\ library's compatibility with Scala Native by providing platform-specific implementations for core logging components. It includes a new \java.util.logging.Logger\ implementation to bridge the standard Java logging API, a \LogEnv\ object tailored for the Native environment (disabling JMX and file scanning features not available on Native), and a custom \LogTimestampFormatter\ that uses cross-platform time arithmetic to generate timestamps without relying on POSIX-specific functions like \localtime\_r\. This enables users to utilize airframe-log in Scala Native applications (specifically targeting Scala Native 0.5+).

airframe-log/.native, airframe-msgpack/.native, airframe-rx/.native · high confidence

The RPC examples now include a Scala.js-based user interface that demonstrates calling remote RPC services from the browser. The UI is built using Airframe's Rx and HTML rendering components, featuring a button that triggers an asynchronous RPC call and displays the response. The example uses Bootstrap 4.5.3 for styling and is served via a standard HTML entry point that loads the compiled Scala.js output.

examples/rpc-examples/rpc-scalajs/ui · high confidence

Introduces a new Scala.js-specific compatibility module (Compat.scala) that provides platform-specific implementations for the codec system. This includes a default message codec finder, an empty map for platform-specific codecs, and specific handling for parsing Instant timestamps. Notably, it explicitly disables binary UUID reading in the Scala.js environment by throwing an IllegalArgumentException, ensuring the library functions correctly on JavaScript targets while acknowledging platform limitations.

airframe-codec/.js · high confidence

A new compatibility layer (Compat.scala) has been added to the airframe-control module to support Scala.js builds. This shim provides a no-op implementation for the sleep utility, allowing the control library to compile on JavaScript targets where native sleep functionality is unavailable, thereby enabling airframe-control to be used in Scala.js environments.

airframe-control/.js · high confidence

Introduces a new \Compat.scala\ file for the Scala.js target that provides platform-specific implementations for the HTTP client infrastructure. This includes using the browser's \window.location\ to determine server addresses, configuring the default HTTP client backend to \JSHttpClientBackend\, setting up the MacrotaskExecutor for asynchronous execution, and defining exception classifiers that are compatible with the JavaScript environment (e.g., returning empty classifiers for SSL and connection exceptions where Java classes are unavailable).

airframe-http/.js/src/main/scala/wvlet/airframe/http · high confidence

The airframe-surface library now includes a dedicated implementation for Scala.js, providing macro-based surface reflection capabilities (SurfaceFactory) and a caching mechanism (package.scala) tailored to the JavaScript runtime. This change introduces Scala 3-specific inline definitions alongside the Scala 2 macro implementation, ensuring consistent surface discovery behavior across JVM and JS platforms while maintaining compatibility with the existing airspec testing infrastructure via a new bridge object.

airframe-surface/.js · high confidence

A new example file, Launcher\_01\_Simple.scala, has been added to the launcher examples directory. This example demonstrates how to define global options (such as environment and help flags) in the constructor arguments of a main application class, and how to define command-local options for subcommands (like 'monitor') using function arguments. It shows the basic usage of the Launcher API to execute commands with arguments and options.

examples/src/main/scala/wvlet/airframe/examples/launcher · high confidence

A new example file (JSON\_01\_Parse.scala) has been added to the examples directory, demonstrating how to parse a JSON string and extract specific fields using the airframe-json library.

examples/src/main/scala/wvlet/airframe/examples/json · high confidence

New Scala 2-specific source files have been added to the airframe-surface module to provide runtime reflection capabilities. This includes a package object with caching for surfaces and methods, a RuntimeSurface object for creating surface instances via WeakTypeTag, a SurfaceFactory for accessing local surfaces and method metadata, and a RuntimeGenericSurface class that handles object instantiation through Java reflection, including support for inner classes and primary constructor resolution.

airframe-surface/.jvm/src/main/scala-2 · high confidence

Users can now utilize the airframe-surface library on Scala Native platforms. This change introduces platform-specific implementations for surface creation and caching, including a new SurfaceFactory for Scala 3 and a cache management module using ConcurrentHashMap-backed maps, enabling surface reflection capabilities in Native environments.

airframe-surface/.native · high confidence

A new example file (Main.scala) was added to the sbt-airframe JS client test project, demonstrating how to instantiate an asynchronous RPC client for Scala.js using the new Rx-based HTTP client interface. The example shows calling a service method that returns an Rx type and handling the result via a run callback.

sbt-airframe/src/sbt-test/sbt-airframe/js-client/client · high confidence

A new GreeterApi trait has been introduced in the sbt-airframe gRPC test project, defining endpoints for standard, server, client, and bidirectional streaming using the Rx interface. This file serves as the API contract for the gRPC client generation feature, demonstrating how streaming methods are declared within the airframe-http RPC framework.

sbt-airframe/src/sbt-test/sbt-airframe/grpc/api · high confidence

A new Java gRPC stub implementation for the 'helloworld.Greeter' service has been added to the airframe-benchmark module. This file, generated by gRPC proto compiler version 1.30.2, provides the client-side infrastructure (async, blocking, and future stubs) and server-side binding definitions required to benchmark the grpc-java implementation against the standard 'SayHello' unary RPC method.

repository · high confidence

A new shell script, update-monaco-facade.sh, has been added to the airframe-rx-widget project to automate the generation of Scala.js bindings for the Monaco editor. This script fetches the TypeScript definitions from the bundled node modules, applies specific sed transformations to make them compatible with the scala-js-ts-importer tool, and then generates the corresponding Scala source files (Monaco.scala) in the wvlet.airframe.rx.html.widget.editor package.

airframe-rx-widget/scripts · high confidence

AirSpec now supports running tests on Scala Native 0.5 (Scala 3 only). This enables users to execute their AirSpec test suites against native binaries, expanding the platform coverage beyond the JVM and Scala.js.

airspec · high confidence

The airframe-launcher module now supports Scala 3 by introducing a dedicated LauncherCompat implementation for the Scala 3 compiler. This implementation replaces the Scala 2-specific reflection APIs (scala.reflect.runtime.universe) with Scala 3's inline methods and the Surface API, enabling users to run Airframe launchers in Scala 3 environments.

airframe-launcher/src/main/scala-3 · high confidence

This change introduces the core components for Java Management Extensions (JMX) integration within the airframe-jmx module. It adds a JMX annotation for exposing methods and fields, a registry for managing MBean registration and unregistration, and utility classes to handle reflection and JMX agent startup. The implementation includes specific logic to handle Scala-specific class naming conventions (such as removing trailing '$' for objects) to ensure compatibility with JMX naming requirements, and provides fallback mechanisms for Java 8 versus Java 9+ environments when starting the JMX agent.

airframe-jmx/src/main/scala · high confidence

This change introduces the core components for the airframe-json library, including the JSONScanner for tokenizing input, JSONSource for handling byte/string data, and JSONEventHandler/JSONContext traits that define how parsed tokens are assembled into an Abstract Syntax Tree (AST). It also provides the JSONValueBuilder to construct JSONValue objects (JSONObject, JSONArray, JSONString, etc.) from the stream, a NullJSONContext for validation-only scanning, and a JSONTraverser with a visitor pattern for iterating over parsed JSON structures. The package.scala file exposes convenience extension methods on JSONValue and JSONValueSeq for extracting typed values (e.g., getValue, toLongValue) and navigating nested structures (e.g., the / operator).

airframe-json/src/main · high confidence

This change introduces the core components for gRPC support within the airframe-http-grpc module. Users can now create and manage gRPC servers using the new GrpcServerFactory and the gRPC object entry point. The update also includes a GrpcClientInterceptor that automatically attaches client version headers and configures content types, as well as GrpcClientCalls to handle request/response encoding and streaming logic for generated gRPC clients.

airframe-http-grpc/src/main/scala/wvlet/airframe/http/grpc · high confidence

The Scala.js HTTP client now includes a new JSFetchChannel implementation that uses the browser's Fetch API, selectable via the useFetchAPI configuration option. This new channel adds support for reading Server-Sent Event (SSE) streams (text/event-stream), allowing asynchronous handling of real-time events through ServerSentEventHandler. The JSHttpClientBackend now routes requests to either the new Fetch-based channel or the existing XMLHttpRequest-based JSHttpClientChannel depending on availability and configuration, while maintaining the same Rx\[Response\] interface for async operations.

airframe-http/.js/src/main/scala/wvlet/airframe/http/client · high confidence

The airframe-http router module for the JVM platform has been populated with core routing components, including ControllerProvider for locating controller instances, HttpEndpointExecutionContext for handling request execution and response conversion, HttpRequestMapper for binding HTTP requests to method arguments, and ResponseHandler for formatting responses. This change establishes the foundational routing logic required for processing HTTP endpoints on the JVM.

airframe-http/.jvm/src/main/scala/wvlet/airframe/http/router · high confidence

The JVM module now includes a dedicated compatibility layer (Compat.scala) and platform trait (PlatformAirSpec.scala) to handle JVM-specific runtime requirements. This implementation provides a daemon thread pool for test execution, configures source-code-aware log formatting, and implements reflection-based logic to resolve test class fingerprints and instantiate test objects, ensuring the framework functions correctly on the JVM platform.

airspec/.jvm/src/main · high confidence

This change adds a new set of JVM-targeted utilities to the airframe-control module, including a command-line argument tokenizer, shell command execution helpers (with process management and remote launch capabilities), parallel execution runners, OS type detection, and thread factory utilities. These components provide low-level control and system interaction features specifically for the JVM platform.

airframe-control/.jvm/src/main · high confidence

This change adds a new set of JVM-specific core utilities to the airframe-core module, including a custom logging infrastructure (LogEnv, Logger, handlers, formatters, and JMX integration), an I/O utility for resource management and file operations, and a Timer/StopWatch for code performance measurement. These components are placed in the .jvm source directory, indicating they are intended for the JVM target platform only.

airframe-core, airframe-core/.jvm · high confidence

This change adds a new experimental HTTP server and client implementation backed by Netty within the airframe-http-netty module. It introduces core components including NettyBackend for request/response handling, NettyRequestHandler for managing HTTP and WebSocket connections, and NettyResponseHandler for encoding responses (including Server-Sent Events). The implementation supports Rx-based filters, WebSocket upgrades, and integrates with the existing RPC context and logging infrastructure, providing an alternative to the previous HTTP backend.

airframe-http-netty/src/main · high confidence

The airframe-http module now supports reactive (Rx) processing for HTTP requests and responses. This change introduces the \RxHttpFilter\ trait for defining reactive filters, the \RxHttpEndpoint\ trait for reactive endpoints, and the \RxRouterProvider\ interface to allow RPC clients to discover the default router. These components enable developers to build HTTP services that return \Rx\[Response\]\ streams, integrating with the existing filter and routing infrastructure.

airframe-http/src/main/scala/wvlet/airframe/http · high confidence

Added the airframe-canvas module, providing a \Canvas\ abstraction for high-performance reading and writing of primitive types (bytes, shorts, ints, longs, floats, doubles) to large memory buffers. The implementation uses \sun.misc.Unsafe\ to enable native C-code level access performance on both heap-backed arrays and off-heap memory, supporting operations like slicing, byte copying, and big-endian conversions while explicitly deprecating direct \ByteBuffer\ access to ensure compatibility with JDK 16+.

airframe-canvas/src/main · high confidence

The new airframe-control module provides core utilities for resource lifecycle management and service health monitoring. It introduces the Resource trait and Control object, enabling safe handling of AutoCloseable resources through loan patterns (withResource, withResources) that properly aggregate exceptions if closing fails, including support for asynchronous resources via withResourceAsync. The module also adds an IO object for convenient file and stream operations (readAsString, copy) and a HealthCheckPolicy system with strategies for marking services dead based on consecutive failures, recent failure rates, or failure thresholds, supported by an ExponentialMovingAverage utility and a Ticker for time measurement.

airframe-control/src/main · high confidence

This change introduces the airframe-jdbc module, providing a new JDBC connection pooling abstraction. It includes a ConnectionPoolFactory for managing pool lifecycle, a generic pool backed by HikariCP for standard databases (with specific SSL configuration support for PostgreSQL), and a lightweight embedded pool for SQLite and DuckDB. The library exposes a unified API for executing queries, updates, and transactions via the ConnectionPool trait.

airframe-jdbc/src/main · high confidence

This change introduces the \airframe-log\ module, providing a new logging implementation for users. It includes a \Color\ trait for ANSI color support, a \package.scala\ with \init\ and \initNoColor\ setup methods, and several handler classes (\ConsoleLogHandler\, \NullHandler\, \BufferedLogHandler\) for directing log output. The module also defines core formatting logic in \LogFormat.scala\ with multiple formatters (e.g., \SourceCodeLogFormatter\, \ThreadLogFormatter\), a \Logger\ class wrapping \java.util.logging\, and \LogSupport\ traits for easy integration into classes. Additionally, it adds a \Timer\ trait in \io/StopWatch.scala\ for measuring code block execution times.

airframe-log/src/main/scala · high confidence

The airframe-rx-html module has been relocated to the wvlet.airframe.rx.html package and now provides a comprehensive HTML and SVG tag DSL. Users can access standard HTML elements (via wvlet.airframe.rx.html.tags), SVG elements (via wvlet.airframe.rx.html.svgTags), and global attributes (via wvlet.airframe.rx.html.attrs). The library also supports implicit conversions, allowing users to import wvlet.airframe.rx.html.all.\* to seamlessly embed reactive values and standard types into RxElement nodes.

airframe-rx-html/src/main/scala · high confidence

This change introduces the new airframe-rx-html module (located at wvlet.airframe.rx.html), providing the core infrastructure for rendering reactive HTML elements to the DOM in Scala.js. It adds the DOMRenderer for converting HtmlNodes into DOM elements with proper resource cleanup, exposes RxElement lifecycle hooks (beforeRender, onMount, beforeUnmount) to allow user code to interact with the DOM node after mounting, and provides helper utilities such as RxDOM for DOM access and a type-safe events object for handling user interactions like onClick.

airframe-rx-html/.js/src/main · high confidence

Adds a new airframe-ulid module providing ULID (Universally Unique Lexicographically Sortable Identifier) support. This includes a Crockford Base32 encoding/decoding implementation, a ULID class with methods to extract timestamps, randomness, and convert to UUIDs or byte arrays, and a ULID generator object. The generator supports both secure (default) and non-secure random sources, allows setting a custom default generator, and includes validation for ULID strings and timestamps.

airframe-ulid/src/main · high confidence

The airframe-rx module now provides the foundational reactive types and runtime, including RxVar for stateful reactive variables, RxQueue for asynchronous event accumulation, and a dedicated RxRunner to execute operator chains with proper cancellation and error handling. This change introduces the Cancelable trait for managing subscriptions, RxSource for external data injection, and LazyF0 for safe serialization of call-by-name functions, establishing the core API surface for reactive programming in the library.

airframe-rx/src/main · high confidence

This change adds the foundational components for parsing and analyzing SQL queries within the airframe-sql module. It introduces an ANTLR grammar (SqlBase.g4) to tokenize and parse SQL text into a logical plan, along with a Scala-based interpreter (SQLInterpreter) to convert the parse tree into a structured LogicalPlan. The analyzer package includes a TypeResolver to resolve untyped expressions and relations, a CTEResolver to handle Common Table Expressions, and an Optimizer with column-pruning rules. Supporting utilities include an SQLGenerator to print logical plans back to SQL text, an SQLAnonymizer for obfuscating query details, and a DataTypeParser for handling complex type definitions.

airframe-sql/src/main · high confidence

This change adds new internal components to the airframe-http module to standardize HTTP request/response logging and RPC error handling. The new HttpLogs object provides structured logging for request details (method, path, headers), response status, duration, and RPC-specific context (method, arguments, interface). The RPCResponseFilter integrates this logging to automatically capture RPC status codes, handle exceptions by embedding error details in responses, and ensure consistent log output for both successful and failed RPC calls. Additionally, new codecs (HttpMultiMapCodec, HttpResponseBodyCodec) are introduced to support serialization of HTTP headers and response bodies, particularly for MsgPack and JSON content types.

airframe-http/src/main/scala/wvlet/airframe/http/internal · high confidence

The airframe-msgpack module now includes a pure-Scala implementation of the MessagePack codec SPI, adding new files such as BufferPacker, BufferUnpacker, OffsetPacker, and OffsetUnpacker alongside core SPI interfaces like Buffer, MessageSink, and MessageSource. This change provides a platform-independent, pure-Scala foundation for MessagePack serialization and deserialization, replacing or supplementing previous implementations that may have relied on external dependencies or non-pure Scala constructs. Users benefit from a consistent, pure-Scala API for packing and unpacking MessagePack data, including support for standard types, timestamps, and extension types, all within the wvlet.airframe.msgpack.spi package.

airframe-msgpack/src/main/scala/wvlet/airframe/msgpack/spi · high confidence

Added new classes and annotations to the airframe-surface module to support type inspection and parameter handling. This includes CName for normalizing and formatting variable names (e.g., camelCase to snake\_case), CanonicalNameFormatter for consistent string formatting, and TypeName for sanitizing class names. The update also introduces the @required and @secret Java annotations to mark parameters as mandatory or sensitive (with masking options), and adds the Zero object to generate default values for primitive, collection, and tuple types.

airframe-surface/src/main/scala · high confidence

This change adds the core JVM implementation for the airframe-log library, introducing a custom LogManager (AirframeLogManager) that prevents logger reset during shutdown hooks, an asynchronous logging handler (AsyncHandler) for non-blocking log output, and a file rotation handler (LogRotationHandler) backed by Logback for managing log file size and age. It also includes supporting components such as JMX integration for runtime log level management, timestamp formatting, and general IO utilities, establishing the foundational logging behavior for the JVM platform.

airframe-log/.jvm/src/main · high confidence

Adds HttpMacros.scala to the Scala 2 implementation package, providing macro-based methods for HTTP client requests. This file implements compile-time code generation for synchronous and asynchronous read and call operations, as well as content serialization (JSON and MsgPack) using codec factories, enabling type-safe HTTP interactions for Scala 2 users.

airframe-http/src/main/scala-2/wvlet/airframe/http/impl · high confidence

The HTTP client module now provides new standard interfaces, SyncClient and AsyncClient, which unify request handling across different backends. These clients feature a standardized pipeline that applies logging, client, request, and response filters, along with built-in circuit breaking and configurable retry policies. The change introduces a new HttpChannel abstraction to decouple the core client logic from specific transport implementations (such as JDK11, Netty, or OkHttp), allowing for a cleaner separation of concerns and consistent behavior for both synchronous and asynchronous HTTP requests.

airframe-http/src/main/scala/wvlet/airframe/http/client · high confidence

The airframe-di module for the JVM now includes lifecycle event handling and JSR-250 annotation support. The new AddShutdownHook component ensures that shutdown hooks are properly registered and unregistered for lifecycle managers, preventing issues during JVM shutdown. The JSR250LifeCycleExecutor enables the use of @PostConstruct and @PreDestroy annotations on injected objects, allowing automatic execution of initialization and cleanup methods. These changes are accompanied by comprehensive tests verifying lifecycle behavior, annotation handling, and serialization.

airframe-di/.jvm · high confidence

The JVM module now includes concrete implementations for the MsgPack serialization interface: \PackerImpl\ and \UnpackerImpl\. These classes act as adapters to the underlying \msgpack-core\ library, enabling the packing and unpacking of standard data types (integers, floats, strings, booleans, nil), binary data, arrays, maps, and timestamps. The implementation also handles conversion between Airframe's internal \Value\ representation and msgpack-core's V8 value types, ensuring that the JVM-specific serialization logic is properly bridged to the core library.

airframe-msgpack/.jvm/src/main/scala/wvlet/airframe/msgpack/impl · high confidence

The airframe-rx library now includes JVM-specific implementation details to support blocking operations and asynchronous scheduling. A new RxBlockingQueue class provides a LinkedBlockingQueue-based RxSource, enabling support for gRPC streaming scenarios where blocking consumption of events is required. Additionally, a compat.scala file introduces JVM-native utilities for timer scheduling, one-shot delayed execution, and synchronous blocking retrieval of Rx values (toSeq and await), allowing users to integrate reactive streams with blocking code or wait for single asynchronous results.

airframe-rx/.jvm · high confidence

This change introduces JVM-specific codec components for the airframe-codec library. It adds a new JDBCCodec that allows encoding JDBC ResultSets directly into MsgPack or JSON formats, handling various SQL types. Additionally, it provides platform-specific codecs for Java time types (ZonedDateTime, Date) and a StringUnapplyCodec for Enum-like case objects, wired together via a new Compat object and CompatBase trait to manage JVM-specific surface and codec resolution.

airframe-codec/.jvm/src/main/scala · high confidence

Added native-specific implementations for the logging subsystem, including LogEnv and LogTimestampFormatter. The new LogTimestampFormatter provides cross-platform timestamp generation using basic time arithmetic, avoiding platform-specific POSIX functions to ensure compatibility on Scala Native. LogEnv supplies the default logging configuration for the native target, establishing the baseline behavior for log levels, handlers, and output streams in this environment.

airframe-core/.native · high confidence

The codegen module now includes dedicated generators for four client types: RPC, gRPC, synchronous, and asynchronous HTTP clients. The RPC generator produces client stubs that support Rx\[A\] return types and use lazy initialization for internal method definitions to prevent large static initializer errors. The gRPC generator creates stubs with descriptor builders and model classes for MsgPack serialization. The synchronous and asynchronous generators produce typed client classes that wrap underlying HTTP clients, allowing users to generate strongly-typed client interfaces for their HTTP services directly from the codegen layer.

airframe-http-codegen/src/main/scala/wvlet/airframe/http/codegen/client · high confidence

A new RedirectToRxEndpoint class has been added to the HTTP router, allowing users to define endpoints that bypass and redirect incoming requests (GET, POST, PUT, etc.) to a specified target RxHttpEndpoint. This enables simpler routing configurations where requests can be forwarded to another handler without implementing custom logic for each HTTP method.

airframe-http/src/main/scala/wvlet/airframe/http/router · high confidence

Added a series of new example files in the DI examples directory to demonstrate advanced Airframe features. These include manual session management (DI\_04\_Session), explicit lifecycle hooks via API and JSR-250 annotations (DI\_05\_LifecycleHooks, DI\_07\_JSR250Annotation), binding overrides for testing (DI\_08\_OverrideBinding), design composition and binding precedence (DI\_09\_ComposingDesigns), production mode eager initialization (DI\_11\_ProductionMode), resource reuse and shutdown ordering (DI\_12\_ReusingService), explicit session binding for external shutdown control (DI\_20\_BindSession), and design coverage statistics via DIStats (DI\_91\_Stats).

examples/src/main/scala/wvlet/airframe/examples/di · high confidence

Added example code demonstrating the airframe control and logging capabilities. The new files illustrate how to configure retry strategies with exponential backoff, jitter, and custom wait times, as well as how to execute parallel tasks. Additionally, a new example shows how to use the LogSupport trait for structured logging.

examples/src/main/scala/wvlet/airframe/examples/control · high confidence

The JVM-specific reflection package in airframe-surface now includes new components to enhance runtime type handling. MethodCallBuilder enables the construction of method calls by automatically resolving and injecting default argument values. ReflectTypeUtil provides helper methods for inspecting class structures, including detection of companion objects, primitive types, collections, and string-based unapply constructors. TypeConverter adds logic to convert values between different types, supporting primitives, collections, and custom classes via string constructors or unapply methods. Additionally, the reflect package object introduces implicit extensions and utilities for discovering Java annotations on surfaces, parameters, and methods, traversing class hierarchies to find inherited annotations.

airframe-surface/.jvm/src/main/scala · high confidence

Added three new scripts to streamline the build and release process: \scripts/dynver.sh\ computes sbt-dynver-compatible version numbers by parsing git tags and dirty states; \scripts/release.rb\ automates the creation of annotated git tags and pushes on the main branch, using a YYYY.MM.patch format; and \scripts/setup-scalajs.sh\ ensures a clean pnpm environment by removing legacy npm node\_modules before installation.

scripts · high confidence

The repository is initialized with a comprehensive set of configuration files that standardize the development environment and CI pipeline. A new \.scalafmt.conf\ enforces Scala 3 formatting with a 120-column width and specific rewrite rules, while \.scalafix.conf\ enables syntax checks like \DisableSyntax\ and \LeakingImplicitClassVal\. CI automation is configured via \.mergify.yml\ for automatic merging of dependency updates and \.codecov.yml\ to enforce an 80% project coverage threshold. Additionally, \.scala-steward.conf\ manages dependency updates, pinning \logback-core\ to 1.3.x and Scala 3 to 3.3.x, and the \sbt\ launcher script is included to ensure consistent build execution.

(repo-wide) · high confidence

The airframe-surface module now includes a dedicated Scala 3 implementation of the Surface interface. This new file defines the core Surface trait and its companion object, enabling compile-time surface generation via Scala 3 macros (using scala.quoted). A key addition is the isEnum method, which allows the library to correctly identify and handle Scala 3 enum types, ensuring that enum-based surfaces are processed accurately alongside other type structures.

airframe-surface/src/main/scala-3 · high confidence

The Parquet module now supports Scala 3 by introducing a new \ParquetCompat\ trait in the \scala-3\ source directory. This trait provides inline methods for creating Parquet writers and readers (\newWriter\, \newReader\) and executing SQL queries against Parquet files (\query\), leveraging Scala 3's \inline\ capabilities and the \Surface\ abstraction to maintain type safety and performance.

airframe-parquet/src/main/scala-3 · high confidence

Added a new Scala 3-specific compatibility file (JMXCompat.scala) that provides inline helper methods for JMX MBean creation and registration. This enables users to leverage JMX features with Scala 3 syntax and inline optimizations, ensuring the airframe-jmx module functions correctly in Scala 3 environments.

airframe-jmx/src/main/scala-3 · high confidence

Added a new Scala 3-specific compatibility module (ConfigCompat.scala) that provides inline-wrapped versions of core configuration methods (such as bindConfig, of, getOrElse, and YamlReader load/bind) to ensure seamless usage of the configuration library in Scala 3 projects. This change introduces the necessary Scala 3 syntax and inline semantics without altering the underlying runtime behavior, enabling users to adopt the library in Scala 3 environments.

airframe-config/src/main/scala-3 · high confidence

The airframe-codec module now includes a Scala 3-specific compatibility implementation (CompatBase.scala) that provides the core codec resolution logic using Scala 3 syntax. This change introduces a \codecOf\ method that leverages inline methods to resolve message codecs and a \surfaceOfClass\ method for type surface retrieval, enabling the codec functionality to operate correctly on the Scala 3 platform.

airframe-codec/.jvm/src/main/scala-3 · high confidence

Added Scala 3-specific compatibility layers to enable the codec library to function correctly on Scala 3. This includes a new \AnyCodecCompat\ trait that detects Scala 3 \EnumValue\ instances to ensure RPC works with Scala 3 enums, and \ScalaCompat\ objects that replace macro-based implementations with \inline\ methods for \MessageCodec\ and \MessageCodecFactory\ operations.

airframe-codec/src/main/scala-3 · high confidence

Added Scala 3-specific base traits (HttpMessageBase, HttpServerExceptionBase, RxRouterBase) to the airframe-http module, enabling the use of Scala 3 syntax such as \inline\ methods and the new wildcard import \\*\ syntax. These changes provide the foundational structure for Scala 3 compatibility, including support for concrete filter instances in RxRouter.filter/andThen.

airframe-http/src/main/scala-3/wvlet/airframe/http · high confidence

The airframe-msgpack library now supports Scala.js by introducing a pure-Scala packer and unpacker implementation. This change adds a compatibility layer that handles platform-specific nuances, such as JavaScript's lack of NaN in float/double values, ensuring consistent serialization behavior across JVM and JavaScript environments.

airframe-msgpack/.js · high confidence

The airspec library now supports comparing Scala.js \js.Object\ instances using the \shouldBe\ assertion. A new \JsObjectMatcher\ component performs deep equality checks on JavaScript objects, allowing tests to verify that two JS objects have the same keys and values, including nested object structures.

airspec/.js/src/main/scala/wvlet/airspec/spi · high confidence

The sbt-airframe plugin is now available as a standalone sub-project, providing an sbt plugin for generating Airframe RPC HTTP clients (sync, async, Scala.js, and gRPC) and OpenAPI specifications. The directory includes the plugin source, configuration files (scalafmt, Steward), documentation, and a bundled sbt launcher script.

sbt-airframe · high confidence

The experimental Scala macro-based logging implementation in the wvlet-log module has been removed. The \LogMacros\ object, which provided compile-time macro methods for log levels, and the \Logger\ trait, which relied on these macros and \org.slf4j.LoggerFactory\, have been deleted from the source code. This change eliminates the dependency on \scala.language.experimental.macros\ for the core logging interface, simplifying the logging API and removing the associated macro expansion logic.

src/main · high confidence

This change introduces JVM-specific source files for the airframe-rx-html module to support cross-compilation. It adds a \compat\ object that defines platform-specific type aliases for DOM events (UIEvent, MouseEvent, WheelEvent) and a \PlatformEmbeddableNode\ trait. Additionally, it adds an \HtmlNodeBase\ trait containing a stub implementation of \renderTo(nodeId)\, which serves as a placeholder to ensure IntelliJ recognizes the method signature on the JVM side, while the actual DOM rendering logic remains specific to Scala.js.

airframe-rx-html/.jvm · high confidence

The airframe-config module now includes a Scala 2-specific compatibility layer (ConfigCompat.scala) that bridges type-tagged configuration methods to the underlying Surface-based implementation, ensuring API consistency across Scala versions. Additionally, a new YamlReader component has been introduced to handle YAML parsing via SnakeYaml and convert the resulting data structures into MessagePack format for efficient deserialization into typed configuration objects.

airframe-config/src/main/scala · high confidence

This change introduces a new compatibility package (\scala-2\) for the \airframe-rx-html\ module, providing macro-based source code extraction and type embedding support required for Scala 2.13. The new files (\HtmlCompat.scala\, \RxHtmlMacros.scala\, and \package.scala\) implement the \when\ conditional rendering helper, implicit conversions for embedding various types as \RxElement\ or \HtmlNode\, and a macro to extract the source code of \rxElement\ for debugging purposes, ensuring the library functions correctly on Scala 2 while the main implementation targets Scala 3.

airframe-rx-html/src/main/scala-2 · high confidence

The airframe-di module has been reorganized to support both Scala 2 and Scala 3, introducing separate implementation files for each version (e.g., \BinderImpl.scala\ in \scala-2\ vs \scala-3\ directories). The Scala 3 implementation uses inline methods and \Surface\ for type reflection, replacing the macro-based approach used in Scala 2. Several legacy binding methods (\toInstanceOf\, \toSingletonOf\, \toInstanceProvider\, \toSingletonProvider\) are now deprecated in favor of the unified \to\[X\]\ and \toProvider\[X\]\ syntaxes. Additionally, in-trait binding methods (\bind\, \bindLocal\, \bindFactory\) are deprecated, encouraging users to switch to constructor injection or \design.bind\[A\].toProvider(...)\. Scala.js-specific lifecycle handlers (\AddShutdownHook\, \JSR250LifeCycleExecutor\) are now no-ops, reflecting the lack of shutdown hooks in that environment.

airframe-di · high confidence

The Scala 2 HTTP client compatibility layer has been updated so that asynchronous request methods (readAs and call) return Rx\[Resp\] reactive streams instead of standard Scala Futures. This change allows users to handle HTTP responses as reactive data streams, enabling more flexible composition and handling of asynchronous data in the client.

airframe-http/src/main/scala-2/wvlet/airframe/http/client · high confidence

The \Finagle\ object in \airframe-http-finagle\ now marks its \client\, \server\, \newClient\, and \newSyncClient\ methods as deprecated. Users should migrate to the unified \Http.client\ API for client configuration and \Http.client.newAsyncClient\/\newSyncClient\ for creating clients, and use \Netty.server\ in the \airframe-http-netty\ module for server setup instead of the Finagle-specific server configuration.

airframe-http-finagle/src/main/scala/wvlet/airframe/http/finagle · high confidence

The HTTP recorder has been updated to store recorded requests and responses in a local SQLite database instead of in-memory storage, enabling persistent recording across sessions. This change introduces support for record expiration, allowing users to configure a time limit after which recorded entries are automatically deleted. Additionally, request matching is now case-insensitive and ignores unstable headers (such as date, cache-control, and pragma) to improve replay reliability. The recorder also provides new methods to dump recorded sessions as JSON or YAML for easier inspection and integration.

airframe-http-recorder/src/main · high confidence

The Scala.js implementation of ULID generation now attempts to use a cryptographically secure random number generator (SecureRandom) instead of the default pseudo-random generator. This change enhances the unpredictability of generated IDs in environments where the crypto module is available, falling back to the standard random generator if secure random is not supported.

airframe-ulid/.js · high confidence

The internal gRPC server implementation has been refactored to improve context propagation and error handling. A new GrpcContextTrackInterceptor ensures that the GrpcContext is correctly attached to thread-local storage for the duration of a request, while a dedicated GrpcException utility standardizes the conversion of application exceptions into appropriate gRPC StatusRuntimeExceptions with detailed metadata. The GrpcRequestHandler now explicitly supports JSON request parsing alongside the existing MessagePack format, and the GrpcServiceBuilder has been updated to wire these components together, including a new GrpcRequestLogger for enhanced access logging.

airframe-http-grpc/src/main/scala/wvlet/airframe/http/grpc/internal · high confidence

The Parquet integration in airframe-parquet now uses a custom NioInputFile implementation for reading and LocalOutputFile for writing, removing the dependency on Hadoop's LocalInputFile. This change enables Parquet operations to work with non-Hadoop file systems, such as remote S3 file systems accessed via java.nio, and ensures compatibility with modern JDK versions (including JDK 25) by avoiding legacy java.io file APIs.

airframe-parquet/src/main/scala · high confidence

The airframe-codec module now includes a Scala 2-specific compatibility layer (under scala-2) to support the new Scala 3 implementation. This layer provides \AnyCodecCompat\ with a stub for enum detection, \CodecMacros\ for macro-based codec generation, and \ScalaCompat\ traits that define the \MessageCodec\ and \MessageCodecFactory\ APIs using Scala 2 reflection (\TypeTag\) and macro syntax. This ensures the codec library functions correctly on Scala 2.13 while maintaining a separate codebase for Scala 3 features.

airframe-codec/src/main/scala · high confidence

The airframe-launcher now renders help messages with ANSI color coding (e.g., cyan for usage and option labels) to improve readability. Additionally, the command-line argument parser has been updated to support nested objects in command arguments, allowing complex configurations to be passed via the CLI. This change also introduces new internal components like HelpMessagePrinter, OptionSchema, and StringTreeCodec to handle these features.

airframe-launcher/src/main/scala · high confidence

A new Scala 2-specific implementation of the Surface trait and its companion object has been added to the airframe-surface module. This file defines the core reflection API (including methods for type arguments, parameters, and type checks like isOption or isMap) and sets the scalaMajorVersion to 2, ensuring that Scala 2 codebases use the correct macro-based surface resolution logic distinct from the Scala 3 implementation.

airframe-surface/src/main/scala-2 · high confidence

The MsgPack I/O layer now uses a new pure-Scala implementation for byte buffer management, replacing previous platform-specific or external dependencies. This change introduces \ByteArrayBuffer\ and \InfiniteByteArrayBuffer\ classes within the \wvlet.airframe.msgpack.io\ package, providing efficient, big-endian read/write operations for bytes, shorts, ints, and longs. Users benefit from a consistent, dependency-free buffering mechanism that supports dynamic capacity expansion and slice operations, ensuring reliable data handling for MsgPack serialization and deserialization without relying on Java-specific buffer classes.

airframe-msgpack/src/main/scala/wvlet/airframe/msgpack/io · high confidence

A new Scala 3-specific implementation of the router base (\RouterBase.scala\) has been added to the JVM source directory. This file defines the \RouterBase\ and \RouterObjectBase\ traits, along with a macro object \RouterObjectMacros\, which handle route registration and controller addition using Scala 3 syntax (e.g., \inline\ methods, \\*\ imports, and quoted macros). It also marks the legacy \RouterObject.of\ and \add\ methods as deprecated in favor of \RxRouter.of\, signaling a shift in how HTTP routing is constructed for Scala 3 users.

airframe-http/.jvm/src/main/scala-3 · high confidence

A new JVM-specific compatibility module (Compat.scala) has been introduced to standardize HTTP client behavior on the JVM platform. This change provides a default Java HTTP client backend, configures daemon thread factories to prevent JVM shutdown blocking, and implements robust exception classifiers. These classifiers automatically distinguish between retryable and non-retryable failures for SSL errors, connection issues (such as timeouts and socket exceptions), and HTTP/2 GOAWAY responses, ensuring consistent and resilient client behavior for users.

airframe-http/.jvm/src/main/scala/wvlet/airframe/http · high confidence

The JVM HTTP client backend has been updated to use the JDK 11 \java.net.http.HttpClient\ by default, replacing the previous \URLConnection\-based implementation. This change brings modern HTTP/2 support and improved async handling for JVM 11+ environments. For users running on Java 8, the client automatically falls back to the \URLConnectionChannel\ implementation to ensure compatibility. The new \JavaHttpClientChannel\ also introduces support for Server-Sent Events (SSE) when the response content type is \text/event-stream\, allowing asynchronous event handling directly from the HTTP client.

airframe-http/.jvm/src/main/scala/wvlet/airframe/http/client · high confidence

The airframe-rx library now includes a JavaScript-specific compatibility layer (compat.scala) that defines how reactive operations execute and schedule timers on the JVM/JS platform. This implementation uses MacrotaskExecutor for the default execution context and leverages JavaScript's setInterval and setTimeout for timer scheduling, while explicitly throwing UnsupportedOperationException for Rx.toSeq and Rx.await, indicating these features are not supported in the JavaScript environment.

airframe-rx/.js · high confidence

The command-line launcher annotations (@argument, @command, @option) have been relocated from their previous location to the main Java source folder (src/main/java). This structural change is intended to reduce compiler warnings during the build process, ensuring a cleaner compilation experience for users and developers working with the airframe-launcher module.

airframe-launcher/src/main/java · medium confidence

The documentation website has been rebuilt using Docusaurus, replacing the previous static site generator. This change introduces a new site structure with a React-based footer component, a JSON-driven sidebar configuration for organizing docs into categories like Framework and Core Modules, and a centralized site configuration file. Users will now benefit from Docusaurus features such as Algolia-powered search (DocSearch), a dedicated blog section, and improved navigation for release notes and community links.

website · high confidence

The JSON-to-MessagePack conversion logic in the airframe-msgpack module has been refactored to improve performance. A new streaming builder implementation (StreamMessagePackBuilder) replaces the previous nested approach, utilizing a context stack and pre-allocated placeholders to efficiently handle array and map headers during parsing. This change optimizes the internal stream conversion process without altering the external API.

airframe-msgpack/src/main/scala/wvlet/airframe/msgpack/json · high confidence

The Fluentd integration has been refactored to support Scala 3, introducing a new \ConsoleLogger\ for debugging metrics to the console and updating the \FluentdLogger\ to use Scala 3's wildcard import syntax. The \MetricLoggerFactory\ now caches \TypedMetricLogger\ instances and ensures events are serialized as MessagePack maps, while deprecated factory methods \withFluentdLogger\ and \withTDLogger\ remain available for backward compatibility.

airframe-fluentd/src/main/scala · high confidence

The HTTP codegen module has shifted from generating code at compile time to building the router at runtime. A new ClassScanner component now scans the classpath for classes implementing the RxRouterProvider interface, and RouteScanner uses this to construct the router dynamically. The previous buildRouter methods are deprecated and throw UnsupportedOperationExceptions, directing users to the new buildRxRouter approach which supports async HTTP clients via the Rx interface.

airframe-http-codegen/src/main/scala/wvlet/airframe/http/codegen · high confidence

The HTTP router's filter chaining methods (filter/andThen) now support passing concrete filter instances directly, in addition to the previous type-based registration. This allows users to inject specific filter implementations without relying solely on type inference or trait factories, providing more explicit control over request processing pipelines.

airframe-http/src/main/scala-2/wvlet/airframe/http · high confidence

The Scala 2 source files for airframe-log have been replaced with a new macro-based implementation. LogMacros.scala now generates code that checks log levels at compile time, ensuring that log message objects are only created when the corresponding level is enabled, thereby removing runtime overhead. LoggerBase.scala exposes these macros through the LoggerBase and LoggingMethods traits, allowing users to call standard logging methods (error, warn, info, debug, trace) with zero performance penalty when logging is disabled.

airframe-log/src/main/scala-2 · high confidence

The airframe-di-macros module now includes a dedicated source folder for Scala 2 (src/main/scala-2), containing the AirframeMacros implementation. This change separates the Scala 2 macro logic from the Scala 3 implementation, allowing the library to maintain distinct macro code paths for each Scala version while supporting dependency injection features such as trait instantiation and provider bindings in Scala 2 environments.

airframe-di-macros · high confidence

The Scala 2 build target now includes the \RouterBase\ and \RouterMacros\ classes within the \wvlet.airframe.http.router\ package. These files provide the macro-based implementation for registering HTTP controllers and filters, enabling the \add\, \andThen\, and \of\ methods to automatically register trait factories and route definitions at compile time for Scala 2 users.

airframe-http/.jvm/src/main/scala-2 · high confidence

The Fluentd module now supports Scala 3 by introducing a compatibility layer in MetricLoggerFactoryCompat. This change adds inline methods for retrieving typed metric loggers, ensuring that the MetricLoggerFactory functions correctly in Scala 3 environments without requiring syntax changes in user code.

airframe-fluentd/src/main/scala-3 · high confidence

The Scala 3 implementation of the logging API now uses inline methods for all log levels (error, warn, info, debug, trace), allowing the compiler to eliminate disabled log calls at compile time for better performance. Additionally, the source position tracking has been optimized to store only the file name rather than the full source path, which reduces the compiled binary size.

airframe-log/src/main/scala-3 · high confidence

The ULID library now uses cryptographically secure random bytes for generating ULIDs on Scala Native, replacing previous implementations that may have relied on less secure methods. This change introduces a native-specific secure random implementation that interfaces with OpenSSL's RAND\_bytes function, ensuring that generated ULIDs are unpredictable and suitable for security-sensitive contexts.

airframe-ulid/.native · high confidence

The Scala 3-specific HTTP client compatibility layer now allows users to pass an HttpClientContext to the readAs, call, and rpc methods on both synchronous and asynchronous clients. This enables contextual configuration (such as headers or metadata) to be propagated during HTTP requests without requiring separate setup steps.

airframe-http/src/main/scala-3/wvlet/airframe/http/client · high confidence

The JVM-specific MessagePack compatibility layer now defaults to the pure-Scala packer and unpacker implementations instead of the external MessagePack-Java library. This change removes the dependency on the native Java MessagePack classes for buffer packing and unpacking operations, aligning the JVM runtime with the pure-Scala approach used in other targets.

airframe-msgpack/.jvm/src/main/scala/wvlet/airframe/msgpack/spi · high confidence

The Scala 3 implementation of airframe-surface now uses compile-time surface generation instead of runtime reflection. The new package.scala defines caching structures for surfaces, while RuntimeSurface delegates to CompileTimeSurfaceFactory to resolve type information at compile time, resulting in faster startup and more reliable type introspection for Scala 3 users.

airframe-surface/.jvm/src/main/scala-3 · high confidence

The documentation site has been updated with a new visual style, including a custom CSS file that adjusts typography (importing Roboto fonts), layout widths, and color schemes for headers, links, and code blocks. Additionally, several new SVG illustrations have been added to the features section to visually represent concepts such as server architecture, online transactions, process flows, and code review.

website/static · high confidence

Added AirSpec test suite for service lifecycle and dependency injection; Added AirSpec-based test suite for Airframe examples; Added AirSpec-based test suite for airframe-config; Added AirSpec-based test suite for msgpack SPI components; Added AirframeSpec base trait for test suites; Added JVM HTTP client integration tests; Added JVM router tests for HTTP routing, RPC, and path matching; Added JVM tests for HTTP client retry logic, message building, and server exceptions; Added JVM-specific codec tests for JDBC, Java Time, and MessageCodec; Added JVM-specific surface tests for abstract types, inner classes, and Java types; Added JVM-specific test coverage for airframe-control components; Added JVM-specific tests for surface reflection capabilities; Added SQL benchmarking infrastructure; Added Scala 3 (Dotty) compatibility tests; Added Scala 3 surface tests for generic methods, intersection/union types, and opaque types; Added Scala 3 test compatibility bridge; Added Scala.js-specific test coverage for AirSpec; Added TPC-DS benchmark SQL test resources; Added comprehensive test coverage for airframe-http components; Added comprehensive test coverage for airframe-rx core operations; Added comprehensive test suite for airframe-codec; Added comprehensive test suite for gRPC client, server, and logging; Added gRPC example API definitions and client stubs for testing; Added integration test for OpenAPI schema generation; Added integration test for RPC server with Netty and RxRouter; Added integration test for Scala.js client generation; Added integration tests for RPC, HTTP clients, and protocol enforcement; Added integration tests for gRPC server streaming and client types; Added integration tests for the JS HTTP client; Added local mock server and RPC API for integration testing; Added parser and generator tests for airframe-sql; Added server-side test demonstrating RPC client integration with REST endpoints; Added test coverage for ByteArrayBuffer ReadBuffer API; Added test coverage for SQL analyzer components; Added test coverage for airframe-control utilities; Added test coverage for airframe-json parser, scanner, and formatters; Added test coverage for airframe-launcher command processing; Added test coverage for airframe-log initialization and log formatters; Added test coverage for airframe-rx-html core components; Added test coverage for airframe-rx-html rendering and lifecycle features; Added test coverage for airframe-surface type resolution and metadata; Added test examples for sbt-airframe HTTP API definitions; Added test for Scala 3 + Netty + RxRouter integration; Added test for Twitter JSON parsing; Added test for custom HTTP endpoints; Added test for sbt-airframe client generation; Added tests for CORS filter behavior; Added tests for Count, DataSize, and ElapsedTime parsing and formatting; Added tests for HTTP client filters and retry behavior; Added tests for HTTP recorder features; Added tests for JDBC connection pooling, configuration, and DuckDB support; Added tests for JMX agent and registry functionality; Added tests for JS HTTP async client and RPC client; Added tests for JSON to MessagePack conversion; Added tests for Parquet read/write, schema mapping, and query planning; Added tests for RxWidget rendering and reactive updates; Added tests for SQL catalog and data type parsing; Added tests for Scala 3 Enum codec support; Added tests for ULID module components; Added tests for airframe-fluentd using AirSpec and MockFluentd; Added tests for benchmark execution; Added tests for literal type interference in Surface caching; Added tests for log level patterns, timestamp formatting, and logger behavior; Added tests for the new OkHttp client integration; Added unit tests for SQL expression and logical plan traversal; Expanded test coverage for HTTP code generation; Expanded test coverage for Netty HTTP server capabilities; Initial test coverage for airframe-canvas; JVM-specific ULID compatibility and calendar validation tests; Migrate airframe-http-finagle tests to AirSpec.

A dependency / build maintenance change in (dependencies) — 1771 commits (60 fixs), 14 files.

(dependencies) · high confidence · unverified

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

• CAI 63 → 68 (+4.5)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 84 → 84 (+0.0)
• Architecture 98 → 81 (-17.1)
• Maturity 64 → 64 (+0.0)
• Readiness 68 → 66 (-1.8)
• Security 55 → 71 (+16.4)

• Documentation: no licence statement (README.md)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• Medium CVE: [CVE redacted] (pnpm-lock.yaml)
• Off-boarding risk: anonymized user #1

• Documentation: no project overview (website/README.md)
• Off-boarding risk: anonymized user #1
• Outdated: ch.qos.logback:logback-core
• Outdated: com.fasterxml.woodstox:woodstox-core
• Outdated: com.google.protobuf:protobuf-java
• Outdated: com.squareup.okhttp3:okhttp-jvm
• Outdated: com.zaxxer:HikariCP
• Outdated: commons-collections:commons-collections
• Outdated: io.netty:netty-all
• Outdated: org.apache.commons:commons-collections4
• Outdated: org.apache.hadoop:hadoop-common
• Outdated: org.apache.hadoop:hadoop-mapreduce-client-core
• Outdated: org.codehaus.woodstox:stax2-api
• Outdated: org.duckdb:duckdb_jdbc
• Outdated: org.postgresql:postgresql
• Projects may be oversized for their cohesion

• Containers 0 added · 0 removed · contexts 4 added · 0 removed · edges 5 added · 0 removed

• gallery
• generate-client
• rpc-scalajs
• sbt-airframe

• airspec → repository (coupling)
• gallery → repository (coupling)
• generate-client → repository
• rpc-scalajs → repository
• sbt-airframe → repository

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

wvlet/airframe 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.