Skip to content
CAI
Software that uses CAICheck a score

getkyo/kyo

41.5

Weak · 14 November 2026

373.3k

lines of production code

Scala

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Amazon Ion serialization support

Introduces a new Amazon Ion codec for the schema-based serialization API, enabling users to encode and decode Scala values to and from Ion text and Ion Binary formats. The \Ion\ companion object provides default helpers for Ion text (strings and UTF-8 bytes), while \IonBinary\ handles compact binary serialization. Configuration options allow switching between text and binary wire formats, setting decoding limits for nesting depth and collection size, and controlling whether schema annotations are emitted as Ion type annotations.

kyo-schema-ion/shared · high confidence

Add DoltLite embedded SQL backend

Introduces a new DoltLite backend for the kyo-sql module, enabling version-controlled SQL operations on embedded DoltLite databases via the \doltlite://\ URL scheme. This change adds the backend factory, FFI bindings to the native DoltLite library, and a client implementation that supports standard version-control operations such as branching, merging, committing, and diffing, while handling platform-specific native library availability with typed exceptions. Also in this area: 1 commit (0 fixes) modifying kyo-sql-doltlite/shared.

kyo-sql-doltlite/shared · medium confidence · unverified

Add JS/WASM platform-specific system and process support

Introduces platform-specific implementations for the \kyo-system\ module on JavaScript and WebAssembly targets. This includes \SystemPlatformSpecific\ to correctly detect OS name, architecture, and available processor counts by falling back to Node.js globals (\process.platform\, \process.arch\, \os.availableParallelism\) or browser APIs (\navigator.hardwareConcurrency\) when standard Java properties are unavailable. It also adds \ProcessPlatformSpecific\, which provides Node.js child process facades and stream wrappers (\NodeInputStream\, \NodeOutputStream\) to handle process lifecycle, stdin/stdout/stderr piping, and broken pipe errors gracefully in the async JS environment. Tests verify correct behavior in both Node and browser-like environments.

kyo-system/js-wasm · high confidence

Add JS/Wasm platform-specific implementations for core data structures

This change introduces a new \kyo-data/js-wasm\ module that provides platform-specific implementations of Kyo's internal data structures for JavaScript and WebAssembly targets. It includes a \JsUnsafeBuffer\ backed by \Uint8Array\ and \DataView\ (with \Long\ emulation for 64-bit values), simplified single-threaded queue implementations (\MpmcUnsafeQueue\, \MpscUnsafeQueue\, etc.) that avoid atomic operations, and optimized \Tag\ hashing and equality logic that leverages JS string identity for fast comparisons. These additions enable Kyo's data layer to function correctly and efficiently on JS/Wasm by replacing JVM/Native-specific concurrency and memory primitives with their JavaScript equivalents.

kyo-data/js-wasm · high confidence

Add JVM CompletionStage interoperability bindings for Kyo and ZIO

New compatibility bindings have been added for the JVM platform in both the Kyo and ZIO stacks, enabling seamless conversion of Java's \java.util.concurrent.CompletionStage\ into the respective stack's \CIO\ effect. This allows users to lift existing asynchronous Java futures into Kyo's or ZIO's effect systems, with failures surfacing as aborts or typed errors respectively, while noting that cancellation does not propagate back to the original stage.

kyo-compat/bindings/kyo/jvm, kyo-compat/bindings/zio/jvm · high confidence

Add JVM and Scala Native platform support for internationalization

The kyo-i18n module now supports JVM and Scala Native targets. On these platforms, the default locale detection relies on the \user.language\ system property and environment variables via \kyo.System\, rather than browser APIs. Additionally, tests confirm that \I18n.init\ can load translation files from a directory on these platforms.

kyo-i18n/jvm-native · high confidence

Add JVM ledger example with HTTP API and in-memory transaction processing

A new JVM-based ledger example has been added to demonstrate processing financial transactions with relaxed durability. The example includes an HTTP server that exposes endpoints for posting transactions, retrieving account statements, and checking health status. It utilizes shared mapped files for in-memory data handling between API instances and writes the transaction log asynchronously, providing a concrete implementation of the ledger logic via a Handler trait and DB abstraction.

kyo-examples/jvm/src/main/scala/examples/ledger · high confidence

Add JVM logging backend via Java Platform Logger

Users can now route Kyo's \Log\ effect to the Java Platform Logger (JPL) on the JVM. This new \JavaLog\ integration wraps \java.lang.System.Logger\, allowing log levels to be reconfigured at runtime via standard JUL settings without restarting the application, and includes source call-site position information in log output.

kyo-logging-jpl/jvm · high confidence

Add JVM/Native platform support for dynamic flags and environment resolution

This change introduces platform-specific implementations for the JVM and Native targets, enabling the kyo-config library to resolve system properties and environment variables on these platforms. It adds \FlagPlatform.scala\ to handle low-level access to \java.lang.System\ and includes concurrency tests (\DynamicFlagConcurrencyPlatformTest\) to verify that dynamic flags remain thread-safe during concurrent updates, ensuring consistent reads without blocking.

kyo-config/jvm-native · high confidence

Add Kyo scheduler integration for ZIO applications

New \KyoSchedulerZIORuntime\ and \KyoSchedulerZIOAppDefault\ components are introduced in the \kyo-scheduler-zio\ module, enabling ZIO applications to utilize the Kyo scheduler for task execution. This integration ensures that ZIO effects run on threads managed by the Kyo scheduler, as verified by tests confirming the presence of 'kyo' in thread names.

kyo-scheduler-zio/shared · high confidence

Add MessagePack serialization support

Introduces a new MessagePack codec implementation for the Kyo schema system, enabling users to serialize and deserialize data to and from the MessagePack wire format. This addition includes a dedicated writer and reader that handle MessagePack-specific types (such as fixint, fixstr, and extension types) and supports round-trip encoding for primitives, collections, options, maps, and complex structures like UUIDs and recursive trees.

kyo-schema-msgpack/shared · high confidence

Add N-Queens solver example using Choice effects

A new example file (NQueens.scala) has been added to the JVM examples directory, demonstrating how to solve the N-Queens problem using Kyo's Choice effect for backtracking. The implementation defines a Board type with safety checks and a recursive solver that explores valid column placements, printing each solution and the total count for an 8x8 board.

kyo-examples/jvm/src/main/scala/examples/leetcode · high confidence

Add OTLP telemetry export for traces and metrics

Introduces a new OpenTelemetry Protocol (OTLP) exporter module that automatically discovers and exports telemetry data when the \OTEL\_EXPORTER\_OTLP\_ENDPOINT\ environment variable is set. The module registers service-loader factories to provide W3C Trace Context HTTP filters for automatic trace propagation on client and server requests, and an exporter factory to initialize background fibers that periodically flush trace spans and metrics to an OTLP-compatible collector. Configuration is driven by standard OpenTelemetry environment variables, supporting custom endpoints, headers, timeouts, and resource attributes.

kyo-stats-otlp/shared · high confidence

Add Reactive Streams interop and compliance tests for JVM

This change introduces the \kyo-reactive-streams\ interop layer for the JVM platform, providing functions to convert between Kyo Streams and the standard Reactive Streams \Publisher\/\Subscriber\ interfaces (via \FlowAdapters\). It includes \fromPublisher\, \subscribeToStream\, and \streamToPublisher\ utilities. Additionally, it adds comprehensive TCK compliance tests (\StreamPublisherTest\, \StreamSubscriberTest\) to verify that the Kyo-based publishers and subscribers correctly implement the Reactive Streams specification.

kyo-reactive-streams/jvm · high confidence

Add Reactive Streams interop for converting between Kyo Streams and Java Publisher/Subscriber APIs

New files in the \kyo.interop.flow\ package provide bidirectional conversion between Kyo \Stream\ types and the Java \java.util.concurrent.Flow\ APIs. Users can now create a \Publisher\ from a Kyo \Stream\ using \streamToPublisher\, or consume an existing \Publisher\ as a Kyo \Stream\ via \fromPublisher\. The implementation includes \StreamPublisher\ and \StreamSubscriber\ components that manage subscription lifecycles, backpressure, and resource cleanup within Kyo's \Scope\ and \Sync\ effects.

kyo-reactive-streams/shared/src/main/scala/kyo/interop · high confidence

Add Scala Native platform support for kyo-data

This change introduces the first-class Scala Native backend for the kyo-data library. It adds platform-specific implementations for core internal components, including a Native-specific \Platform\ object that resolves OS detection (Windows, macOS, Linux, BSD) and stack depth limits at link time, and a \NativeUnsafeBuffer\ backed by direct pointer arithmetic and \libc.memcpy\ for high-performance memory operations. The \UnsafeBufferPlatform\ implementation enables memory allocation via \stdlib.malloc\ and memory-mapped file I/O using POSIX \mmap\/\munmap\ bindings. These additions are accompanied by corresponding test suites for the JS and Native targets to verify OS family resolution and platform abstraction correctness.

kyo-core/native/src/main · high confidence

Add Scala Native platform support for kyo-data

This change introduces the first-class Scala Native backend for the kyo-data library. It adds platform-specific implementations for core internal components, including a Native-specific \Platform\ object that resolves OS detection (Windows, macOS, Linux, BSD) and stack depth limits at link time, and a \NativeUnsafeBuffer\ backed by direct pointer arithmetic and \libc.memcpy\ for high-performance memory operations. The \UnsafeBufferPlatform\ implementation enables memory allocation via \stdlib.malloc\ and memory-mapped file I/O using POSIX \mmap\/\munmap\ bindings. These additions are accompanied by corresponding test suites for the JS and Native targets to verify OS family resolution and platform abstraction correctness.

kyo-data/native · high confidence

Add Scala Native scheduling backend for CIO timing operations

Introduces a new \CompatScheduler\ implementation for Scala Native that enables \CIO.sleep\, \CIO.timeout\, and \CIO.cede\ by leveraging \java.util.concurrent.ScheduledExecutorService\. This binding uses a two-thread daemon thread pool to handle scheduled tasks, ensuring these timing operations function correctly on the Native platform where they were previously unsupported or broken.

kyo-compat/bindings/future/native · high confidence

Add Scala Native support to kyo-tasty

This change introduces a new Scala Native platform implementation for the kyo-tasty reflection library, enabling type introspection on Native targets. It provides platform-specific modules for file I/O (using POSIX mmap and libc bindings), snapshot reading, and hashing, while gracefully degrading JVM-only features like JPMS module resolution and JAR reading. The update also includes the necessary test infrastructure, such as embedded fixture loaders and cross-platform test helpers, to ensure the library functions correctly in the Native runtime.

kyo-tasty/native, kyo-test/runner/js-wasm · high confidence

Add Twitter Future compatibility bindings for JVM

This change introduces a new compatibility layer in the \kyo-compat/bindings/twitter-future/jvm\ module that allows Kyo effects to run on top of the Twitter Future runtime. It provides a full set of carrier bindings including \CIO\ (the core effect type), \CFiber\ for asynchronous execution, and primitives for concurrency and state management such as \CAtomicBoolean\, \CAtomicInt\, \CAtomicLong\, \CAtomicRef\, \CChannel\, \CLatch\, \CLocal\, \CMeter\, \CPromise\, and \CStream\. These bindings enable users to integrate Twitter Future-based libraries and infrastructure directly into Kyo applications while maintaining the effect system's semantics.

kyo-compat/bindings/twitter-future/jvm · high confidence

Add WebAssembly (WASM) support for browser launching

This change introduces platform-specific implementations for the JS/WASM target, enabling the browser launcher to function in WebAssembly environments. It adds a no-op shutdown hook registration (since JS runtimes manage process lifecycle differently than JVMs) and a process ID resolver that reads the \process.pid\ global, panicking if the Node-like environment is missing. A corresponding test ensures the no-op hook executes without error.

kyo-browser/js-wasm · high confidence

Add WebAssembly support for kyo-http

This change introduces WebAssembly (WASM) support for the kyo-http module, enabling it to run in WASM environments. The implementation includes Node.js built-in module facades (net, tls, fs, os, path, child\_process) using the \node:\ scheme to ensure compatibility with ES modules, and adds test infrastructure for platform-specific features like TLS and Unix sockets within the WASM context.

kyo-http/js-wasm · high confidence

Add cross-platform internationalization module

Introduces a new \kyo-i18n\ module providing reactive, cross-platform internationalization. The module parses Fluent-style \.ftl\ bundles into per-locale translation handles, supporting reactive translation leaves via \I18n.t\ that automatically re-render when the active locale changes. It includes an \i18n"..."\ string interpolator for composing literal text with reactive arguments, point-in-time lookups via \I18n.now\, and locale switching via \I18n.setLocale\. Missing or empty keys render as visible markers (e.g., \‹key›\) rather than falling back silently. The \Locale\ type normalizes language tags to primary subtags, and the module supports loading bundles from memory, custom loaders, or the filesystem.

kyo-i18n/shared · high confidence

Add stream compression and platform-specific secure random

Users can now compress and decompress data streams directly using new \deflate\, \inflate\, \gzip\, and \gunzip\ extension methods on \Stream\, supporting configurable compression levels, strategies, and flush modes. Additionally, a new \SecureRandomPlatformSpecific\ implementation provides a lazy-initialized JVM secure random source for cryptographic operations.

kyo-core/jvm/src/main/scala/kyo · high confidence

Added JavaScript/WASM-specific scheduling and OTLP registration components

This change introduces platform-specific support for JavaScript and WebAssembly targets. It adds a \CompatScheduler\ implementation that enables \CIO.sleep\, \CIO.timeout\, and \CIO.cede\ operations by mapping them to \setTimeout\, addressing runtime class-loading issues in Scala.js. Additionally, it provides an \OTLPRegistration\ object that explicitly registers OpenTelemetry exporters and HTTP filters for the JS environment, bypassing the lack of \META-INF/services\ support by using a top-level JavaScript export for initialization.

kyo-compat/bindings/future/js-wasm, kyo-stats-otlp/js-wasm · high confidence

Added build-time generator for fast float parsing table

A new Scala tool, FastFloatPow10Gen, has been added to the kyo-schema JVM module to generate the FastFloatPow10Table used by the Eisel-Lemire algorithm for high-performance float parsing. This generator computes 128-bit powers of ten (from 10^-348 to 10^347) and writes the resulting arrays to the shared source directory, ensuring build reproducibility by checking in the generated output.

kyo-schema/jvm · high confidence

Added property-based testing framework with shrinking and deterministic replay

The \kyo-test/prop\ module introduces a new property-based testing capability, providing \Gen\ for generating test data, \Shrink\ for minimizing failing counterexamples, and a \forAll\ DSL in \PropertyTest\ for running property checks. The implementation uses a pure, splittable \Seed\ (SplitMix64) and lazy rose trees to ensure deterministic, reproducible shrinking across \map\, \flatMap\, and \filter\ operations. It also includes macro-based derivation (\Gen.derive\) for case classes and sealed traits, allowing automatic generation for complex types. Tests verify that \forAllSeeded\ allows deterministic replay of failures by recording the seed in \PropertyFailedException\.

kyo-test/prop/shared · high confidence

Automated build script for static Aeron C library

Added a new build script (build-aeron.sh) that automates the compilation of the Aeron C library (version 1.51.1) into a static archive. The script supports cross-platform builds for Linux (x86\_64, aarch64, musl), macOS (x86\_64, aarch64), and Windows (x86\_64, aarch64), handling specific toolchain requirements such as MSVC for Windows and position-independent code for Linux ARM. It stages the resulting libraries and headers into a structured directory, ensuring the built artifacts match the target architecture.

kyo-aeron/scripts · high confidence

Browser testing gains stability, readability, and network tracking

The browser module now includes built-in support for readable content extraction via Readability.js and Markdown conversion via Turndown.js. Assertion logic has been hardened with a stability sampling mechanism that waits for DOM values to settle before passing, and network interactions can be monitored using new fetch/XHR trackers that enable waiting for network idle states. Additionally, screenshot captures now use a 'hold-still' protocol that freezes animations and waits for fonts to ensure consistent visual results.

kyo-browser/shared/src/main · high confidence

Client-side SPA routing and drag-and-drop support

The kyo-ui/js-wasm module now includes a client-side router via \UILocation\, which exposes a reactive \Signal\ of the current URL path and intercepts same-origin anchor clicks to perform \pushState\ navigations without full page reloads. Additionally, the framework adds native drag-and-drop support, allowing elements to be declared as drag sources or drop targets with typed event handling, and introduces \UIMount\ to manage mounting UI trees into the DOM along with stylesheet injection.

kyo-ui/js-wasm · high confidence

Configurable default HTTP client connection limits

Users can now tune the default HTTP client's connection pool behavior via system properties. A new 60-second idle timeout for keep-alive connections is configurable via \-Dkyo.http.client.defaultIdleTimeout\, and the maximum number of idle keep-alive connections per host is configurable via \-Dkyo.http.client.defaultMaxConnectionsPerHost\ (defaulting to 100). These settings apply exclusively to the process-lifetime default client used by ambient helper methods, as this client cannot be configured through standard initialization.

kyo-http/shared/src/main/scala/kyo/http · high confidence

Cross-platform WHATWG charset decoding in kyo-charset

The kyo-charset module now provides character-set decoding that behaves identically on the JVM, Scala.js, Scala Native, and Wasm by implementing the WHATWG Encoding Standard. It replaces the inconsistent JDK java.nio.charset support with a portable implementation that includes the full WHATWG index tables (excluding replacement and x-user-defined) plus UTF-7, UTF-32, ISO-2022-KR, and HZ-GB-2312. Users can resolve labels via Charset.resolve (which maps aliases like latin1 to Windows-1252 per the standard) and decode byte sequences using decode (which replaces ill-formed sequences with U+FFFD) or decodeStrict (which fails on the first error). The module also supports byte-order mark sniffing and handles stateful encodings like ISO-2022-JP without requiring caller-side state management.

kyo-charset · high confidence

Direct block now supports async operations on Result, Maybe, List, and Chunk

The \kyo-direct\ library now allows asynchronous operations (such as \map\, \flatMap\, \foreach\, and \filter\) to be performed directly on \Result\, \Maybe\, \List\, and \Chunk\ types within \direct\ blocks. This is achieved by introducing specialized \AsyncShift\ implementations (\ResultAsyncShift\, \MaybeAsyncShift\, \ListAsyncShift\, and \ChunkAsyncShift\) that integrate with the CPS monad, enabling users to write cleaner, sequential-style code for collections and effectful optional/result types without manual unwrapping.

kyo-direct/shared/src/main/scala/kyo/internal · high confidence

DoltLite database engine support for JavaScript/WebAssembly environments

Users can now run DoltLite databases in JavaScript and WebAssembly runtimes (such as browsers and Node.js) via the new \DoltLiteWasm\ module. This adds a WebAssembly-backed backend that automatically loads the \@dolthub/doltlite-wasm\ library, enabling \doltlite://\ URLs without native dependencies. The implementation handles asynchronous module initialization, registers the backend for service discovery, and includes tests verifying data integrity for edge cases like embedded NUL characters, large integers, and blob storage within the WASM environment.

kyo-sql-doltlite/js-wasm · high confidence

Enables runtime backend discovery on JS and Wasm platforms

Adds a platform-specific registration mechanism for the SQL backend on JavaScript and WebAssembly targets. Since these platforms do not read standard Java service files at runtime, this change introduces a \BackendPlatformSpecific\ trait and a corresponding \register\ method that allows backends to explicitly register themselves with an in-memory service registry. This ensures that SQL backends can be discovered dynamically via computed URLs, rather than only being accessible via literal URLs resolved against the compile classpath. Tests verify that registered backends are correctly discoverable by the runtime discovery system.

kyo-sql/js-wasm · high confidence

Finagle scheduler integration via KyoFinagleSchedulerService

Adds a new Finagle scheduler service that integrates Kyo's adaptive scheduling system with Finagle's execution model. When enabled via the system property \-Dcom.twitter.finagle.exp.scheduler=kyo\, Finagle applications can benefit from Kyo's load management and thread optimization. The integration maintains Finagle's default LocalScheduler for lightweight Future compositions while redirecting FuturePools and compute-intensive tasks to Kyo's adaptive thread management. Backpressure is managed through Finagle's ForkingSchedulerFilter, allowing Kyo's scheduler to monitor system load and engage backpressure when needed. The service is automatically discovered through Finagle's service loading mechanism.

kyo-scheduler-finagle/jvm · high confidence

Initial support for Scala.js and WebAssembly platforms

This change introduces the \kyo-core/js-wasm\ module, enabling Kyo applications to run on JavaScript and WebAssembly runtimes. It provides platform-specific implementations for core capabilities previously unavailable on these targets: a cryptographically secure random number generator that probes for \crypto.getRandomValues\ or the Node \crypto\ module, synchronous standard input reading via Node's \fs\ module, and stubs for JDK concurrency utilities like \ScheduledExecutorService\, \SecureRandom\, and \VarHandle\. The entry also includes a service loader registry to replace JVM-based \META-INF/services\ discovery and adapts the \KyoApp\ runner for single-threaded execution.

kyo-core/js-wasm · high confidence

Integrate Kyo scheduler with Pekko actors

Users can now configure Pekko actors to execute on Kyo's adaptive scheduler by setting the default dispatcher executor to kyo.scheduler.KyoExecutorServiceConfigurator. This allows Pekko actors to benefit from Kyo's thread utilization optimizations and admission control, ensuring that actor messages are processed on Kyo-managed threads rather than standard Java threads.

kyo-scheduler-pekko/jvm · high confidence

Introduce Actor and PubSub concurrency primitives

Adds the \Actor\ and \PubSub\ modules to the \kyo-actor\ library. The \Actor\ primitive provides a message-based concurrency model with a private mailbox, sequential FIFO message processing, parent-child hierarchy support, and strand-safe request-response communication via \ask\. The \PubSub\ module offers a push-based publish/subscribe mechanism, available in two modes: a high-performance direct fan-out version and a linearized version backed by an actor to guarantee total ordering of events across all subscribers.

kyo-actor/shared/src/main · high confidence

Introduce Dolt SQL backend with version-control operations

Users can now connect to Dolt databases using the \dolt://\ scheme. This backend leverages the MySQL wire protocol but implements Dolt-specific version control features, including branching, merging, committing, and remote synchronization (push/fetch/pull). It handles Dolt's unique revision scoping via database names (e.g., \app/feature\) and enforces specific isolation levels (Repeatable Read) while rejecting unsupported ones. The driver also includes workarounds for Dolt's specific SQL dialect quirks, such as temporal bind corruption and window function frame calculation errors.

kyo-sql-dolt/shared · high confidence

Introduce Dolt and DoltLite SQL backends with version-controlled filesystem support

Users can now persist data using Dolt or DoltLite as SQL backends, enabling version-control features such as branching, committing, diffing, and merging directly on database state. The \DoltBranchScope\ manages per-fiber revision context to prevent race conditions when multiple fibers operate on different branches. A new \DoltFileSystem\ allows treating the database as a file system, storing file trees in a \vfs\_node\ table and supporting operations like writing, reading, and merging file contents across branches. Conformance tests verify that both backends behave consistently across these version-control and filesystem capabilities.

kyo-sql-dolt-api/shared, kyo-system-doltfs/shared · high confidence

Introduce DoltLite embedded SQL backend with version-control capabilities

Adds the \kyo-sql-doltlite\ module, providing an embedded SQL driver that uses the DoltLite engine (a SQLite fork with content-addressed storage) to support branches, commits, merges, and diffs within a single file. Users can open databases via \doltlite://\ URLs, which are handled by a new \DoltLiteBackendFactory\ registered via \META-INF/services\. The backend supports macOS, Linux (glibc and musl), and x86\_64/aarch64 architectures, though Windows is currently unsupported due to upstream native library limitations. It also includes a WebAssembly build for browser environments, requiring specific cross-origin isolation headers and the OPFS VFS for data persistence. A browser-check script and associated HTML/JS test pages are included to verify engine loading and database persistence in headless Chrome.

kyo-sql-doltlite · high confidence

Introduce HTTP WebSocket transport for JSON-RPC

Added \kyo-jsonrpc-http\, a new module that provides a \JsonRpcTransport\ implementation backed by HTTP WebSockets. This allows JSON-RPC clients and servers to communicate over WebSocket connections, with the transport handling the encoding/decoding of JSON-RPC envelopes to/from WebSocket text frames. The implementation includes factories for connecting to a URL or adapting an existing WebSocket, with proper error handling for malformed messages and connection lifecycle management.

kyo-jsonrpc-http/src/main · high confidence

Introduce Kyo Parse module for compositional text parsing

The \kyo-parse\ module is introduced, providing a new parser combinator effect for building structured text parsers. This change adds the core \Parse\ effect along with supporting types (\ParseInput\, \ParseState\, \ParseResult\, \ParseError\, \ParseFailure\) and a \RecoverStrategy\ for handling parse failures. The implementation includes combinators like \firstOf\ for ordered alternatives and utilizes an indexed \ParseInput\ to ensure O(1) token access, addressing previous quadratic complexity issues in repetition operations.

kyo-parse/shared/src/main · high confidence

Introduce KyoDoctest sbt plugin for validating Markdown code blocks

Adds the KyoDoctestPlugin, an sbt plugin that automatically validates Scala code blocks in Markdown files (defaulting to README.md) across JVM projects. It introduces new tasks including \doctest\ (validation), \doctestFresh\ (cold validation), \doctestFormat\ (style rewriting), and \doctestClean\ (cache clearing). The plugin manages concurrency by limiting doctest forks to one at a time across the build, supports content-addressed caching outside the target directory, and allows configuration via settings like \doctestSources\, \doctestPredef\, and \doctestFreshDriver\ to handle specific compiler requirements.

kyo-doctest/plugin/src/main · high confidence

Introduce Model Context Protocol (MCP) server and client support

This release adds the \kyo-mcp\ module, providing a complete implementation of the Model Context Protocol for both server and client roles. Users can now configure MCP endpoints via \McpConfig\, handle reverse-direction client requests (such as sampling, elicitation, and roots) using \McpClientHandler\, and manage server-side capabilities, cancellation, and progress through dedicated policy adapters. The module introduces strict type-safe opaque types for protocol elements like \McpMimeType\, \McpResourceUri\, and \McpCursor\ to ensure validation at construction, and includes hand-rolled schemas for complex content types like \McpContent\ and \CompletionRef\ to support proper JSON-RPC serialization.

kyo-mcp/shared · high confidence

Introduce NIO-based network transport as the JVM fallback backend

Users now have a pure-Java NIO transport available on the JVM platform, serving as the fallback when the preferred POSIX backend (io\_uring/epoll/kqueue) is unavailable or explicitly disabled via the \-Dkyo.net.backend=nio\ flag. This new \NioTransport\ implementation manages the full connection lifecycle—including plain TCP and TLS handshakes—using a single \java.nio.channels.Selector\ to multiplex non-blocking socket channels. It includes dedicated components for handling TLS state (\NioTlsState\, \JdkSslEngine\), connection handles (\NioHandle\), and a driver loop (\NioIoDriver\) that manages read/write/write-connect/accept operations. The transport also supports a driverless stdio connection (\NioStdioConnection\) for bridging process stdin/stdout to the network API, ensuring consistent behavior across different JVM environments regardless of underlying OS syscall availability.

kyo-net/jvm/src/main · high confidence

Introduce Protocol Buffers serialization codec

A new Protocol Buffers (protobuf) codec is now available for serializing and deserializing data. This feature adds support for encoding values to proto3 wire-format bytes and generating .proto schema definitions. It includes configuration options for strict or permissive conformance modes, limits on nesting depth and collection sizes, and support for field ID overrides to ensure interoperability with existing .proto definitions.

kyo-schema-protobuf/shared · high confidence

Introduce SQLite backend with engine-specific configuration and error handling

This change adds the SQLite backend to the SQL driver, enabling users to connect to SQLite databases via the \sqlite://\ scheme. It introduces engine-specific configuration options, including \SqliteAttach\ for attaching additional databases at connection time and \SqliteVfs\ for selecting the Virtual File System (e.g., \opfs\ for WebAssembly). The driver also implements a custom SQL dialect (\SqliteDialect\) that adapts standard SQL rendering to SQLite's limitations, such as handling type casting, arithmetic, and value sources. Additionally, it provides specific exception types like \SqliteAdvisoryLockUnsupportedException\ and \SqliteIsolationLevelUnsupportedException\ to clearly signal when SQLite-specific features (like advisory locks or specific isolation levels) are requested but not supported by the engine.

kyo-sql-sqlite-driver/shared · high confidence

Introduce Telegram Bot API client with strict configuration validation

This change adds a new Telegram Bot API client module (\kyo-telegram/shared\) that provides a typed, safe interface for interacting with Telegram. It introduces \TelegramConfig\ and \TelegramWebhookConfig\ which enforce strict validation rules at initialization—refusing invalid inputs like non-HTTP base URLs, out-of-range timeouts, or illegal webhook path characters with specific exceptions (\TelegramInvalidConfigException\, \TelegramInvalidWebhookConfigException\). The client includes a long-polling loop (\Poller\) for receiving updates with configurable retry schedules and a markup renderer (\Markup\) that correctly escapes text for Telegram's MarkdownV2 and HTML formatting options. Comprehensive tests cover JSON serialization, configuration bounds, and update decoding.

kyo-telegram/shared · high confidence

Introduce WhatsApp Business Cloud API client

Adds a new \kyo-whatsapp\ module providing a client for the WhatsApp Business Cloud API. The module includes configuration types (\WhatsAppConfig\, \WhatsAppWebhookConfig\) with strict validation for tokens, phone numbers, and URLs, and opaque identifier types (\WaId\, \MessageId\, etc.) to prevent type confusion. It exposes verbs for sending messages (\send\, \sendTemplate\), marking messages as read, and making custom Graph API calls, all isolated within their own HTTP client to prevent leakage of caller configuration. Additionally, it provides webhook handlers for receiving notifications, including signature verification using the app secret and constant-time comparison for the verify token.

kyo-whatsapp/shared · high confidence

Introduce cross-platform kyo-aeron transport via C FFI shim

The kyo-aeron module now uses a statically linked C shim (kyo\_aeron.c) and a generic FFI layer to provide the Aeron transport on JVM, JS, Native, and Wasm. This replaces the previous JVM-only native dependency with a portable implementation that bundles the Aeron C client and embedded media driver, enabling cross-platform publish-subscribe messaging via Topic.run, AeronDriver, and AeronClient.

kyo-aeron/shared/src/main · high confidence

Introduce cross-platform network transport for kyo-jsonrpc

Added a new \kyo-net\-backed transport layer to \kyo-jsonrpc\, enabling cross-platform (JVM, JS, Native, Wasm) communication over Unix domain sockets and stdio. This includes \ConnectionWireTransport\ for adapting \kyo-net\ connections, \UdsBackend\ for managing Unix socket listeners and cleanup, and \StdioWireTransport\ for line-delimited stdio I/O, all wired through \WireTransportAdapter\ to handle JSON-RPC framing and encoding.

kyo-jsonrpc/shared/src/main/scala/kyo/internal/transport · high confidence

Introduce custom JSON-RPC 2.0 envelope schema for strict and lenient encoding

Added a custom Schema implementation for the JSON-RPC 2.0 envelope wire format, enabling both strict and lenient serialization modes. The strict mode enforces the presence of the "jsonrpc":"2.0" version field and ignores extra fields, while the lenient mode omits the version field and validates that any extra fields do not conflict with reserved JSON-RPC keys (id, method, params, result, error, jsonrpc). This change introduces the \JsonRpcEnvelopeSchema\ object and associated request structures to handle the non-standard envelope shape where message types are distinguished by field presence rather than a discriminator tag. Also in this area: 1 commit (0 fixes) modifying kyo-jsonrpc/shared.

kyo-jsonrpc/shared/src/main/scala/kyo/internal/codec · medium confidence · unverified

Introduce direct syntax for effectful code blocks

Adds the \direct\ macro and \.now\/\.later\ extension methods to allow writing effectful code in a synchronous style. The \direct\ block transforms the enclosed code to handle effects, where \.now\ sequences an effect immediately to retrieve its result, and \.later\ preserves the effect for advanced composition. This provides a more ergonomic way to work with Kyo's effect system by desugaring to monadic binds.

kyo-direct/shared/src/main/scala/kyo · high confidence

Introduce durable execution engine and HTTP API for workflow management

This change adds the core internal components for durable workflow execution, including the \FlowInterpreter\ and \StoreInterpreter\ which manage state transitions, retries, timeouts, and compensation handlers against a persistent store. It introduces a new HTTP API (\FlowApi\) exposing endpoints for listing workflows, creating and managing executions (start, cancel, signal), and retrieving execution details, history, and diagrams. Additionally, it provides diagram rendering capabilities for Mermaid, DOT, ELK, and JSON formats, and establishes durable naming conventions for nodes and loop iterations to ensure consistent state tracking across restarts.

kyo-flow/shared/src/main · high confidence

Introduce internal JSON-RPC framing implementation

Added FramerImpl, an internal component that parses incoming byte streams into JSON-RPC frames using line-delimited and Content-Length protocols. This enables the kyo-jsonrpc library to correctly handle message boundaries for browser CDP communication and other JSON-RPC use cases.

kyo-jsonrpc/shared/src/main/scala/kyo/internal/framing · high confidence

Introduce kyo-compat for cross-backend library development

The kyo-compat module is now available, allowing library authors to write code once against a unified \kyo.compat.\*\ surface and ship it to five different backends: Kyo, ZIO, scala.concurrent.Future, Ox, and Twitter Future. This enables consumers to select their preferred runtime at deploy time, with each backend pulling only its own runtime-specific artifact. The module provides an overhead-free, inline-based implementation that preserves backend-specific features like traces and fiber locals while offering a uniform API for concurrency primitives and error handling through the portable \CIO\ type.

kyo-compat · high confidence

Introduce kyo-compiler for IDE language intelligence

The kyo-compiler module provides a presentation-compiler driver that exposes IDE capabilities such as diagnostics, completions, hover, signature help, and symbol lookup. It manages a pool of compiler instances that run either in-process or in isolated forked worker JVMs, communicating via Aeron IPC with results serialized using the kyo-schema wire codec.

kyo-compiler/jvm/src/main · high confidence

Introduce kyo-ffi for cross-platform native code bindings

Adds the \kyo-ffi\ module, providing typed off-heap buffers (\Buffer\) with explicit lifetime management and optimized primitive accessors, along with a structured error hierarchy (\FfiLoadError\, \FfiErrno\, \FfiNullPointer\, etc.) to handle native library loading failures, ABI mismatches, and C-side errors safely.

kyo-ffi/shared/src/main/scala/kyo/ffi · high confidence

Introduce kyo-pod: typed, streaming Docker and Podman client

The kyo-pod module provides a non-blocking, typed interface for managing Docker and Podman containers, supporting both a direct HTTP backend (speaking the Docker Engine API) and a Shell backend (invoking CLI subprocesses). Users can now create, start, stop, and inspect containers, execute commands with streaming output, and monitor logs or health checks without wrapping CLI commands. The module includes a development environment setup via \Containerfile.dev\ for rootless Podman testing.

kyo-pod · high confidence

Introduce kyo-sql-sqlite backend for SQLite database support

This change adds the \kyo-sql-sqlite\ module, providing a new SQLite backend for the \kyo-sql\ SQL abstraction layer. The module embeds the SQLite C source (pinned to version 3.53.4) and registers a backend factory that handles \sqlite://\ and \sqlite3://\ URL schemes across JVM, Scala Native, JS, and Wasm platforms. It includes platform-specific runtime registration logic (e.g., \@JSExportTopLevel\ for JS/Wasm) and a build script to fetch and stage the native library, enabling users to connect to SQLite databases using file paths or in-memory stores via the standard \DB.run\ API.

kyo-sql-sqlite · high confidence

Introduce kyo-stats-registry with typed attributes, service-loader exporters, and overflow-safe metrics

The kyo-stats-registry module adds a new stats infrastructure that lets applications register counters, histograms, gauges, and counter-gauges via a hierarchical scope API, while providing a snapshot view for exporters to enumerate live instruments. It introduces a typed Attributes system (supporting Boolean, Double, Long, String, and their Lists) for span metadata, and a TraceExporter SPI discovered via java.util.ServiceLoader that composes multiple providers with isolated failure handling. The metric implementations handle Long overflow correctly in delta calculations for counters and counter-gauges, and the histogram uses fixed buckets with high-throughput atomic updates and percentile computation. Also in this area: 1 commit (0 fixes) modifying (repo-wide), kyo-stats-otlp/shared, kyo-stats-registry/shared.

kyo-stats-registry/shared · low confidence · unverified

Introduce kyo-test V3 runner with CLI, reporters, and deterministic execution

The kyo-test runner has been replaced by a new V3 implementation located in kyo-test/runner/shared. This adds a command-line entry point (Cli) that parses arguments for filtering, parallelism, and reporter selection, and exposes a test-friendly exit interception mechanism (SystemExitException) to allow test harnesses to verify exit codes without terminating the JVM. The runner now supports multiple output formats via a fan-out reporter architecture: a ConsoleReporter with ANSI colors and hierarchical paths, a TAP 13 reporter for CI integration, and a CombinedReporter that dispatches events to all registered reporters while safely handling reporter failures. Execution is driven by a process-global LeafPool that bounds concurrent leaf execution to prevent scheduler flooding, and the runner ensures deterministic behavior by supporting randomization seeds, detecting duplicate leaf paths, and emitting ScalaTest-compatible failure markers (\\\* FAILED \\\*) for tooling compatibility. Hang diagnostics are captured on the first STUCK leaf via a one-shot thread dump and diagnostics snapshot, and cancelled leaves are treated as skips rather than failures.

kyo-test/runner/shared · high confidence

Introduce off-heap memory management with effect-tracked lifetimes

Adds a new \Memory\ API in \kyo-offheap\ that provides type-safe, effect-tracked access to off-heap memory via Java's Foreign Memory API. Users can now allocate and manage memory segments within an \Arena\ context, which guarantees automatic cleanup of resources when the scope ends, eliminating manual deallocation risks. The API includes operations for reading, writing, filling, and copying data, all tracked by the \Arena\ effect to ensure safety.

kyo-offheap/shared/src/main · high confidence

Introduce typed Slack identifiers and secure credential types

The kyo-slack module now uses opaque types for Slack identifiers (such as ChannelId, UserId, and TriggerId) to prevent accidental mixing of distinct ID kinds at compile time. It also introduces dedicated, non-serializable types for sensitive credentials: SlackToken (separating AppLevel and Bot tokens with validation and redacted string rendering) and SlackResponseUrl (redacting the URL in logs and preventing serialization). Additionally, SlackCommand and SlackRawJson are defined to handle command payloads and raw JSON data securely, ensuring that credentials are never inadvertently exposed or serialized.

kyo-slack/shared · high confidence

Introduce zero-code host metrics collection for JS/Wasm and Linux/macOS

The kyo-stats-machine module now provides automatic host metrics collection across JS/Wasm and native platforms. On JS/Wasm, a new \DiskExecutor\ runs disk reads inline to accommodate single-threaded environments, and \MachineRegistration\ uses \@JSExportTopLevel\ to register the metrics factory without relying on JVM classpath discovery. On Linux, the system reads CPU, memory, swap, load averages, cgroup v1/v2 limits, and disk space via optimized, zero-allocation in-place byte scanning of \/proc\ files, while excluding network and virtual filesystems to prevent blocking. On macOS, a new C shim (\machine\_macos.c\) exposes host statistics (CPU, memory, swap, load, mounts) via FFI bindings, with non-macOS stubs ensuring compilation safety. Configuration is exposed via \MachineFlags\ to disable the sampler, adjust the sampling interval, and set disk read timeouts.

kyo-stats-machine/shared · high confidence

Introduces Discord bot client configuration and validation

Adds \DiscordConfig\ and \DiscordWebhookConfig\ to manage bot connection settings and webhook verification. \DiscordConfig\ validates and holds parameters for the REST API and Gateway, including token, intents, shard, reconnect policy, interaction deadline, rate limits, and timeouts, failing initialization with specific errors for invalid values. \DiscordWebhookConfig\ validates the application's public key and webhook path, rejecting paths with invalid characters. The changes also include tests for these configurations and related Discord models like commands and components.

kyo-discord/shared · high confidence

Introduces JavaScript/WebAssembly scheduler with monotonic time and status reporting

Adds a new single-threaded scheduler implementation for the JavaScript and WebAssembly platforms that executes tasks as macrotasks. This scheduler uses monotonic time for internal deadline and slice calculations to ensure stability against wall-clock adjustments, while providing a status file feature that periodically writes scheduler metrics (scheduled, ran, preempted, and max slice duration) to disk for monitoring in Node.js environments.

kyo-scheduler/js-wasm · high confidence

Introduces Kyo Language Server Protocol (LSP) implementation

Adds the core shared components for a Language Server Protocol implementation, including \LspServer\ and \LspClient\ handles for managing connections, \LspConfig\ for configuration (defaulting to LSP 3.17), and \Lsp\ context accessors for handler-side operations like document access and progress reporting. The change also includes internal infrastructure such as \LspCatalog\ for handler indexing and capability derivation, \LspCancellationPolicy\ for JSON-RPC cancellation handling, and \LspContentSchemas\ for serializing LSP-specific data types.

kyo-lsp/shared · high confidence

Introduces Kyo-native HTTP client and server with typed routing and connection pooling

This change adds a new, Kyo-native HTTP module (\kyo-http\) providing a fully typed client and server implementation. The client features connection pooling, configurable retries, redirects, and timeouts, along with convenience methods for JSON and text handling. The server supports typed route definitions, composable middleware filters (including built-in Basic and Bearer authentication), and WebSocket upgrades. The module also introduces a background configuration synchronization system (\FlagSync\) to keep dynamic flags in sync with external sources, and a new \HttpAddress\ type to support both TCP and Unix domain socket connections.

kyo-http/shared/src/main/scala/kyo · high confidence

Introduces Software Transactional Memory (STM) with transactional references and collections

Adds a new Software Transactional Memory (STM) effect to the library, providing optimistic concurrency control for shared state. This includes \TRef\ for transactional variables, \TMap\ for key-value stores, \TChunk\ for sequences, and \TTable\ for structured records with optional indexing. Transactions executed via \STM.run\ are atomic and isolated, automatically retrying on conflicts using a configurable retry schedule, allowing for lock-free concurrent access to these transactional collections.

kyo-stm/shared · high confidence

Introduces a new format-agnostic YAML CST layer

The YAML module has been restructured to include a new format-agnostic core that operates on a Concrete Syntax Tree (CST). This change adds internal components for parsing YAML into CST events (\YamlEventScanner\), building CST documents from events or values (\YamlCstBuilder\), and rendering CSTs back to YAML strings (\YamlCstRenderer\). It also introduces utilities for manipulating the CST structure (\YamlCstEdits\) and handling multi-document streams (\YamlDocuments\), providing a foundation for preserving syntax and trivia during YAML processing.

kyo-schema-yaml/shared · high confidence

Introduces kyo-sql database client with engine-agnostic API and pluggable backend discovery

This change adds the core kyo-sql library, providing a portable SQL client that operates through a \DB\ effect, ensuring database connections are explicit in the type system rather than ambient. It introduces a pluggable backend architecture where database engines (such as PostgreSQL or MySQL) are discovered via \META-INF/services\ on the classpath, allowing applications to remain engine-agnostic while leveraging specific engine capabilities through \DB.clientAs\. The library includes a comprehensive typeclass-based schema system (\SqlSchema\) for automatic derivation of case classes and tuples, a wire vocabulary (\SqlCodec\) for cross-engine serialization, and compile-time SQL naming conventions (\SqlNaming\) to map Scala identifiers to SQL columns and tables.

kyo-sql/shared · high confidence

Introduces native scheduler implementation with blocking detection and self-tuning regulators

This change adds the \kyo-scheduler\ implementation for the JVM and Native platforms, introducing a new scheduler architecture that includes a \BlockingMonitor\ to detect blocked worker threads via user CPU time sampling and dispatch interrupts to unblock them. It also adds an \Admission\ regulator for load-shedding based on queuing delays and a \Concurrency\ regulator for optimizing thread counts by measuring OS scheduling jitter, along with a \Reporter\ that exposes scheduler status via console output, a status file, and JMX.

kyo-scheduler/jvm-native · high confidence

Introduces new JSON-RPC 2.0 core types and configuration policies

The \kyo-jsonrpc\ module now includes foundational types for the JSON-RPC 2.0 protocol, including \JsonRpcEnvelope\ (with \JsonRpcRequest\, \JsonRpcResponse\, \JsonRpcNotification\, and \JsonRpcMalformedMessage\), \JsonRpcError\ (categorized into parse, dispatch, execution, and application failures), and \JsonRpcId\ (supporting string and long identifiers). It also adds configuration policies for cancellation (\JsonRpcCancellationPolicy\), progress reporting (\JsonRpcProgressPolicy\), and ID allocation strategies (\JsonRpcIdStrategy\), alongside utilities for message framing (\JsonRpcFramer\) and pre-dispatch gating (\JsonRpcMessageGate\).

kyo-jsonrpc/shared/src/main/scala/kyo · high confidence

Introduces structured application runner and platform-agnostic logging internals

This change adds three new internal components to the core library. KyoAppRunner provides a shared entrypoint for Kyo applications, handling effect registration, result rendering (splitting stdout for values and stderr for errors), and exit hooks, with a specific KyoAppRunnerWithInterrupts variant that installs signal handlers for SIGINT/SIGTERM on non-Windows platforms to ensure quiet termination. LogShared introduces a platform-agnostic logging dispatch mechanism that separates pure event handling logic from platform-specific emission, supporting asynchronous logging with configurable overflow policies. OSSignal defines a platform-specific abstraction for operating system signal handling, including a no-op handler for environments where signals are not supported.

kyo-core/shared/src/main/scala/kyo/internal · high confidence

Introduces typed SVG support and a declarative Chart layer for data visualization

kyo-ui now includes first-class, type-safe SVG support via the new \Svg\ module, enabling the construction of SVG trees within the UI framework. Building on this, a new \Chart\ layer provides a declarative authoring spec for data visualizations; users can define charts with typed data and marks (bar, line, area, point, text, errorBar, rule) and configure axes, legends, themes, and interactions, lowering the result to an \Svg.Root\ for embedding in the UI.

kyo-ui/shared · high confidence

Introduction of BrowserProcessId for Chrome user-data directory naming

A new internal utility, BrowserProcessId, has been added to the JVM browser module to retrieve the current process ID. This ID is used to name the Chrome user-data directories owned by the running process, ensuring isolation between different browser instances.

kyo-browser/jvm/src/main · high confidence

Introduction of Kyo kernel core types and utility operations

This change introduces the foundational \kyo\ package components, including the \Kyo\ companion object which provides sequential effect utilities such as \lift\, \unit\, \when\, \unless\, and \zip\ (up to 10 arguments) for composing effectful computations. It also defines the \Closed\ exception for resource management and establishes the \kernel.scala\ file which exposes core type aliases like \\<\[A, S\]\, \Id\, and \Const\, along with exports for \Arrow\, \Isolate\, and \Region\. These additions form the basic API surface for handling effects and resources within the Kyo framework.

kyo-kernel/shared/src/main/scala/kyo · high confidence

Introduction of core Kyo effect primitives

This change introduces the foundational effect types for the Kyo framework within the \kyo-prelude\ module. It adds \Abort\ for typed, composable error handling (distinguishing domain failures from panics), \Check\ for runtime validation with configurable failure strategies, \Choice\ for non-deterministic branching, \Emit\ for push-based value production, \Poll\ for pull-based streaming with backpressure, \Pipe\ for composable stream transformations, \Env\ for typed dependency injection, and \Local\ for scoped contextual values with configurable fork-boundary inheritance. These types form the basis of Kyo's effect system, replacing previous ad-hoc mechanisms with a unified, type-safe approach to side effects and control flow.

kyo-prelude/shared/src/main/scala/kyo · high confidence

JS/Wasm FFI backend now supports WebAssembly and dynamic koffi loading

The JS/Wasm FFI backend now supports loading native libraries via WebAssembly in addition to the existing Node.js koffi path, allowing bindings to run in browser environments when a WASM provider is registered. The koffi library is now loaded dynamically on first use rather than via static imports, preventing link-time crashes on hosts without koffi installed and enabling graceful degradation. Blocking FFI calls are now dispatched asynchronously through a libuv worker pool with a configurable meter to apply backpressure and prevent pool exhaustion errors.

kyo-ffi/js-wasm · high confidence

JVM FFI backend implementation using Java Panama

The JVM-specific implementation for the kyo-ffi library has been added, providing the runtime foundation for cross-platform native code bindings. This includes a native library loader that detects the OS and architecture to extract and cache bundled libraries or fall back to system paths, a guard system that wraps Panama shared arenas to manage native resource lifecycles and detect leaks, and a scratch allocator for transient marshalling of strings and structs. The backend also features an upcall bridge to convert Scala functions into Panama upcall stubs for callbacks, a variadic marshaller for handling C variadic functions, and buffer factories for allocating shared and confined memory segments.

kyo-ffi/jvm/src/main/scala · high confidence

JVM bindings for Ox structured concurrency

This change introduces a new set of compatibility bindings in the \kyo-compat/bindings/ox/jvm\ module that allow Kyo applications to run on the JVM using the Ox structured-concurrency library. It provides opaque wrappers for core concurrency primitives—including \CIO\ (the effect type), \CFiber\, \CStream\, \CPromise\, \CChannel\, \CLatch\, \CMeter\, \CLocal\, and atomic references (\CAtomicBoolean\, \CAtomicInt\, \CAtomicLong\, \CAtomicRef\)—that delegate to native Ox and Java concurrency APIs. Users can now leverage Ox's direct-style, scope-bound concurrency model while maintaining a Kyo-like API surface, with specific behaviors such as stack-safe \flatMap\ in \CIO\ and thread-blocking semantics for I/O operations adapted to the JVM environment.

kyo-compat/bindings/ox/jvm · high confidence

JVM scheduler gains cross-classloader singleton semantics and monitoring tools

The JVM scheduler now guarantees a single instance across multiple classloaders (e.g., in application servers or plugin systems) via a new \Singleton\ utility, preventing conflicting thread pool adjustments and inaccurate system load measurements. Additionally, a new \top\ module provides a JMX interface (\kyo.scheduler:type=Top\) and a console client for real-time scheduler status monitoring, while \LoomSupport\ enables optional virtual thread integration on modern JVMs.

kyo-scheduler/jvm · high confidence

JVM signal handling for interruption support

The JVM-specific internal implementation for signal handling has been introduced to support application interruption. This new platform-specific component uses reflection to install OS signal handlers (targeting \sun.misc.Signal\), allowing the framework to react to system signals. If the underlying JVM does not support these signal classes, the system gracefully defaults to a no-op handler rather than failing.

kyo-core/jvm/src/main/scala/kyo/internal · high confidence

JVM test runner adds sbt integration, JUnit XML reporting, and end-of-run leak detection

The JVM test runner now integrates with sbt via a new \SbtFramework\ and \SbtRunner\ that discover and execute \kyo.test.Test\ suites, while also providing a \JUnitXmlReporter\ that writes per-suite XML reports for CI consumption. Additionally, the runner performs end-of-run leak checks in forked JVMs, detecting open file descriptors, non-daemon thread leaks, and stranded operations to fail the build on resource leaks.

kyo-test/runner/jvm · high confidence

Kyo website now uses a Scala.js SPA with client-side routing and SSG hydration

The documentation site has replaced the previous docsify-based static site with a Single Page Application (SPA) built in Scala.js. The new \WebsiteBundleMain\ entry point bootstraps the app by reading pre-rendered HTML 'islands' seeded by the static site generator (SSG), mounts a unified shell, and handles navigation via a client-side router. This allows seamless, reload-free transitions between the landing page and documentation modules, while preserving SEO-friendly URLs and head metadata (title, canonical links) by syncing them with the SSG output. The change includes robust route classification to handle known modules, version prefixes, and unknown paths, along with tests for the new \DocsClient\ and router logic.

kyo-website-bundle/js · high confidence

MySQL backend support added to kyo-sql

The kyo-sql module now includes a MySQL backend, enabling users to connect to MySQL databases via the \mysql://\ URL scheme. This change introduces \MysqlClient\ for engine-specific operations (such as \LOAD DATA LOCAL INFILE\), registers the backend via \META-INF/services\, and implements the MySQL 8.x wire protocol (including handshake, authentication, and packet encoding/decoding) along with MySQL-specific error handling for session variable changes and conflict clause suppressions.

kyo-sql-mysql/shared · high confidence

Native TLS and POSIX networking shims for cross-platform compatibility

The kyo-net module now includes C shims that enable TLS and low-level POSIX networking on Scala Native. A bundled BoringSSL shim (kyo\_net\_boringssl) and a system-OpenSSL fallback (kyo\_ossl) share a common memory-BIO TLS state machine, allowing the library to link and operate on Native even when the target TLS engine is absent by providing stub implementations that report unavailability. Additionally, shims for Linux epoll/eventfd, POSIX file control (fcntl), and hostname resolution (getaddrinfo) are provided with non-POSIX stubs to ensure the link graph remains whole on Windows and other platforms.

kyo-net/shared/src/main · high confidence

Native backend for kyo-ffi cross-platform bindings

This change introduces the Scala Native implementation for the kyo-ffi cross-platform bindings, enabling FFI usage on Native targets. It provides native-specific backends for core components including buffer allocation and memory-mapped file access (BufferFactory), reflective class instantiation (FfiReflect), guard lifecycle and leak detection (NativeGuard, NativeLeakDetector, GuardRegistry), and callback registry management (TaggedCallback, CallbackRegistry). The implementation also includes platform checks for 64-bit hosts (NativeLoader) and comprehensive concurrency and leak-detection tests to ensure stability.

kyo-ffi/native · high confidence

Native browser launcher platform support and process ID utility

This change introduces the native platform implementation for the browser launcher, including a new \BrowserProcessId\ utility that retrieves the current process ID via POSIX \getpid\ to name Chrome user-data directories, and a no-op \BrowserLauncherPlatform\ implementation for native environments. A corresponding test verifies that the native launcher's shutdown hook registration behaves correctly as a no-op without raising exceptions.

kyo-browser/native · high confidence

Native implementation of off-heap memory management

This change introduces the native Scala Native implementation for the \kyo-offheap\ module, providing stub classes for \java.lang.foreign.Arena\ and \java.lang.foreign.MemorySegment\. The \Arena\ class manages the lifecycle of off-heap memory by tracking allocations and freeing them upon closure, while \MemorySegment\ wraps native pointers to allow reading and writing primitive values (such as \Int\, \Long\, \Float\, etc.) and supports memory copying and slicing operations. This enables the application to perform direct memory access on native platforms.

kyo-offheap/native · high confidence

Native platform network transport and DNS resolution

This change introduces the native platform implementation for Kyo's network stack, enabling high-performance, cross-platform networking on Scala Native. It provides a unified transport layer that automatically selects the optimal POSIX I/O backend (io\_uring, epoll, or kqueue) based on OS capabilities, and bundles BoringSSL as the primary TLS provider with a fallback to system OpenSSL. Additionally, it implements a native DNS resolver that correctly handles IPv4/IPv6 address family preferences to match JVM behavior, ensuring consistent hostname resolution across platforms.

kyo-net/native · high confidence

Native platform queue implementations and optimized Tag equality

This change introduces a suite of lock-free, multi-producer/multi-consumer (MPMC), multi-producer/single-consumer (MPSC), and single-producer/single-consumer (SPSC) queue implementations for the JVM and Native platforms, including both bounded and unbounded variants with chunked memory layouts. Additionally, it adds platform-specific Tag equality logic that uses memoized hash codes to quickly reject unequal types before performing expensive string comparisons, improving performance for large type encodings.

kyo-data/jvm-native · high confidence

Native platform support for HTTP, TLS, and Unix sockets

The HTTP client and server now run on Scala Native, providing cross-platform TCP, TLS (via OpenSSL), and Unix domain socket connectivity. This adds native-specific C bindings for non-blocking I/O and TLS handshakes, along with the necessary test infrastructure (TLS certificates and Unix socket helpers) to validate these capabilities on native targets.

kyo-http/native · high confidence

New AI skills for automated README analysis, drafting, and verification

Added a suite of Claude Code skills under \.claude/skills/\ to automate the creation and quality assurance of module READMEs. The workflow begins with \readme-analyze-source\ to extract a source-grounded spine, callouts, and API inventory without reading existing docs. \readme-draft\ uses this analysis to generate a curriculum-structured README that emphasizes teaching over cataloging, enforcing rules like use-case section headings, a 15-line opening hook, and a consistent running domain. \readme-analyze-existing\ diagnoses current READMEs against the source analysis to produce a structured action list (cut, relocate, restructure, etc.) for \readme-edit\ to apply mechanically. Quality is enforced by \readme-critique\, which evaluates the draft on pedagogical axes (e.g., running domain consistency, cross-API teaching), and \readme-verify\, which runs mandatory sbt doctest compilation checks and structural script validations to ensure code examples are valid and complete.

.claude · high confidence

New BSON serialization codec for schema-driven encoding

A new BSON codec has been added to the \kyo-schema-bson\ module, enabling users to serialize and deserialize case classes and maps to/from BSON binary format. The implementation enforces that top-level values must be document-shaped (objects), supporting nested arrays, scalars, binary data, UTC datetimes, and lossless \BigDecimal\ via BSON Decimal128. It includes configurable safety limits for decode depth and collection size, and provides both contextual and explicit configuration APIs for encoding and decoding operations.

kyo-schema-bson/shared · high confidence

New CI and build tooling scripts for local development and diagnostics

The repository introduces a suite of new shell scripts to standardize local builds and improve CI observability. \build.sh\ serves as the primary local entry point, supporting \direct\, \podman\, and \podman-ci\ environments with explicit architecture targeting (native, x86, arm) and resource caps that mirror CI settings. Reliability is improved by \apt-install.sh\, which handles package installation with bounded retries and automatic mirror fallbacks to survive transient network issues. Diagnostics are enhanced with \ci-logs.sh\ for inspecting job logs and failures, \ci-monitor.sh\ for tracking system resource pressure (disk, memory, sockets), and \ci-queue.sh\ for analyzing runner queue wait times. These scripts are accompanied by self-tests (\build-selftest.sh\, \ci-monitor-selftest.sh\) to validate their logic. Also in this area: 1 commit (0 fixes) modifying kyo-slack/shared, scripts; CI scripts now use a Docker Hub pull-through mirror and cache apt packages; Improved detection of sbt invocations in shell scripts; Enforce ExitOnOutOfMemoryError in CI to prevent hung jobs; Added tests for CI robustness against stuck JVMs and sbt boot socket issues.

scripts · low confidence · unverified

New Future-based compatibility binding for Kyo

This change introduces a new \kyo-compat\ binding that allows Kyo effects (\CIO\) to interoperate with the standard Scala \Future\ ecosystem. It provides a \CIO\ implementation backed by \scala.concurrent.Future\, enabling users to lift existing \Future\ code into Kyo and vice versa. The binding includes a full set of concurrency primitives adapted for the Future model, such as \CAtomicBoolean\, \CAtomicInt\, \CAtomicLong\, \CAtomicRef\, \CChannel\, \CLatch\, \CLocal\, \CMeter\, \CPromise\, and \CFiber\. It also introduces a JVM-specific \CompatScheduler\ to handle time-based operations like \CIO.sleep\ and \CIO.timeout\ using a daemon thread pool, and a \LocalCtx\ mechanism to thread fiber-local state through the \Future\-backed effects.

kyo-compat/bindings/future/shared · high confidence

New HTTP client backend with WebSocket and connection pooling support

The HTTP client module now uses a new internal backend (\HttpClientBackend\) that manages connection pooling, transport, and protocol handling. This change introduces native WebSocket support via a new \WebSocketCodec\ for frame encoding/decoding and upgrade handling, alongside robust HTTP/1.1 connection management with configurable timeouts, TLS, and Unix socket support. Users benefit from improved reliability in connection reuse and explicit handling of WebSocket frames and errors.

kyo-http/shared/src/main/scala/kyo/internal/client · high confidence

New IMAP and SMTP configuration models and MIME parsing infrastructure

This change introduces the foundational configuration and parsing components for the new email module. It adds \EmailImapConfig\ and \EmailSmtpConfig\ case classes that define connection parameters (host, port, TLS mode, timeouts, and retry schedules) with strict validation logic to prevent invalid configurations from reaching the network layer. It also includes internal utilities for handling email-specific data formats: \Charsets\ for resolving mail-standard character encodings, \ImapModifiedUtf7\ for encoding mailbox names, \DateCodec\ and \MessageIdCodec\ for parsing RFC 5322 date and message ID headers, and \Threading\ for constructing reply chains. These components provide the structured data models and parsing capabilities required for the IMAP and SMTP effects.

kyo-email/shared · high confidence

New JMH benchmarks and JVM/Native runtime bridges for kyo-ffi

This change introduces a comprehensive JMH benchmark suite in \kyo-ffi/bench\ to measure FFI performance, including call overhead, array passing strategies (zero-copy pinning vs. off-heap copying), callback upcall costs, and reflection-based loading latency. It also adds core runtime infrastructure in \kyo-ffi/jvm-native\ to support these bindings: \BlockingBridge\ wraps synchronous \@Ffi.blocking\ downcalls into \Fiber.Unsafe\ to allow the Kyo scheduler to manage blocked carrier threads, \BorrowOwnerHolder\ manages thread-local borrow ownership, and \GuardDrainSupport\ provides cross-platform primitives for draining retained callbacks. Tests are included to verify the correctness of the mmap buffer operations and the blocking bridge contract.

kyo-ffi/bench, kyo-ffi/jvm-native · high confidence

New JMH benchmarks for Kyo core data structures and concurrency primitives

The benchmark suite now includes detailed performance comparisons for Kyo's Chunk, Span, TypeMap, and Tag implementations against ZIO and standard Scala collections, alongside new benchmarks for Kyo's Async and Sync execution models (including fork, blocking, and flatMap patterns) compared to ZIO and Cats Effect.

kyo-bench/src · high confidence

New JS/Wasm network transport module

This change introduces the \kyo-net\ module for JavaScript and WebAssembly targets, enabling network connectivity in these environments. It provides a \JsIoDriver\ that leverages the Node.js event loop for I/O, a \NodeBackend\ that serves as the default transport floor, and a backend selection mechanism (\IoBackendPlatform\) that allows posix-native transports (via koffi) to take precedence on compatible hosts while falling back to the Node.js implementation. The module also includes platform-specific TLS providers (\NodeTlsProvider\ and \BoringSslProvider\) and Node.js module facades (\NodeBuiltins\) to support these operations.

kyo-net/js-wasm/src/main · high confidence

New JSON and JSONL serialization capabilities with schema metadata support

The kyo-schema-json module now provides a complete JSON serialization surface, including high-performance encoding/decoding via \Json.encode\ and \Json.decode\, and streaming support for line-delimited JSON (JSONL/NDJSON) through \Jsonl.read\ and \Jsonl.write\. Generated JSON schemas are now enriched with runtime metadata from \Schema\, such as field documentation, deprecation markers, examples, and validation constraints. Additionally, the module fixes a compilation issue where external packages could not derive \Schema\ due to private type leaks in the macro-generated code.

kyo-schema-json/shared · high confidence

New Kyo compatibility bindings for standard concurrency primitives

The \kyo-compat\ module now provides a comprehensive set of opaque wrapper types (\CAtomicBoolean\, \CAtomicInt\, \CAtomicLong\, \CAtomicRef\, \CChannel\, \CChunk\, \CFiber\, \CIO\, \CLatch\, \CLocal\, \CMeter\, \CPromise\, \CStream\) that expose Kyo's native effectful types through a unified \CIO\ surface. These bindings allow users to interact with Kyo's atomic cells, channels, fibers, latches, meters, promises, and streams using a consistent API that mirrors standard Java concurrency contracts while preserving Kyo's frame propagation and effect handling semantics.

kyo-compat/bindings/kyo/shared · high confidence

New KyoCaseApp and KyoCommand entrypoints for CLI applications

This change introduces the \kyo-case-app\ module, providing \KyoCaseApp\ and \KyoCommand\ classes that integrate the \case-app\ library with Kyo's effect system. Users can now define CLI applications by extending these classes and registering effectful work using \run\ blocks, which support parsed options, remaining arguments, or no arguments at all. The implementation ensures that multiple \run\ blocks execute in registration order with a consistent snapshot of parsed CLI data, and includes internal support for platform-specific exit handling and interrupt management.

kyo-case-app/shared · high confidence

New MIME parsing and multipart handling capabilities

The kyo-mime library now includes comprehensive support for parsing and rendering MIME types, content dispositions, and multipart boundaries. Users can parse media types and disposition headers according to RFC 2045, 2046, 2183, 6266, 8187, and 2231, including support for RFC 2231/8187 encoded parameters (filename\*) and multipart boundary generation. The implementation handles UTF-8 encoding with proper surrogate pair handling and provides deterministic boundary selection for multipart bodies.

kyo-mime/shared · high confidence

New Microsoft Teams bot client and webhook support

This change introduces the core infrastructure for integrating with Microsoft Teams, including a Bot Connector client for sending activities and handling API responses, a webhook handler for receiving incoming messages and events, and comprehensive JWT token verification for webhook security. It also adds configuration models for Teams-specific settings (such as service hosts and credentials), URL validation utilities, and data models for Activities, Adaptive Cards, and channel events, along with a test playground container for local development.

kyo-teams/shared · high confidence

New SLF4J logging backend for JVM

Users can now route Kyo's \Log\ effect through the SLF4J ecosystem on the JVM via the new \SLF4JLog\ integration. This backend wraps standard \org.slf4j.Logger\ instances, allowing applications to leverage existing SLF4J configurations (such as Logback) for log routing and formatting. It supports all standard log levels (trace, debug, info, warn, error) and ensures that runtime level changes in the underlying SLF4J implementation are immediately reflected in Kyo's logging behavior without requiring an application restart.

kyo-logging-slf4j/jvm · high confidence

New SQLite database backend

The library now supports SQLite as a first-class database engine. Users can connect to SQLite databases using the \sqlite://\ URL scheme via \SqlClient.init\. This backend includes a native C binding layer (\kyo\_sqlite.c\) to interface with the SQLite engine, handles connection pooling, and enforces SQLite-specific behaviors such as refusing multi-statement strings and managing schema-qualified names through attached databases.

kyo-sql-sqlite/shared · high confidence

New ZIO compatibility bindings for core concurrency primitives

The \kyo-compat/bindings/zio/shared\ module now provides a complete set of opaque wrappers that map Kyo's concurrency types to their native ZIO equivalents, enabling seamless interoperability. This includes \CIO\ (wrapping \ZIO\[Any, Throwable, A\]\), \CStream\ (wrapping \ZStream\), and carriers for atomic state (\CAtomicBoolean\, \CAtomicInt\, \CAtomicLong\, \CAtomicRef\), synchronization (\CChannel\, \CLatch\, \CMeter\), control flow (\CFiber\, \CPromise\, \CLocal\), and data structures (\CChunk\). All operations propagate ZIO \Trace\ and expose identity \lift\/\lower\ methods to bridge between the Kyo compat surface and native ZIO APIs.

kyo-compat/bindings/zio/shared · high confidence

New bidirectional Kyo-ZIO interop module

The kyo-zio module introduces bidirectional interoperability between Kyo and ZIO, allowing ZIO effects to be lifted into Kyo computations and vice versa. It provides three pairs of functions: ZIOs.get/run for ZIO values, ZStreams.get/run for ZIO streams, and ZLayers.get/run for ZIO dependency layers. The interop preserves failure semantics (mapping ZIO failures to Kyo Aborts and ZIO dies to Kyo Panics) and supports bidirectional interruption. ZIO environments are not supported directly in ZIOs.get and must be eliminated or routed through ZLayers.get. The module is cross-compiled for JVM, JS, and Native.

kyo-zio · high confidence

New bidirectional interop between Kyo and ZIO

This release introduces the \kyo-zio\ module, providing seamless conversion between Kyo and ZIO effects. Users can lift ZIO effects into Kyo using \ZIOs.get\ and run Kyo computations as ZIO effects via \ZIOs.run\. The module also supports ZIO Layers (\ZLayers\) for dependency injection integration and ZIO Streams (\ZStreams\) for streaming data, ensuring proper resource scoping, interruption handling, and error translation between the two runtimes.

kyo-zio/shared · high confidence

New concurrency primitives and access patterns

The kyo-core module introduces several new concurrent data structures and patterns to improve performance and flexibility. A new Access enum defines producer-consumer access patterns (MPMC, MPSC, SPMC, SPSC) that can be specified for Channels and Queues to optimize internal implementations. New high-performance accumulators, LongAdder and DoubleAdder, are provided for efficient concurrent updates with reduced contention compared to standard atomics. An Admission control mechanism is added to help prevent system overload by selectively rejecting tasks based on probabilistic or key-based sampling. Additionally, the Exchange primitive is introduced to simplify building request/response multiplexers for protocols like HTTP/2 or WebSocket by handling ID assignment, encoding, sending, and response routing automatically.

kyo-core/shared/src/main/scala/kyo · high confidence

New configuration flags, unsafe API guard, and XXHash implementation

This change introduces \StaticFlag\ and \DynamicFlag\ for declaring configuration values that resolve from system properties, with \StaticFlag\ providing zero-overhead, once-resolved values and \DynamicFlag\ supporting runtime updates. It adds the \AllowUnsafe\ abstract class to explicitly gate access to unsafe APIs, requiring an implicit parameter or a specific import to bypass safety checks. Additionally, the internal hashing mechanism is replaced with a Scala port of XXHash (XXH32/XXH64) to provide constant-time, allocation-free string hashing on the JVM and fix store-fault issues on Native platforms.

kyo-config/shared/src/main/scala · high confidence

New cross-platform Markdown-to-UI renderer with safe rendering mode

A new \kyo-markdown\ module provides a cross-platform renderer that converts Markdown source strings into a \kyo-ui\ article subtree, supporting headings, paragraphs, lists, GFM pipe tables, fenced code blocks, blockquotes, and inline images/links. The renderer includes a \safe\ mode (via \Options(html = false)\) for untrusted content, which escapes raw HTML and restricts link/image schemes to \http\, \https\, fragments, and safe paths, refusing dangerous schemes like \javascript:\ or \data:\. Also in this area: 1 commit adding/updating tests in kyo-markdown/shared.

kyo-markdown/shared · high confidence · unverified

New cross-platform TASTy and classfile fixture library

A comprehensive set of Scala and Java fixture classes has been added to the \kyo-tasty/fixtures\ module to enable cross-platform (JVM, JS, Native) testing of TASTy decoding and classfile reflection. The shared fixtures cover a wide range of Scala 3 language features, including opaque types, sealed hierarchies, context functions, intersection/union/match types, and various tree ADT variants. To support JS and Native environments without a full standard library, the module also embeds the raw bytecode of a Java fixture class (\JavaSimpleFixture\), allowing tests to exercise Java annotation retention and classfile parsing paths uniformly across all platforms.

kyo-tasty/fixtures/shared · high confidence

New filesystem and process management APIs in kyo-system

This release introduces a typed, effect-tracked filesystem API and a process management API to the \kyo-system\ module. The filesystem API provides a \Path\ type with distinct \PathRead\ and \PathWrite\ capabilities, enabling safe, composable file operations (read, write, watch, lock) that are discharged by specific runners. It includes a pluggable \FileSystem\ backend with support for advisory locking, change watching, and streaming I/O, backed by a \HostFileSystem\ implementation for the local OS. Concurrently, a new \Command\ API allows building and executing OS processes with typed error handling for launch failures (e.g., program not found, permission denied) and robust lifecycle management via scope-based cleanup. These changes replace ad-hoc system interactions with a structured, type-safe approach to system resources.

kyo-system/shared · high confidence

New internal utilities for type-safe borrowing, cross-platform hashing, and macro stability

This update introduces several internal components to the kyo-data library. A new BorrowOwner and BorrowRevoked mechanism tracks the lifetime of borrowed buffers, throwing a specific exception when access is attempted after revocation. To support cross-platform UUID generation without platform-specific dependencies, pure Scala implementations of SHA-1 and SHA-256 are added. Additionally, the DeclaredBounds utility ensures stable macro behavior across different compiler flags by correctly reading type member bounds, and the Environment utility detects development modes (e.g., SBT presence) to control debug verbosity.

kyo-data/shared/src/main/scala/kyo/internal · high confidence

New kyo-actor and kyo-aeron modules for message-based concurrency and high-performance messaging

This release introduces two new modules. The kyo-actor module provides a low-level, message-based concurrency primitive where actors process messages sequentially in a mailbox, supporting parent-child hierarchies, request-response patterns via \ask\, and graceful shutdown. The kyo-aeron module adds typed publish-subscribe messaging over the Aeron transport, enabling low-latency inter-process communication (IPC) and UDP-based distributed messaging with built-in retry schedules, embedded driver management, and a structured exception hierarchy for handling backpressure, transport, and publish failures.

repository · high confidence

New kyo-combinators library for effect handling and composition

The kyo-combinators module has been introduced, providing a comprehensive set of extension methods and utilities for working with Kyo effects. This includes AbortCombinators for handling and transforming Abort effects (e.g., result, recover, mapAbort), AsyncCombinators for asynchronous operations like forking and parallel execution, ChoiceCombinators for managing choice effects, EmitCombinators for streaming and emitting values, EnvCombinators for environment injection, and KyoCombinators for general control flow (repeat, delay, sequencing). It also provides Constructors for creating effects from standard Scala types (Option, Either, Future) and internal support like Zippable for combining results.

kyo-combinators/shared/src/main · high confidence

New kyo-data utility types and encoders

The kyo-data module introduces several new types and utilities: Ansi provides ANSI color and formatting extensions for strings plus a syntax highlighter for code snippets; Base64 offers a cross-platform (JVM, Scala.js, Scala Native) encoder/decoder for standard and URL-safe alphabets per RFC 4648; ByteSize is an opaque type for storage quantities with parsing, arithmetic, and human-readable formatting; ChunkBuilder is a mutable, reusable builder for creating Chunk.Indexed instances; ConstValue materializes compile-time singleton literal types as runtime values; Dict is an immutable dictionary optimized for small (linear scan) and large (hash map) sizes with a corresponding DictBuilder; Duration gains parsing, conversion from Java/Scala durations, and improved show scaling; Fields reifies intersection field types for Record operations; and Have provides compile-time evidence for field presence in Records.

kyo-data/shared/src/main/scala/kyo · high confidence

New kyo-pod demo applications and internal streaming infrastructure

This change introduces a suite of demo applications in the \kyo-pod/shared\ test sources that showcase advanced container orchestration patterns: a locked-down \CodeSandbox\ for executing user code with resource limits, an \IntegrationTestScaffold\ for spinning up multi-container stacks (Postgres/Redis) with health checks, a \LogAggregator\ for merging and filtering live container logs, a \PrometheusExporter\ for scraping and formatting container stats, and a \ServiceMesh\ demonstrating three-tier routing with DNS resolution. To support these demos and the broader attach/log capabilities, the diff also adds internal streaming primitives: \FrameAssembler\ for demultiplexing Docker's stdout/stderr binary frames, \LineAssembler\ for stitching byte streams into UTF-8 lines, \AttachOutput\ for joining attach sessions into log entries, \ErrorClassification\ for unified error handling across HTTP and Shell backends, and \InspectDtos\ for parsing container inspection responses.

kyo-pod/shared · high confidence

New kyo-ui-based documentation and landing site

The documentation and landing pages have been rebuilt using the kyo-ui component library, replacing the previous static site generator. The new site features a unified single-page-app shell with a persistent header, a reactive two-pane documentation layout with a collapsible mobile drawer, and a redesigned landing page with an AI-first narrative. It includes a live search index, version switching, and a dark/light theme toggle, all rendered via a shared stylesheet defined in code.

kyo-website/shared · high confidence

New low-level HTTP codec and OpenAPI code generation infrastructure

The \kyo-http\ module introduces a new internal codec package that adds a zero-allocation, packed-binary \ParsedRequest\ representation for HTTP/1.1 requests, a corresponding \ParsedResponse\ structure, and a compile-time \OpenApiMacro\ that generates typed HTTP routes from OpenAPI specifications. This changes how the HTTP layer processes and validates incoming requests and generates server-side route definitions, providing a more efficient and type-safe foundation for HTTP handling.

kyo-http/shared/src/main/scala/kyo/internal/codec · high confidence

New pure-Scala cryptographic primitives for kyo-crypto

The kyo-crypto/shared module now includes pure-Scala implementations for several cryptographic algorithms, removing the dependency on platform-specific Java security providers. This adds constant-time comparison utilities (ConstantTime), HMAC-SHA256 (Hmac), PBKDF2 key derivation (Pbkdf2), MD5 and SHA-1 hashing (Md5, Sha1), SASLprep string preparation (Saslprep), and full Ed25519 signature verification (Ed25519). It also introduces RSA support, including key validation and parsing from JWK/PEM formats (Rsa), RSA-OAEP encryption (RsaOaep), and RSASSA-PKCS1-v1\_5 signature verification (RsaPkcs1). These changes enable secure cryptographic operations across all supported platforms, including Scala.js, Scala Native, and Wasm.

kyo-crypto/shared · high confidence

New structural data manipulation primitives: Builder, Compare, Focus, and Modify

The kyo-schema module introduces a suite of new type-safe APIs for constructing, inspecting, and mutating case class data. \Builder\ enables compile-time guaranteed construction of case classes by tracking required fields via intersection types, ensuring \.result\ is only available when all mandatory fields are set. \Compare\ provides read-only structural diffing to identify changed fields between two values. \Focus\ acts as a pure lens for navigating and updating specific fields within a value, supporting a mode lattice (Id, Maybe, Chunk) to track access certainty. \Modify\ allows batching multiple field mutations into a reusable, composable patch that can be applied to a value. These components work together to provide a robust, type-safe foundation for data transformation within the schema system.

kyo-schema/shared · high confidence

Out-of-the-box GraalVM native-image support for kyo-ffi

Users building native binaries with GraalVM can now run kyo-ffi without manual configuration. The library includes a native-image.properties file that enables the required experimental SharedArenaSupport and native access flags, and a reachability-metadata.json file that registers necessary reflection types and resource globs, ensuring the Panama FFM layer functions correctly in the native image.

kyo-ffi/jvm/src/main/resources · high confidence

PostgreSQL backend support added to kyo-sql

The kyo-sql library now includes a dedicated PostgreSQL backend, enabling users to connect to PostgreSQL databases using the \PostgresClient\. This addition introduces PostgreSQL-specific capabilities such as bulk data loading and unloading via \COPY\ (\copyIn\/\copyOut\), asynchronous notification subscriptions via \LISTEN\/\NOTIFY\ (\notifications\), and access to server startup parameters. It also provides type-safe support for PostgreSQL-specific data types including \hstore\, \Range\, and \enum\ types through \PostgresTypes\, along with configuration options for custom type resolution, search paths, and cleanup timeouts via \PostgresConfig\. The backend is registered via the standard Java Service Provider Interface mechanism.

kyo-sql-postgres/shared · high confidence

Reactive Streams interop for Kyo streams

Users can now convert Kyo streams into standard Java Reactive Streams Publishers and subscribe to them using standard Subscribers. This change introduces the \StreamReactiveStreamsExtensions\ object, which provides \subscribe\ and \toPublisher\ extension methods on \Stream\[T, S & Sync\]\, enabling interoperability with existing Reactive Streams libraries and tools.

kyo-reactive-streams/shared/src/main/scala/kyo · high confidence

SQLite driver now supports WebAssembly execution in browsers

The SQLite driver for the JavaScript/WASM target now includes a new \SqliteWasmFacade\ implementation that allows the database engine to run via a compiled WebAssembly module instead of relying on native shared libraries. This enables the driver to function in browser environments where native dynamic linking is unavailable, by mapping SQLite C API calls to WebAssembly exports and handling data marshalling (such as pointer and string conversions) specifically for the WASM runtime.

kyo-sql-sqlite-driver/js-wasm · high confidence

Scala Native test runner support

The kyo-test framework now supports running tests on Scala Native. This adds a native-specific test runner implementation (NativeFramework, NativeRunner, NativeTask) that integrates with the sbt.testing interface and Scala Native's reflective instantiation. Key behaviors include: parallelism is capped to 1 (single-threaded execution), JUnit XML and TAP file reporters are unsupported (returns error), and thread dumps are unavailable. The runner uses Scala Native's Reflect API for class instantiation since standard Java reflection is not available. Tests are discovered via the native test-interface bridge rather than service-loader scanning.

kyo-test/runner/native · high confidence

Scheduler diagnostics now report worker status and fiber traces

The scheduler now registers a diagnostics dumper that exposes detailed internal state, including per-worker metrics (running, mount, load, executions, blocked, stalled, frame) and busy fiber traces. This allows the test runner to detect and diagnose scheduler hangs, such as lost wakeups, by providing visibility into worker activity and fiber progress during diagnostic dumps.

kyo-core/jvm-native/src/main/scala/kyo/scheduler · high confidence

Shared JVM/Native network transport bootstrap and TLS test harness

This change introduces the shared \jvm-native\ source set for the network module, providing a platform-agnostic transport bootstrap and a comprehensive test suite for the native TLS implementation. The \NetPlatformTransportBase\ trait centralizes the creation of the process-shared \Transport\ instance for both JVM and Native platforms, ensuring consistent initialization via the \IoBackendPlatform\ registry. Additionally, the diff adds a suite of tests for the bundled BoringSSL engine, including lifecycle verification, deterministic io\_uring STARTTLS wire-order invariants, and critical security checks for TLS close\_notify handling and PEM configuration validation (ensuring unreadable CA/cert paths fail closed rather than silently weakening trust).

kyo-net/jvm-native · high confidence

kyo-ffi: cross-platform FFI layer with JS integration tests and build tooling

The kyo-ffi module introduces a low-level foreign-function-interface layer that generates platform-specific native bindings (JVM Panama, Scala Native @extern, JS koffi) from Scala traits at build time. This release adds comprehensive integration tests (kyo-ffi-it) exercising the plugin-to-runtime pipeline on JVM, Scala Native, and Scala.js, including specific JS-side system library initialization to handle koffi's path resolution quirks on macOS and Linux. It also introduces build-time tooling for CI workflows (GitHub Actions template for native builds) and npm dependency bundling (koffi version pinning) to streamline shipping native libraries across platforms. Also in this area: 1 commit (0 fixes) modifying kyo-ffi/plugin.

kyo-ffi/plugin/src/main · medium confidence · unverified

Removals

Removal of legacy effect system components

The \aborts\, \arrows\, \batches\, \core\, \envs\, \futures\, \ios\, \lists\, \options\, and \tries\ modules have been removed from \kyo-core\. This eliminates the previous effect encoding and handler implementations, signaling a migration to a new effect system architecture.

kyo-core/src/main · high confidence

Architecture

Introduce internal transport abstraction layer for HTTP networking

This change introduces a new internal transport module (\kyo.internal.transport\) that abstracts raw network connections into a unified streaming interface. It adds a \TransportStream\ trait to decouple protocol layers (like WebSocket) from specific transport implementations, and provides \ConnectionBackedStream\ to adapt raw connection channels for reading and writing while silently handling expected connection closures. Additionally, it includes \NetConfigTranslation\ to map HTTP-specific configuration (TLS, addresses, transport settings) to the underlying \kyo-net\ types, ensuring that HTTP public APIs remain independent of the lower-level network library's internal types.

kyo-http/shared/src/main/scala/kyo/internal/transport · high confidence

Behavioural changes

7 commits (0 fixes) modifying kyo-compat/plugin/src/main

A change to existing behaviour in kyo-compat/plugin/src/main — 7 commits, 4 files: “\[kyo-compat\] publish kyo-compat-plugin for sbt 2 (\#2198)”; “\[kyo-compat\] let backends be maintained outside the repo (\#1840)”; “\[compat\] seamless cross-stack libraries (\#1627)”; and 4 more (refs \#2198, \#1840, \#1627, \#1957, \#1720, …).

kyo-compat/plugin/src/main · medium confidence · unverified

8 commits (0 fixes) modifying kyo-caliban/src/main

A change to existing behaviour in kyo-caliban/src/main — 8 commits, 1 file: “new encoding for zio and cats-effect integrations (\#711)”; “move original sources to their new position to preserve git history”; “\[schema\] introduce module (\#1517)”; and 5 more (refs \#711, \#1517, \#1490, \#589, \#1148, …).

kyo-caliban/src/main · medium confidence · unverified

Added Scala 3-specific equality instances and compile-time flag support

This change introduces Scala 3-specific implementations for the configuration module. It adds \CanEqual\ instances for sealed hierarchies (\Flag.Source\, \Flag.ReloadResult\, \Rollout.Selector\, \DynamicFlag.HistoryEntry\) to support Scala 3's strict equality checks. Additionally, it adds a new \CompileTimeFlag\ object that resolves boolean flags at compile time via macros, inlining the result as a constant and enforcing stricter validation (failing the build if the value is not explicitly \true\ or \false\) compared to runtime flag reading.

kyo-config/shared/src/main/scala-3 · high confidence

Async logging enabled by default with platform-specific backend support

Logging is now asynchronous by default on JVM and Native platforms, using a background daemon to handle event dispatching and ensuring logs are flushed on shutdown. This change introduces platform-specific implementations for async logging, standard input reading, and KyoApp execution, while also adding support for converting Java CompletableFuture and CompletionStage instances into Kyo async computations.

kyo-core/jvm-native/src/main/scala/kyo/internal · high confidence

Automatic browser process cleanup on host runtime exit

The kyo-browser module now ensures that Chrome processes launched by the application are forcibly terminated if the host runtime exits unexpectedly (e.g., via System.exit or abrupt sbt termination). A new platform-specific shutdown hook registers a daemon-free thread that checks for and destroys any still-alive Chrome process upon JVM shutdown, preventing orphaned browser instances.

kyo-browser/jvm-native · high confidence

Cross-platform WHATWG-compliant charset decoding

The kyo-charset library now implements charset decoding for Big5, EUC-JP, EUC-KR, GB18030/GBK, HZ-GB-2312, ISO-2022-JP, ISO-2022-KR, Shift\_JIS, UTF-7, UTF-16, UTF-32, and various single-byte encodings (such as Windows-1252 and ISO-8859 series) using the WHATWG Encoding Standard algorithms. This replaces platform-dependent native decoders with a shared, deterministic implementation that ensures consistent character mapping and error handling (including proper replacement character insertion for ill-formed sequences) across all supported platforms.

kyo-charset/shared · high confidence

Docs site migrated from Docsify to a Scala-based static site generator with SPA hydration

The documentation site has been rebuilt using a new Scala-based static site generator (SSG) and single-page application (SPA) architecture, replacing the previous Docsify setup. This change introduces a JVM-only build-time renderer that converts Markdown into a structured UI tree with syntax highlighting and copy-to-clipboard support for code blocks. The generator emits pre-rendered HTML for SEO and initial load, while embedding JSON boot schemas to hydrate interactive features like version selection and client-side navigation. Intra-repo file links are now automatically rewritten to absolute GitHub URLs to prevent 404s. The legacy Docsify assets and the old scaladoc commit workflow have been removed, and the deployment pipeline now uses a forward-only render from the current repository state.

kyo-website/jvm · high confidence

Enables runtime SQL backend discovery on Scala.js, Wasm, and Native

Users can now reliably discover and use MySQL and Postgres backends in Scala.js, WebAssembly, and Scala Native environments. Previously, the standard Java service-provider mechanism did not work at runtime for these platforms; this change adds explicit registration entry points (\\_\_kyo\_sql\_mysql\init\, \\\_kyo\_sql\_postgres\_init\) for JS/Wasm and a platform-specific registration trait for Native, ensuring that backend factories are registered and discoverable via \SqlBackendDiscovery\ without requiring manual wiring.

kyo-sql-mysql/js-wasm, kyo-sql-postgres/js-wasm, kyo-sql/native · high confidence

HTTP server routing and dispatch rewritten for zero-allocation performance and security hardening

The internal HTTP server implementation has been replaced with a new, high-performance architecture. The new \HttpRouter\ uses a flat-array prefix trie for cache-friendly, zero-allocation path matching, allowing multiple routes with different capture codecs to coexist at the same trie node by chaining candidates. Route lookup results are now handled by a reusable, connection-scoped \RouteLookup\ object that records segment indices instead of allocating dictionaries, deferring decoding until after a match is found. The dispatch layer (\UnsafeServerDispatch\) now uses a parser-driven model that bridges safely to Kyo fibers, handling keep-alive idle timeouts, host header validation, and connection closure watchers to prevent handler leaks. Additionally, the server is hardened against HTTP/1.1 smuggling attacks by enforcing strict body consumption rules before reusing connections for keep-alive requests. Also in this area: 2 commits (0 fixes) modifying kyo-http/shared; HTTP configuration validation and error handling improvements.

kyo-http/shared/src/main/scala/kyo/internal/server · medium confidence · unverified

Internal refactoring of Reducible mechanism

The internal implementation of the Reducible mechanism, which handles the safe elimination or transformation of effects, has been moved to the kyo.internal package. This change introduces a LowPriorityReducibles trait to manage default instances for irreducible effects and consolidates the Reducible type definitions and associated given instances within the internal package structure.

kyo-prelude/shared/src/main/scala/kyo/internal · high confidence

Introduce Arrow-based effect system with explicit region management

The kernel has been rewritten to use an explicit region stack and fused arrows for effect handling. This introduces new core abstractions: \Arrow\ for composable, JIT-fused transformations; \ArrowEffect\ for operations with handler-provided continuations (supporting multi-shot continuations for backtracking); and \ContextEffect\ for dynamically scoped values with configurable inheritance across forks. Resource safety is now handled via \Bracket\, which guarantees exactly-once release tied to region scope, and \Isolate\ provides a unified mechanism for managing state capture, isolation, and restoration when forking computations.

kyo-kernel/shared/src/main/scala/kyo/kernel · high confidence

Introduce blocking and callback-retention safety checks in FFI code generation

The FFI code generator now validates binding traits against allowlists of known POSIX symbols that block the calling thread (e.g., \read\, \sleep\, \pthread\_join\) or retain callback pointers beyond the call (e.g., \epoll\_ctl\, \pthread\_create\). If a method resolves to one of these symbols but lacks the required \@Ffi.blocking\ annotation or \Ffi.Guard\ parameter, the build emits a warning (or throws in strict mode), helping prevent silent deadlocks or dangling callbacks. This adds a new layer of safety to the codegen pipeline without changing the generated runtime behavior for valid bindings.

kyo-ffi/codegen/src/main · high confidence

Introduce new zero-allocation HTTP/1.1 parser and chunked body decoder

The HTTP/1.1 transport layer now uses a completely rewritten, zero-allocation parser and a dedicated chunked body decoder. The new \Http1Parser\ and \Http1ResponseParser\ use a callback-driven state machine with reusable buffers to parse requests and responses without allocating intermediate objects. The \ChunkedBodyDecoder\ handles HTTP/1.1 chunked transfer encoding, supporting both buffered and streaming modes, and includes safeguards against unbounded memory growth (CWE-400) by capping accumulated body sizes. The \HeaderTokens\ module ensures strict, whole-token matching for HTTP field values to prevent request smuggling vulnerabilities. These components are integrated into \Http1ClientConnection\ and \Http1StreamContext\ to handle connection lifecycle, request/response serialization, and body reading with improved performance and security.

kyo-http/shared/src/main/scala/kyo/internal/http1 · high confidence

Introduce reproducible doctest caching and isolated runtime execution

The JVM doctest engine now uses a stable SHA-256 fingerprint of the classpath (based on TASTy and Java bytecode) to invalidate its cache only when source content actually changes, preventing stale results from being reused after clean builds. Runtime expectations are executed in a separate child process with a child-first classloader to isolate test execution from the runner's application classpath, and per-README default modifiers can now be configured via HTML comments at the top of the file.

kyo-doctest/jvm/src/main · high confidence

Introduces runtime ABI and version checks for FFI bindings

The kyo-ffi runtime now validates compatibility before loading native libraries. It enforces a monotone ABI version to catch binary-incompatible changes between generated code and the runtime, and checks a minimum runtime version declared in the native library's manifest to prevent running on older, unsupported runtimes. These checks surface as catchable \FfiLoadError.AbiMismatch\ errors instead of crashes. Additionally, the internal buffer lifecycle and guard teardown logic have been refactored to use atomic state machines, ensuring thread-safe cleanup and preventing memory leaks or use-after-free issues during concurrent callback invocations.

kyo-ffi/shared/src/main/scala/kyo/ffi/internal · high confidence

Introduces structured error handling and low-level binary decoders for TASTy and classfile parsing

The kyo-tasty/shared module now uses a closed \TastyError\ ADT to surface all failure paths (such as file corruption, format mismatches, or missing symbols) as structured \Abort\ values instead of throwing exceptions, enabling exhaustive pattern matching by callers. This change also adds the underlying binary decoding infrastructure required for this parsing, including big-endian LEB128 varint readers/writers, UTF-8 decoding, JVM classfile constant pool handling, Java annotation unpickling, and module-info.class reading.

kyo-tasty/shared · high confidence

JS/WASM kernel introduces safepoint-based slice deadlines using monotonic time

The JS/WASM target now includes a new internal kernel implementation that manages execution slices via a safepoint mechanism. This adds a \Report\ object for unhandled exceptions and a \Safepoint\ system that tracks slice budgets and deadlines. Crucially, slice expiration is now judged against monotonic time (\System.nanoTime\) rather than wall-clock time, ensuring that system clock changes do not incorrectly expire or extend active slices. Tests confirm that this monotonic approach prevents wall-clock steps from affecting slice validity.

kyo-kernel/js-wasm · high confidence

JVM Tasty query engine now uses memory-mapped JARs for faster, lower-memory classpath loading

The JVM implementation of the Tasty query engine has been replaced with a custom, memory-mapped JAR reader that bypasses the standard \java.util.jar.JarFile\ API. By parsing the ZIP central directory directly via \RandomAccessFile\ and memory-mapping the JAR content with \MappedByteBuffer\, the engine avoids per-entry object allocations and reduces memory pressure. This change introduces a thread-safe reader pool (\JarMappedReaderPool\) scoped to the classpath load operation, allowing concurrent fibers to read entries from the same JAR efficiently. It also adds support for reading JDK module descriptors from the \jrt:/\ virtual filesystem and includes a file-descriptor semaphore to prevent exhaustion when opening many snapshots. These changes improve startup performance and stability for applications relying on Tasty reflection.

kyo-tasty/jvm · high confidence

JVM platform-specific filesystem and process internals

This change introduces JVM-specific platform adapters for the kyo-system filesystem and process APIs, including atomic file moves, exclusive file creation, and child process spawning. It also adds JVM-only tests to verify correct handling of symbolic links, file locking with alias resolution, stdin feed lifecycle management, and path watching behavior.

kyo-system/jvm · high confidence

JVM-specific internal platform utilities and unsafe buffer implementation

This change introduces JVM-specific internal implementations for the Kyo data layer, including a new \Platform\ object that defines JVM constants (such as \maxStackDepth\ set to 256), OS detection logic, and execution context defaults. It also adds \EmptyArrays\ for efficient, garbage-collection-friendly zero-length array caching using \ClassValue\, and implements \JvmUnsafeBuffer\ and \UnsafeBufferPlatform\ to provide high-performance, allocation-free memory management backed by Java Foreign Memory API (\MemorySegment\) and file mapping capabilities.

kyo-data/jvm/src/main · high confidence

Major build infrastructure overhaul with new code generation and test tooling

The build system has been significantly upgraded, including a jump in sbt from version 1.6.2 to 1.13.0 and a comprehensive update to plugins such as sbt-scalafmt, sbt-scalajs, and sbt-scala-native. This change introduces several new in-build tools: \CallbackShapesGen\ automates the generation of Scala Native callback registry code, \ClassNameCheck\ prevents duplicate class name collisions across projects, and \TestVariant\ enables code generation for test variants via annotations. Additionally, a new \testKyo\ command unifies test execution across platforms and Scala versions, while \WasmPlatform\ adds support for the WebAssembly backend. The legacy \metals.sbt\ file has been removed.

project · high confidence

Native scheduler gains reliability fixes and platform-specific utilities

The Scala Native scheduler implementation now includes robustness and platform-specific support. A new HandoffRetryExecutor shields the scheduler from lost or refused thread submissions by tracking and retrying them via a watchdog, ensuring tasks run exactly once even if the underlying pool fails. WorkerExecutors serialize thread creation through an init gate to prevent heap corruption caused by a Scala Native GC race. Platform-specific utilities have been added: ThreadUserTime queries per-thread CPU time on macOS and Linux for blocking detection, Sleep uses nanosleep on Unix to avoid file descriptor contention, and LoomSupport provides a no-op virtualization stub.

kyo-scheduler/native · high confidence

New internal kernel infrastructure for effect evaluation and type safety

The \kyo.kernel.internal\ package has been restructured with new core components that define the runtime behavior of the effect system. \CanLift\ and \Implicits\ introduce a compile-time constraint that prevents accidental nesting of effect computations and rejects lifting of module objects, providing clearer error messages when type inference produces nested effects. The \Eval\ object implements the main evaluation loop that unfolds suspended computations, while \Handler\ defines the region-based structures for intercepting and answering effects. \PendingInternal\ and \Nested\ manage the representation of suspended computations and their wrapping, and \Stack\ handles the region stack for context effects. Additionally, \Debugger\ and \EffectTrace\ provide hooks for tracing execution and reconstructing meaningful stack traces for failures.

kyo-kernel/shared/src/main/scala/kyo/kernel/internal · high confidence

New kernel implementation with explicit region stack and fused arrows

The kernel has been replaced with a new implementation that introduces an explicit region stack and fused arrows for effect handling. This change includes a new \Safepoint\ mechanism for managing thread-local budgets and preemption, a \Report\ utility for uncaught exception handling, and updated threading tests to verify correct behavior across threads, including context inheritance and effect tracing.

kyo-kernel/jvm, kyo-kernel/jvm-native · high confidence

Optimized scheduler state updates using JVM VarHandles

The JVM scheduler implementation now uses java.lang.invoke.VarHandle for atomic state updates in IOPromise and IOTask. This platform-specific optimization replaces previous allocation-heavy mechanisms (such as AtomicReference) with direct memory access, reducing garbage collection pressure and improving performance for internal scheduler operations.

kyo-core/jvm/src/main/scala/kyo/scheduler · high confidence

Pinned and cross-platform build of BoringSSL for kyo-net

The build system now clones and compiles a specific pinned revision of BoringSSL (commit d84317af) from a GitHub mirror to ensure reliable CI execution. The new \build-boringssl.sh\ script supports cross-platform builds for Linux (x86\_64, aarch64, musl variants) and macOS (x86\_64, aarch64), producing static libraries (\libssl.a\, \libcrypto.a\) and headers staged per OS-architecture. This change ensures that the native network transport module links against correctly architected native libraries, preventing runtime issues on mixed-architecture environments.

kyo-net/build · high confidence

Refactored JSON-RPC engine internals to fix race conditions and improve reliability

The internal JSON-RPC engine components (CallEngine, CancellationEngine, LifecycleEngine, ProgressEngine, RateLimitEngine) have been rewritten to address concurrency issues. Key changes include fixing a race condition where a close operation could leak a raw Closed error to pending calls by ensuring the caller registry is drained before the transport closes, and ensuring that timeouts and cancellations deterministically fail calls even if a reply arrives late. The engine now uses monotonic time for deadline checks to prevent issues with wall-clock adjustments, and serializes progress emissions to guarantee monotonicity on the wire.

kyo-jsonrpc/shared/src/main/scala/kyo/internal/engine · high confidence

Scheduler configuration flags and task preemption/runtime tracking

The scheduler now exposes configurable static flags for tuning worker counts, scheduling strides, time-slice duration (default 10ms), and top-status reporting intervals, allowing users to adjust performance characteristics. Internally, the Task implementation has been refactored to use a bit-packed state for tracking accumulated runtime and preemption status, ensuring that interrupted fibers are prioritized correctly by resetting their runtime to zero. This change also introduces a mechanism to reliably detect and report fiber leaks by attaching kyo traces to interrupted tasks, improving diagnostic visibility when fibers are not properly released.

kyo-scheduler/shared · high confidence

Support environment variable resolution in Scala.js/Wasm environments

Environment-backed configuration flags and rollout settings now correctly resolve their values in Scala.js and WebAssembly targets. Previously, \java.lang.System.getenv\ returned null in these environments, causing flags to fail to detect their source or resolve to incorrect defaults. This change introduces a platform-specific resolver that safely accesses the Node.js \process.env\ object when available, while gracefully falling back to the standard library or returning null in browser-like environments without a \process\ global, ensuring consistent behavior across JVM and non-JVM runtimes.

kyo-config/js-wasm · high confidence

Fixes

Fixes crash on Scala Native when hashing zero-hash strings

The kyo-config library now avoids a runtime crash on Scala Native when computing the hash of strings whose JLS hash value is zero (such as the null character). Previously, Scala Native's \String.hashCode\ attempted to memoize the result by writing to a read-only memory section, causing a store fault (SIGBUS/SIGSEGV). The updated platform-specific implementation for Native computes the hash manually without storing the result, ensuring stability at the cost of slightly higher CPU usage for these specific strings.

kyo-config/jvm, kyo-config/native · high confidence

Test coverage

1 commit adding/updating tests in kyo-lsp/jvm; Add golden snapshot testing for generated samples; Added FlowStore conformance test suite; Added HTTP demo applications and test service registrations; Added JS-specific network transport tests; Added JVM and Native platform-specific parse tests; Added JVM tests for WHATWG charset decoder differences against the JDK; Added JVM-specific TLS introspection and NIO engine-gate tests; Added JVM-specific and monad law tests for the kyo prelude; Added JVM-specific serialization tests for STM TRef; Added JVM-specific test infrastructure for HTTP client; Added JVM-specific test infrastructure for allocation probing and reflection; Added JVM-specific tests for Browser.runShared; Added JVM-specific tests for Gate race conditions and Stream compression; Added JVM-specific tests for OpenAPI class loading and HTTP server resilience; Added JVM-specific tests for browser launcher cleanup and CDP backend resilience; Added JVM-specific tests for tag class loading, Span allocation, and Glob macro bytecode; Added JVM-specific tests for the kyo-stats-machine module; Added JavaScript-specific parse tests; Added Kyo-ZIO test integration and test suite; Added MCP demo servers and integration tests for reverse-direction, long-running, and typed interactions; Added Node.js file I/O support for snapshot tests in WebAssembly environments; Added browser automation test fixtures and demo applications; Added comprehensive test coverage for kyo-config flags and rollouts; Added comprehensive test coverage for kyo-jsonrpc core components; Added comprehensive test coverage for schema codecs, builders, and Protobuf integration; Added comprehensive test suite for kyo-aeron bindings and transport behavior; Added comprehensive test suite for kyo-compat bindings; Added comprehensive test suites for kyo-prelude effects; Added comprehensive test suites for the Kyo kernel; Added comprehensive tests for kyo-net transport reliability and correctness; Added concurrency and ownership tests for the internal network stack; Added cross-platform test coverage for kyo-ffi core components; Added cross-platform validation tests for kyo-crypto; Added flamegraph profiling data for the HTTP server demo; Added golden-file tests for kyo-ffi code generation across JS, JVM, and Native targets; Added integration tests for the Kyo-Caliban GraphQL module; Added placeholder for JVM-Native FFI integration tests; Added platform-specific tests for Native SecureRandom; Added regression tests for MIME message parsing differences; Added sbt plugins for Scala.js and Scala Native test support; Added scripted tests for kyo-doctest plugin capabilities; Added test coverage for Actor, PubSub, and Subject components; Added test coverage for kyo-combinators; Added test coverage for kyo-core effects; Added test coverage for kyo-data utilities and data structures; Added test coverage for kyo-doctest corpus, parser, and runtime behavior; Added test harness for JS/WASM network backends; Added test infrastructure for SQL backend registration on JS/Wasm and Native platforms; Added test infrastructure for Scala Native support; Added test infrastructure for WebAssembly support; Added test infrastructure for container lifecycle management; Added test infrastructure for kyo-pod on Scala.js/WebAssembly; Added test suite for the kyo-parse module; Added test support for platform-specific SQLite VFS naming; Added tests and demo applications for the kyo-compiler presentation compiler; Added tests and demo programs for the kyo-ai module; Added tests for Async interop on Native platforms; Added tests for CStream compatibility layer; Added tests for IOPromise blocking behavior and scheduler diagnostics; Added tests for JS and Wasm TASTy classpath loading; Added tests for JS/Wasm network driver reliability and TLS configuration; Added tests for JSON-RPC over HTTP WebSocket transport; Added tests for JVM-specific JSON writer behavior; Added tests for Node.js-specific filesystem and locking behaviors; Added tests for OS signal handling; Added tests for SQL backend neutrality and out-of-tree backend SPI; Added tests for Zippable combinators; Added tests for compile-time flag resolution behavior; Added tests for core concurrency and resource-safety primitives; Added tests for fatal throwable handling in fibers; Added tests for internal Kyo utilities and concurrent queues; Added tests for locale-independent JSON-RPC error messages; Added tests for monotonic time handling and Unix domain socket transport errors; Added tests for platform detection and unsafe buffer operations; Added tests for reactive-streams interop flow components; Added tests for the kyo-offheap Memory API; Added tests for the sbt-publish plugin and its cross-platform integration; Added tests for weak-reference hierarchy and ThreadLocal behavior in JVM-Native stats registry; Added tests to ensure DoltLite bindings match SQLite bindings; Added unit tests for internal network utilities; Added unit tests for the Kyo FFI SBT plugin; Expanded JVM-specific test coverage for kyo-ffi; Expanded scripted tests for kyo-compat plugin; Expanded test coverage for Kyo Flow engine durability, lifecycle, and subflows; Expanded test coverage for the \direct\ macro; Integration test suite for kyo-ffi cross-platform bindings; Integration tests for kyo-ffi cross-platform bindings; Introduce kyo-test V3 API with new assertion, reporting, and configuration primitives; JVM FFI integration tests for load failures and concurrency; JavaScript FFI integration tests for library loading and blocking metering; Native integration test scaffolding for struct bindings; New sbt-test suite for kyo-ffi plugin capabilities; Published conformance test suites for FlowStore and FileSystem backends; Removed Cats and ZIO monad law tests; SQL conformance test suite published as a shared artifact; Scripted tests for the kyo-compat sbt plugin.

Housekeeping

Repository configuration and contributor guidelines; kyo-ffi module documentation and integration test scaffolding.

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 42 → 41 (-0.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 19 → 19 (-0.3)
  • Architecture 91 → 91 (+0.0)
  • Maturity 72 → 74 (+1.6)
  • Readiness 51 → 50 (-0.5)
  • Security 63 → 58 (-5.3)
  • Performance 84 → 100 (+16.4)

Resolved (82)

  • DerReader.readLength (cognitive 19) (kyo-crypto/shared/src/main/scala/kyo/crypto/Rsa.scala)
  • Duplicated block (10 lines × 2) (kyo-http/shared/src/main/scala/kyo/internal/codec/OpenApiGenerator.scala)
  • Duplicated block (10 lines × 3) (kyo-ffi/codegen/src/main/scala/kyo/ffi/codegen/emitters/JsEmitter.scala)
  • Duplicated block (11 lines × 2) (kyo-discord/shared/src/main/scala/kyo/DiscordException.scala)
  • Duplicated block (11 lines × 2) (kyo-sql/shared/src/main/scala/kyo/internal/FromExprDerived.scala)
  • Duplicated block (11 lines × 2) (kyo-ui/shared/src/main/scala/kyo/internal/ChartMarks.scala)
  • Duplicated block (11 lines × 2) (kyo-ui/shared/src/main/scala/kyo/internal/ChartTransitions.scala)
  • Duplicated block (11 lines × 3) (kyo-kernel/shared/src/main/scala/kyo/kernel/ArrowEffect.scala)
  • Duplicated block (12 lines × 2) (kyo-kernel/shared/src/main/scala/kyo/kernel/internal/Handler.scala)
  • Duplicated block (12 lines × 2) (kyo-markdown/shared/src/main/scala/kyo/Markdown.scala)
  • Duplicated block (12 lines × 2) (kyo-system/js-wasm/src/main/scala/kyo/internal/ProcessPlatformSpecific.scala)
  • Duplicated block (13 lines × 2) (kyo-markdown/shared/src/main/scala/kyo/Markdown.scala)
  • Duplicated block (14–16 lines × 5) (kyo-ffi/codegen/src/main/scala/kyo/ffi/codegen/emitters/JsEmitter.scala)
  • Duplicated block (15 lines × 2) (kyo-schema/shared/src/main/scala/kyo/internal/FocusMacro.scala)
  • Duplicated block (17–18 lines × 2) (kyo-ffi/codegen/src/main/scala/kyo/ffi/codegen/emitters/JvmEmitter.scala)
  • Duplicated block (18 lines × 2) (kyo-stats-otlp/shared/src/main/scala/kyo/stats/otlp/OTLPMetricsExporter.scala)
  • Duplicated block (19 lines × 2) (kyo-flow/shared/src/main/scala/kyo/internal/FlowRender.scala)
  • Duplicated block (20–22 lines × 3) (kyo-ffi/codegen/src/main/scala/kyo/ffi/codegen/emitters/JsEmitter.scala)
  • Duplicated block (25–26 lines × 2) (kyo-http/shared/src/main/scala/kyo/internal/client/HttpClientBackend.scala)
  • Duplicated block (32–39 lines × 2) (kyo-tasty/shared/src/main/scala/kyo/internal/tasty/snapshot/SnapshotReader.scala)
  • …and 62 more

New (558)

  • DerReader.readLength (cognitive 19) (kyo-crypto/shared/src/main/scala/kyo/internal/crypto/DerReader.scala)
  • DomReactiveRegions.replaceContent (cognitive 17) (kyo-ui/js-wasm/src/main/scala/kyo/internal/DomReactiveRegions.scala)
  • DomReactiveRegions.replaceContent (cyclomatic 17) (kyo-ui/js-wasm/src/main/scala/kyo/internal/DomReactiveRegions.scala)
  • Duplicated block (10 lines × 2) (kyo-pod/shared/src/main/scala/kyo/internal/HttpContainerBackend.scala)
  • Duplicated block (12 lines × 2) (kyo-markdown/shared/src/main/scala/kyo/Markdown.scala)
  • Duplicated block (5 lines × 2) (kyo-core/shared/src/main/scala/kyo/Stat.scala)
  • Duplicated block (5 lines × 2) (kyo-slack/shared/src/main/scala/kyo/SlackConfig.scala)
  • Duplicated block (7–8 lines × 2) (kyo-markdown/shared/src/main/scala/kyo/Markdown.scala)
  • Duplicated block (8 lines × 2) (kyo-http/shared/src/main/scala/kyo/internal/client/HttpClientBackend.scala)
  • Edited copies of one member (3 members, 10+ corresponding lines) (kyo-discord/shared/src/main/scala/kyo/DiscordException.scala)
  • Edited copies of one member (3 members, 10+ corresponding lines) (kyo-kernel/jvm/src/jmh/scala/kyo/kernel/bench/KernelBench.scala)
  • Edited copies of one member (3 members, 10+ corresponding lines) (kyo-kernel/shared/src/main/scala/kyo/Kyo.scala)
  • Edited copies of one member (3 members, 10+ corresponding lines) (kyo-kernel/shared/src/main/scala/kyo/Kyo.scala)
  • Edited copies of one member (3 members, 10+ corresponding lines) (kyo-system/jvm-native/src/main/scala/kyo/internal/PathPlatformSpecific.scala)
  • Edited copies of one member (3 members, 10+ corresponding lines) (kyo-tasty/shared/src/main/scala/kyo/internal/tasty/reader/AstUnpickler.scala)
  • Edited copies of one member (3 members, 11+ corresponding lines) (kyo-discord/shared/src/main/scala/kyo/internal/discord/Rest.scala)
  • Edited copies of one member (3 members, 11+ corresponding lines) (kyo-schema-yaml/shared/src/main/scala/kyo/internal/yaml/YamlReader.scala)
  • Edited copies of one member (3 members, 13+ corresponding lines) (kyo-compat/bindings/future/shared/src/main/scala/kyo/compat/CIO.scala)
  • Edited copies of one member (3 members, 13+ corresponding lines) (kyo-schema-yaml/shared/src/main/scala/kyo/internal/yaml/YamlCstEdits.scala)
  • Edited copies of one member (3 members, 14+ corresponding lines) (kyo-kernel/shared/src/main/scala/kyo/Kyo.scala)
  • …and 538 more

Changes since last survey

  • 48 commits — 44 feature/other, 4 fixes

By area

  • kyo-browser/shared — 4 commits
  • kyo-core/shared — 3 commits
  • kyo-discord/shared — 3 commits
  • kyo-ui/shared — 3 commits
  • .github/workflows — 2 commits
  • kyo-data/shared — 2 commits
  • kyo-http/shared — 2 commits
  • kyo-net/shared — 2 commits
  • kyo-pod/shared — 2 commits
  • kyo-schema-json/shared — 2 commits
  • (root) — 1 commit
  • kyo-compat/plugin — 1 commit
  • kyo-crypto/shared — 1 commit
  • kyo-ffi/plugin — 1 commit
  • kyo-jsonrpc/shared — 1 commit
  • kyo-kernel/shared — 1 commit
  • kyo-lsp/shared — 1 commit
  • kyo-markdown/shared — 1 commit
  • kyo-mcp/shared — 1 commit
  • kyo-mime/shared — 1 commit

Notable commits

  • fix: Revert "[kyo-discord] preserve handler failures across receive races" (#2218)
  • fix: [kyo-net] Make the SQ-full close regression deterministic (#2254)
  • fix: [kyo-net] expose address resolution and fix macOS socket layouts (#2221)
  • fix: [kyo-test] fix argument failures, freeze detection, and assertion reports (#2217)
  • change: Bump coursier/setup-action from 3.0.4 to 3.1.0 (#2212)
  • change: [build] Make the website relink task dependency explicit (#2256)
  • change: [ci] Pause automatic main snapshot releases
  • change: [ci] build Darwin release natives on macOS 15 (#2216)
  • change: [ci] dependency fetches survive a multi-minute Maven Central 404 burst (#2195)
  • change: [ci] the build passes on the Ubuntu 26.04 runner images (#2204)
  • change: [kyo-browser] Await hold-still sampling intervals (#2261)
  • change: [kyo-browser] fill editable text through native input (#2265)
  • change: [kyo-browser] keep discovery text valid and report decode problems (#2263)
  • change: [kyo-browser] preserve console primitives and thrown values (#2262)
  • change: [kyo-compat] publish kyo-compat-plugin for sbt 2 (#2198)
  • change: [kyo-core] Test peeled remainders after scope closure (#2244)
  • change: [kyo-core] mapPar interrupts every element fiber when its consumer is interrupted (#2205)
  • change: [kyo-core] preserve interrupt causes in finalizers (#2226)
  • change: [kyo-crypto] Share RSA key parsing and signature encoding (#2231)
  • change: [kyo-data] add method records, UUID.V7 and plain error text (#2220)
  • …and 28 more

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 0 removed · edges 1 added · 2 removed

Added dependency edges (1)

  • structs-end-to-end → repository

Removed dependency edges (was a dependency, now gone) (2)

  • repository → structs-end-to-end (coupling)
  • structs-end-to-end → repository (coupling)

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

Survey your own repository

getkyo/kyo 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 14 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 31a744565cdfd75a3a7bdbdbf8128f22808e6dd7 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — 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.65+preprod-e1a3b69fc8ee.