getkyo/kyo

Kyo is a high-performance, cross-platform effect system for Scala that enables structured concurrency and effectful programming across the JVM, Scala Native, Scala.js, and WebAssembly. It provides a comprehensive ecosystem of libraries for networking, serialization, database access, and AI integration, all unified by a type-safe effect abstraction that supports interoperability with existing runtimes like ZIO and Finagle. The system emphasizes safety and performance through features like off-heap memory management, adaptive scheduling, and rigorous cross-platform FFI support.

55 changes.

This period focused on replacing the legacy effect system with a new prelude-based architecture, introducing core primitives like Abort, Env, and Stream, while simultaneously overhauling the scheduler for improved concurrency, fairness, and platform support. The work established a robust foundation through extensive testing, performance benchmarking, and the addition of cross-platform capabilities including WebAssembly and Scala Native, alongside new modules for actors, STM, and interop with ZIO and Reactive Streams.

165 changes.

This period focused on extending Kyo to WebAssembly and Scala.js, introducing platform-specific schedulers, HTTP, and UI runtimes for browser environments. It also established a unified compatibility layer (kyo-compat) allowing libraries to target multiple backends like ZIO, Ox, and Future, while adding new modules for FFI, JSON-RPC, and AI integration.

The Ion schema module now includes a binary codec alongside the existing text format. Users can serialize and deserialize case classes to compact Ion Binary bytes using the new \IonBinary\ entry point (e.g., \IonBinary.encode\/\decode\) or by configuring the generic \Ion\ codec with \Ion.Config(format = Ion.Format.Binary)\. This change introduces the internal binary reader and writer implementations required to handle the Ion 1.0 binary wire format.

kyo-schema-ion/shared · high confidence

The \kyo-jsonrpc-http\ module introduces \JsonRpcHttpTransport\, enabling JSON-RPC communication over WebSocket connections using the \kyo-http\ library. This transport handles encoding and decoding of JSON-RPC envelopes to and from WebSocket text frames, while explicitly dropping binary frames and surfacing parse errors as malformed messages rather than failing the stream. It manages the WebSocket lifecycle via Kyo scopes, ensuring the connection is closed when the scope exits, and provides extension methods on \JsonRpcTransport\ for convenient instantiation.

kyo-jsonrpc-http · high confidence

This change introduces the \kyo-net/js-wasm\ module, providing a cross-platform network transport for Scala.js and Scala Native (Wasm). It includes a \JsIoDriver\ that leverages the Node.js event loop for I/O, a \NodeBackend\ that serves as the default floor, and a capability-probed registry (\IoBackendPlatform\) that allows higher-priority posix backends (io\_uring, epoll, kqueue) to run via koffi on compatible hosts, degrading to Node when posix syscalls are unavailable. The module also adds platform-specific TLS providers (\NodeTlsProvider\ and \BoringSslProvider\), Node.js module facades (\NodeBuiltins\), and a test harness (\TestBackends\) that exercises all available backends. Additionally, a shared \NetPlatformTransportBase\ is introduced for JVM/Native to unify process-lifetime transport construction.

kyo-net/jvm-native · high confidence

Introduces a custom Schema for the JSON-RPC 2.0 wire format in \kyo-jsonrpc\, enabling proper serialization and deserialization of request, notification, and response envelopes. The implementation supports two modes: \strict\, which enforces the \"jsonrpc":"2.0"\ version field and ignores extra fields, and \lenient\, which 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 allows the library to correctly handle the dynamic union of message types distinguished by field presence rather than a discriminator tag, bridging the typed envelope structure to the universal \Structure.Value\ format used for wire transport.

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

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

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

The JVM scheduler now exposes a JMX MBean (kyo.scheduler:type=Top) that publishes scheduler status, enabling external tools to monitor runtime metrics. A new CLI client connects to this JMX endpoint to fetch and display status updates, and a console utility provides a real-time, top-like view of the scheduler's state.

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

This change introduces platform-specific implementations for the JVM and Native targets, enabling the configuration system to read system properties and environment variables directly via \java.lang.System\. It also adds a concurrency test suite to verify that dynamic flag updates remain thread-safe and non-blocking under concurrent access, ensuring consistent reads during simultaneous updates.

kyo-config/jvm-native · high confidence

Users can now route Kyo's \Log\ effect through the standard Java Platform Logger (JPL) API via the new \JavaLog\ object. This integration allows applications to leverage existing JVM logging configurations, supporting runtime reconfiguration of log levels without restarting the application. Log messages are formatted with source call-site positions (e.g., \\[file:line\]\) and map Kyo's log levels to corresponding JPL levels, enabling seamless integration with tools like \java.util.logging\.

kyo-logging-jpl/jvm · high confidence

The kyo-scheduler now includes a new implementation for JavaScript and WebAssembly targets, enabling the scheduler to run in browser environments. This adds platform-specific components including a single-threaded Scheduler that defers tasks to the MacrotaskExecutor, an InternalClock for time management, a Coordinator stub, and utility classes for thread handling, allowing Kyo applications to execute on JS/WASM platforms.

kyo-scheduler/js-wasm · high confidence

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

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 non-deterministic search. The implementation includes a Board type with safety checks and a recursive solver that explores valid column placements, along with a main entry point that runs the solver for the 8-Queens case, prints each solution board, and counts the total number of solutions.

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

This change introduces the necessary JavaScript/Scala interop layer to support the WebAssembly backend for the HTTP module. It adds \NodeBuiltins.scala\, which provides typed facades for Node.js core modules (net, tls, fs, os, path, child\_process) using \@JSImport\ to ensure compatibility with ES modules. Additionally, it includes test infrastructure files (\HttpFilterTestRegistration\, \HttpTestPlatformBackend\, \TlsTestHelper\, \UnixSocketTestHelperImpl\) that enable HTTP client filter tests and TLS/Unix socket testing on the WASM platform by leveraging these Node.js built-ins.

kyo-http/js-wasm · high confidence

The \kyo-stats-otlp\ module now enables automatic export of application telemetry to an OTLP-compatible collector. When the \OTEL\_EXPORTER\_OTLP\_ENDPOINT\ environment variable is set, the module registers itself via service loaders to provide HTTP filters that inject and parse W3C Trace Context headers, and to create a trace exporter that buffers and flushes spans. It also starts background fibers to periodically collect and export metrics (counters, histograms, and gauges) from the global \StatsRegistry\. The implementation includes retry logic with exponential backoff, coalesced flushes to prevent queue corruption, and detailed error/rejection tracking.

kyo-stats-otlp/shared · high confidence

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

The \kyo-reactive-streams\ module now includes a new \interop.flow\ package that bridges Kyo's \Stream\ type with the Java \java.util.concurrent.Flow\ API. Users can convert an existing Java \Publisher\ into a Kyo \Stream\ using \fromPublisher\, or expose a Kyo \Stream\ as a Java \Publisher\ via \streamToPublisher\. The implementation introduces \StreamPublisher\ and \StreamSubscription\ to manage the lifecycle and backpressure, ensuring that subscriptions are properly scoped and cleaned up when the Kyo effect completes or is interrupted.

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

This change introduces platform-specific implementations of \SecureRandom\ for the Scala Native target, enabling cryptographically secure random number generation on native platforms. It adds a C shim (\kyo\_entropy.c\) to bridge to OS-specific entropy sources—\BCryptGenRandom\ on Windows and \/dev/urandom\/\/dev/random\ on POSIX systems—and provides a \java.security.SecureRandom\ shim to satisfy linkage requirements for \java.util.UUID.randomUUID\. The implementation includes platform-specific logic for handling entropy availability and signal handling, along with comprehensive tests for these native-specific behaviors.

kyo-core/native · high confidence

The kyo-test runner now supports Scala.js (and WebAssembly) targets. This change introduces a new \JsFramework\ that implements the \sbt.testing.Framework\ interface, allowing kyo-test suites to be discovered and executed via the standard sbt test-interface bridge. The implementation includes platform-specific adapters for reflective instantiation, CLI argument parsing, and task execution, ensuring that tests run correctly in the single-threaded JS environment (with parallelism capped to 1). It also provides stubs for unsupported features like JUnit XML reporting and thread dumps, ensuring the test runner compiles and behaves gracefully on JS/Wasm.

kyo-test/runner/js-wasm · high confidence

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 \CIO\ effect type backed by \com.twitter.util.Future\, along with bindings for core concurrency primitives including \CFiber\ (with interrupt handling), \CPromise\, \CLatch\, \CMeter\ (semaphores), \CChannel\ (bounded FIFO), \CLocal\ (fiber-local context), and \CStream\ (lazy streams). The bindings also include wrappers for JDK atomic types (\CAtomicBoolean\, \CAtomicInt\, \CAtomicLong\, \CAtomicRef\) and a bridge for \java.util.concurrent.CompletionStage\, enabling seamless integration with existing Twitter Future-based codebases.

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

This change introduces support for the WebAssembly target (via Scala.js) across several Kyo modules. It provides platform-specific implementations for core runtime behaviors: a no-op shutdown hook for the browser environment, a scheduler based on JavaScript timers for sleep/timeout operations, a trace pool optimized for the JS runtime, and explicit service registration for OTLP stats to replace Java's META-INF/services mechanism. These additions enable Kyo applications to run in WebAssembly-compatible environments.

(repo-wide) · high confidence

This change introduces new \ZIOs\, \ZLayers\, and \ZStreams\ modules in the \kyo-zio\ integration that allow seamless conversion between Kyo and ZIO types. Users can now lift ZIO effects (\ZIO\[R, E, A\]\) into Kyo effects via \ZIOs.get\ and run Kyo effects as ZIO tasks via \ZIOs.run\, with proper handling of interruptions and error mapping. Additionally, ZIO layers (\ZLayer\) can be lifted into Kyo layers (\ZLayers.get\) and vice versa, respecting resource scoping, and ZIO streams (\ZStream\) can be converted to and from Kyo \Stream\ types, supporting finite, infinite, and concurrent stream consumption patterns.

kyo-zio/shared · high confidence

The kyo-bench module now includes a suite of JMH benchmarks that measure Kyo's performance against ZIO, Cats Effect, and standard Scala collections. These benchmarks cover JSON encoding and decoding, Chunk operations, foreach iterations, type-tag comparisons, TypeMap usage, and various concurrency patterns such as blocking, flatMap depth, collection, and channel operations.

kyo-bench/src · high confidence

Introduces a new \kyo-i18n\ module providing cross-platform internationalization support. The module includes a \Locale\ type for handling language identifiers and an \I18n\ facade for managing translation bundles. Users can initialize translations via in-memory strings or file paths, switch the active locale reactively, and access translations through the \t\ and \now\ methods or the \i18n\ string interpolator. Missing keys are rendered with a visible marker rather than failing silently.

kyo-i18n/shared · high confidence

The kyo-stats-machine module now supports JavaScript and WebAssembly targets. This change introduces platform-specific implementations for disk execution and service registration, including a \DiskExecutor\ that runs inline on the single-threaded JS event loop and a \MachineRegistration\ object that registers the stats factory via \@JSExportTopLevel\ to bypass the absence of \META-INF/services\ classpath discovery. Tests are added to verify the registration side-effect and the correct wiring of the macOS FFI shim in the JS/Wasm test environment.

kyo-stats-machine/shared · high confidence

The \kyo-direct\ module now supports using \Result\, \Maybe\, \List\, and \Chunk\ types directly within \direct\ blocks. This is achieved by introducing internal \AsyncShift\ implementations that allow standard collection and effect operations (such as \map\, \flatMap\, \foreach\, \filter\, and \fold\) to work seamlessly with Kyo effects inside the macro-generated code.

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

A new TracePool implementation has been added for the native platform, providing a pool for Trace objects to optimize memory usage and performance. This includes a global pool using a ConcurrentLinkedQueue and a local pool mechanism within the Local abstract class, which manages borrowing and releasing traces with specific capacity limits.

kyo-kernel/native · high confidence

This change introduces platform-specific implementations for the \Platform\ object in the \kyo-data\ library, enabling support for JavaScript (Node.js) and WebAssembly runtimes. The new code provides OS detection capabilities (identifying Windows, macOS, Linux, and BSD variants) and sets a \maxStackDepth\ of 256 for both JS and WASM to ensure stack safety on these environments. Corresponding tests verify that OS family detection remains mutually exclusive and exhaustive on the respective runtimes.

kyo-data/js · high confidence

The scheduler now includes a 'top' monitoring feature that periodically reports internal status. A console sink prints a human-readable, delta-based table of worker states (running, blocked, stalled), load averages, and regulator metrics to stdout. A status-file sink writes a machine-readable, single-line summary (including worker counts, load, execution stats, and admission percentage) to a specified file path using an atomic write pattern to prevent partial reads. These sinks run on a dedicated background thread to avoid impacting scheduler performance and are disabled by default.

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

This change introduces new capabilities for JVM users: the \StreamCompression\ object adds extension methods (\deflate\, \inflate\, \gzip\, \gunzip\) to Kyo streams, allowing users to compress and decompress byte streams with configurable levels and strategies. Additionally, a new \SecureRandomPlatformSpecific\ trait provides a lazy, platform-specific implementation of secure random number generation using \java.security.SecureRandom\, improving security practices for cryptographic needs.

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

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

The kyo-test module now includes a property-based testing system (\kyo.test.prop\) that allows users to define properties using \forAll\ with generated samples. This system features deterministic shrinking to minimize failing counterexamples, replayable via fixed seeds (\forAllSeeded\), and supports automatic derivation of generators for case classes and sealed traits via macros. Additionally, golden snapshot testing capabilities have been added to verify generated samples against expected outputs.

kyo-test/prop/shared, kyo-test/snapshot/jvm-native, kyo-test/snapshot/shared · high confidence

A new \SchedulerDiagnostics\ component has been added to register a diagnostic dumper and probe for the shared kyo scheduler. This enables the \Diagnostics.dumpAll()\ mechanism to report detailed scheduler state—including worker status, execution counts, and busy fiber traces—when a hang or lost wakeup is detected, addressing the previous issue where such events went unreported due to missing scheduler context.

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

The scheduler now includes new utility classes in the \kyo.scheduler.util\ package to support internal operations and validation. \MovingStdDev\ provides a high-throughput, allocation-free calculator for rolling standard deviation and mean, suitable for scheduler instrumentation. \SelfCheck\ introduces a self-test utility that verifies scheduler behavior under load by incrementally increasing concurrency and monitoring rejection rates. \XSRandom\ offers a fast, thread-local xorshift-based pseudo-random number generator optimized for work-stealing and load-balancing tasks. Additionally, \Threads\ provides a factory for creating named daemon threads with disabled thread-local inheritance, which is required for correct operation on Scala Native.

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

This change introduces WebAssembly support for the kyo-data library by providing a complete set of platform-specific implementations for the JS/WASM target. It adds a JS-backed UnsafeBuffer using TypedArrays and DataView, including a workaround for 64-bit integer handling in Scala.js 1.x, and implements single-threaded queue variants (MPMC, MPSC, SPMC, SPSC) that replace complex atomic operations with simple ring buffers and ArrayDeques. Additionally, it introduces a memoized hash cache for Tag dispatch to eliminate repeated string hashing costs, significantly improving runtime performance for effect dispatch on the WebAssembly platform.

kyo-data/js-wasm · high confidence

The kyo-ui/js-wasm module now provides a complete client-side runtime for browser-based single-page applications. It introduces client-side routing via the History API (UILocation), which automatically intercepts same-origin anchor clicks to enable seamless navigation without full page reloads. Window-level reactive signals (UIWindow) expose viewport size, visibility, and OS color-scheme preferences, along with document-level event subscriptions for keyboard and mouse interactions. The UI also supports drag-and-drop operations (DomDragRuntime) with native browser integration and structured reactive HTML ranges (DomReactiveRegions) to ensure efficient, topology-preserving DOM updates for complex lists and tables. These capabilities are wired together through a new mount system (UIMount) and DOM backend (DomBackend) that handles event delegation, stylesheet injection, and lifecycle management.

kyo-ui/js-wasm · high confidence

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

The kyo-tasty library now supports Scala.js and Scala Native platforms in addition to the JVM. This change introduces platform-specific implementations for Tasty reflection and snapshot reading: JS and Native fallbacks handle the absence of the JVM boot classpath and \jrt:/\ filesystem by requiring explicit classpath binding and returning empty results for JDK module queries. JS-specific code degrades gracefully by disabling jar reading and using path-based hashing for digests, while Native adds POSIX memory-mapped file I/O (via \mmap\) and low-level file bindings to enable efficient snapshot reading. Test infrastructure is also ported to both platforms, allowing shared test suites to run against embedded fixtures on JS and Native.

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

This change adds the necessary platform-specific implementations to run Kyo on JavaScript and WebAssembly targets. It introduces a cryptographically secure random number generator that probes for \crypto.getRandomValues\ or the Node \crypto\ module, ensuring reliable entropy without silent fallbacks. Standard I/O is now supported via a synchronous line reader using Node's \fs.readSync\, fixing previous crashes when reading from stdin. The release also includes shims for JDK classes required by the Scala.js linker (such as \java.security.SecureRandom\, \java.util.ServiceLoader\, and \java.util.concurrent.atomic\ adders), stubs for unsupported concurrency primitives like \LockSupport\, and a timer-based scheduler for \ScheduledExecutorService\ that correctly handles large delays to prevent overflow issues in the host environment.

kyo-core/js-wasm · high confidence

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

The JVM module now includes out-of-the-box support for building with GraalVM native-image. This adds native-image configuration properties to enable shared arena support and native access, along with reachability metadata for required reflection types. The implementation introduces JVM-specific infrastructure including a native library loader with platform detection, a per-thread scratch allocator for transient marshalling, a guard system with leak detection, and upcall bridges to connect Scala functions to native code.

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

This change introduces the core Model Context Protocol (MCP) support for the Kyo framework, adding both server and client capabilities built on top of kyo-jsonrpc. The implementation includes a client-side handler system (\McpClientHandler\) for managing reverse-direction requests and notifications such as sampling, elicitation, and root listing. It defines strict opaque types for domain-specific strings, including \McpMimeType\ (with RFC 6838 validation), \McpResourceUri\ (with template extraction support), and \McpCursor\ for pagination. The module also provides hand-rolled JSON schemas for discriminated unions like \McpContent\ and \McpServer.SamplingContent\, ensuring type-safe serialization and deserialization of text, image, audio, and resource data. Internal components handle MCP-specific behaviors, including capability gating (\McpCapabilityGate\) to enforce advertised server features, cancellation policies (\McpCancellationPolicy\) aligned with the MCP spec, and a catalog (\McpCatalog\) to manage registered tool, resource, and prompt handlers.

kyo-mcp/shared · high confidence

Adds a new PostgreSQL database backend to the Kyo SQL library, enabling users to connect to and query PostgreSQL databases using the \postgres://\ and \postgresql://\ URL schemes. This change introduces the core protocol stack, including message marshalling and unmarshalling for the PostgreSQL wire protocol, support for both simple and extended query protocols, and readers for complex data types such as arrays and hstore. The backend is registered via the standard Java Service Provider Interface (SPI) mechanism, allowing it to be discovered and used automatically by the Kyo SQL client.

kyo-sql-postgres/shared · high confidence

The BSON codec is now available for encoding and decoding data structures. This change introduces the core reader and writer logic, including support for standard BSON types such as documents, arrays, strings, numbers, booleans, binary data, dates, and Decimal128. It also enforces BSON-specific constraints, such as requiring a top-level document, preserving field insertion order, and rejecting reserved element types and binary subtypes.

kyo-schema-bson/shared · high confidence

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 message processing runs on Kyo-managed threads rather than standard Java threads.

kyo-scheduler-pekko/jvm · high confidence

The kyo-aeron module now uses a C FFI shim (kyo\_aeron.c) to communicate with the Aeron client and embedded media driver, replacing the previous JVM-only implementation. This enables Aeron support on Scala Native, Scala.js, and Wasm, in addition to the JVM. The change introduces a new AeronClient API for managing scoped connections, implements async publication/subscription addition to keep fibers interruptible, and adds robust error handling for fatal conductor conditions without crashing the process. Resource lifecycle is managed via a global live-bundle registry and refcounting to prevent use-after-free errors during teardown.

kyo-aeron/shared · high confidence

This change adds the JavaScript/WebAssembly backend for the kyo-ffi library, enabling native FFI calls on JS platforms. It introduces an asynchronous dispatch mechanism for \@Ffi.blocking\ calls via koffi's libuv worker pool, complete with a process-global meter to apply backpressure and prevent pool exhaustion errors. The implementation includes a JS-specific buffer factory that uses \Uint8Array\ and a file-system-based mmap fallback, a native library loader that resolves libraries via environment variables, npm packages, or system paths, and runtime probes to validate koffi ABI compatibility and reject unsupported browser environments.

kyo-ffi/js-wasm · high confidence

The JVM platform now includes a non-blocking NIO transport (\NioTransport\) that serves as the floor backend when POSIX syscalls (io\_uring/epoll/kqueue) are unavailable or explicitly disabled via \-Dkyo.net.backend=nio\. This transport multiplexes TCP and TLS connections through a single \java.nio.channels.Selector\, handling plain TCP, TLS handshakes via the JDK \SSLEngine\, and process stdin/stdout bridging. It includes a custom \SelectedSelectionKeySet\ to reduce allocation overhead during selector polls, a dedicated \JdkSslEngine\ wrapper for TLS state management, and specific handling for TLS record coalescing and peer-close detection to ensure correct behavior on the NIO floor.

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

The JVM module now includes the internal implementation for the Scala 3 presentation compiler driver, enabling IDE-like features such as compilation diagnostics, completions, hover information, signature help, and symbol lookup. The system supports two execution modes: an in-process backend for version-matched configurations and a forked worker backend (using Aeron IPC) for isolated or mismatched toolchains. This change adds the necessary pool management, request/response serialization, and worker lifecycle handling to the JVM side of the compiler infrastructure.

kyo-compiler/jvm · high confidence

The new \KyoDoctestPlugin\ automatically validates Scala code blocks in Markdown files (defaulting to \README.md\) as part of the build. It provides \doctest\, \doctestFresh\, and \doctestClean\ commands, along with settings to customize sources, scalac options, parallelism, and a content-hash cache. The plugin is auto-enabled on JVM projects and includes scripted tests covering basic validation, caching, classpath handling, and failure scenarios.

kyo-doctest/plugin · high confidence

Adds a new MessagePack codec implementation for the Kyo schema system, enabling users to serialize and deserialize data using the MessagePack wire format. This includes a new \MsgPackFormat\ module defining protocol constants, alongside \MsgPackWriter\ and \MsgPackReader\ classes that handle encoding and decoding of primitives, collections, and complex types like UUIDs and BigInts.

kyo-schema-msgpack/shared · high confidence

A new \direct\ macro is introduced in the \kyo-direct\ module, allowing users to write effectful code blocks that are desugared into monadic composition. This feature adds \.now\ and \.later\ extension methods to effect types, enabling immediate sequencing of effects or their preservation for advanced composition within the block. The implementation includes macro hygiene fixes, validation of edge cases, and specific handling for opaque types to ensure correct compilation and error reporting.

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

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

The kyo-ffi/shared module now provides the core runtime for cross-platform native code bindings. This includes a typed off-heap Buffer class with explicit lifetime management, high-performance primitive accessors, and UTF-8 conversion utilities. It also introduces a structured error hierarchy (FfiLoadError, FfiErrno, FfiMalformedResult, etc.) and an ABI versioning system to ensure compatibility between generated code and the runtime, replacing previous ad-hoc error handling with catchable, diagnostic-rich exceptions.

kyo-ffi/shared · high confidence

Added the internal engine implementation for the new kyo-jsonrpc library, including CallEngine for managing outbound call lifecycle and concurrency, CancellationEngine for handling request cancellation and timeouts, DispatchEngine for routing incoming methods, IdStrategyEngine for generating request IDs, LifecycleEngine for managing connection close and resource cleanup, ProgressEngine for streaming progress notifications with monotonicity guarantees, and RateLimitEngine for controlling concurrent in-flight requests.

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

Adds the kyo-net module, providing a low-level network transport layer supporting TCP, Unix-domain sockets, stdio, and TLS across Linux, macOS/BSD, JVM, and JS/Wasm platforms. The module introduces a unified, unsafe-tier API (Transport, Connection, Listener) that abstracts over platform-specific I/O drivers (epoll, kqueue, io\_uring, NIO, Node.js) and TLS engines (BoringSSL, OpenSSL, JDK). It includes build infrastructure to clone and stage a pinned BoringSSL revision for native libraries, ensuring consistent TLS behavior and avoiding CI rate-limiting issues from upstream sources.

kyo-net · high confidence

The new \kyo-parse\ module provides a parser combinator effect for compositional text parsing, enabling the construction of sophisticated parsers for structured text processing, domain-specific languages, and configuration formats. The core \Parse\ effect supports incremental text consumption, backtracking, and a rich set of combinators including \firstOf\ for ordered alternatives, \attempt\ for error handling, and \peek\ for look-ahead. It includes pre-built parsers for common patterns like whitespace, numbers, and identifiers, along with execution modes such as \runResult\ and \runOrAbort\ to handle success and failure cases.

kyo-parse/shared · high confidence

Adds the kyo-pod module, providing a typed, non-blocking client for Docker and Podman with two interchangeable backends: an HTTP backend that speaks the Docker Engine API directly and a Shell backend that invokes the CLI as a subprocess. The module exposes a scope-bound lifecycle for containers (automatic cleanup on scope close), supports container operations such as exec, streaming logs, and health checks, and includes a dev Containerfile for reproducible rootless Podman testing.

kyo-pod · high confidence

This change adds the initial kyo-slack module, enabling Socket Mode connections with a robust reconnect strategy that prevents message loss during socket rotations. It introduces a typed error hierarchy (e.g., SlackHandshakeException, SlackRateLimitException) and opaque types for Slack identifiers (ChannelId, UserId, etc.) and tokens (AppLevel, Bot) to prevent misuse at compile time. The implementation includes a Socket Mode engine with overlap-based deduplication to ensure no envelopes are dropped when switching connections, along with demo applications and tests to validate the functionality.

kyo-slack/shared · high confidence

This change introduces the core infrastructure for kyo-sql's static SQL query system. It adds a typeclass-based schema system (SqlSchema) that derives column mappings for case classes and tuples at compile time, ensuring unsupported types fail at compile time rather than runtime. It includes a SqlNaming enum to control SQL identifier casing (e.g., snake\_case) and a @column annotation for explicit field renaming. The update also defines a portable SqlType vocabulary for CAST operations and introduces JsonText support for JSON columns. Additionally, it establishes the Backend abstraction for database engine discovery and connection management, along with the Connection interface for executing statements and managing transactions.

kyo-sql/shared · high confidence

The kyo-test runner has been replaced with a new V3 implementation that provides structured, extensible test reporting and improved diagnostics. Users can now choose from multiple output formats via the \--reporter\ flag, including a new TAP 13 reporter for CI integration and a fan-out \CombinedReporter\ that allows running multiple reporters (such as Console and JUnit XML) simultaneously. The runner now emits ScalaTest-compatible \\\\* FAILED \\\*\ markers on failure lines to maintain compatibility with existing log-parsing tools. Additionally, the new runner includes built-in hang detection: if a test leaf becomes unresponsive, the runner captures a one-shot thread dump and diagnostic snapshots to aid in root-causing the issue, while ensuring that cancelled leaves are correctly reported as skips rather than failures.

kyo-test/runner/shared · high confidence

This change adds a new MySQL database backend to the kyo-sql library, enabling users to connect to MySQL databases using the \mysql://\ URL scheme. The implementation includes a full wire-protocol client (\MysqlChannel\, \MysqlBufferReader/Writer\) that supports both simple text queries and parameterized binary queries. A key feature is the addition of \MysqlClient.loadLocalInfile\, which allows streaming bulk data loads via MySQL's \LOCAL INFILE\ protocol, a capability specific to MySQL and not available in the generic \SqlClient\. The backend registers itself via \META-INF/services\ and provides dedicated initialization methods (\MysqlClient.init\, \initWith\, etc.) for programs that require this specific functionality.

kyo-sql-mysql/shared · high confidence

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, read, write, and manage memory segments within scoped \Arena\ contexts, ensuring automatic resource cleanup and preventing leaks. The implementation leverages Kyo's effect system to track \Arena\ dependencies explicitly, while using \Layout\ type classes to maintain type safety for memory operations.

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

kyo-ui now includes a new charting layer that lowers a typed authoring spec into SVG, providing first-class support for bar, line, area, point, rule, text, and error bar marks with reactive updates, interactive legends, and WCAG-compliant color contrast. Additionally, a new \Sortable\ module provides pure, platform-agnostic semantics for keyed sortable collections, enabling declarative drag-and-drop moves, copies, and multi-select expansion across single or multiple collections.

kyo-ui/shared · high confidence

This change adds the \kyo-ai\ module, providing a first-class API for interacting with Large Language Models. It introduces \AI\ instances for managing conversation state (including persistent sessions and one-shot generations), \Mode\ for intercepting and transforming generations (e.g., for self-consistency sampling), and \Observe\ for tracking token usage and turn completion. The module supports typed generation with schema validation, streaming responses (both text and object-based), tool calling, and structured reasoning via \Thought\. It also includes command-backed completion harnesses for providers like Claude Code and Codex, along with strict JSON schema enforcement for structured outputs. Several demo applications are included to illustrate usage patterns such as conversation memory, tool use, and streaming.

kyo-ai/shared · high confidence

Adds new \LspClient\ and \LspServer\ modules in \kyo-lsp/shared\ that provide typed, Kyo-effect-managed handles for communicating with Language Server Protocol peers over JSON-RPC transports. The client exposes extension methods for standard LSP requests (completion, hover, definition, etc.) and manages the initialization handshake, while the server provides methods for sending notifications and requests to clients (show message, publish diagnostics, apply edits) and includes internal components like \LspCatalog\ for handler indexing and capability derivation, \LspGate\ for enforcing handshake and shutdown protocols, and \LspContentSchemas\ for handling LSP 3.17 wire formats.

kyo-lsp/shared · high confidence

This change adds a complete, Kyo-native HTTP stack to the \kyo-http\ module, replacing previous implementations. It introduces \HttpClient\ for making requests with connection pooling, retries, redirects, and typed request/response handling via \HttpRoute\. The \HttpServer\ component allows binding handlers to ports with automatic OpenAPI spec generation. The system features a composable \HttpFilter\ middleware system with compile-time field tracking for authentication (Basic/Bearer) and rate limiting, alongside a typed path DSL (\HttpPath\) and codecs (\HttpCodec\, \HttpFormCodec\) for parsing query parameters, headers, and form data. Support for Unix domain sockets is included via the \HttpAddress\ type.

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

Adds a new Software Transactional Memory (STM) effect to the library, providing optimistic concurrency control for shared state. The implementation includes TRef for transactional references, TMap for key-value stores with fine-grained locking to minimize contention, and TChunk for atomic sequence operations. Transactions execute speculatively and automatically retry on conflicts, supporting configurable retry schedules and nested transaction isolation. The change also introduces an internal CommitBuffer for efficient multi-reference commit protocols.

kyo-stm/shared · high confidence

This change establishes the foundational effect system for the Kyo library by adding new source files for key abstractions: Abort (typed failure handling), Check (validation), Choice (non-deterministic branching), Emit (push-based streaming), Env (dependency injection), Local (contextual values), Pipe (stream transformations), and Poll (pull-based streaming). It also introduces Aspect for intercepting behavior and defines the underlying ArrowEffect and ContextEffect mechanisms. These files provide the primitives for error handling, state management, and data flow that other parts of the library build upon.

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

Adds new internal server-side components for handling HTTP/1.1 requests: ResponseWriter for streaming response bodies, RouteLookup for zero-allocation route matching, StreamContext for per-connection request/response handling, and UnsafeServerDispatch for the parser-driven server logic. These files establish the foundation for the new HTTP server implementation, including support for keep-alive, idle timeouts, and connection management.

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

The kyo-schema module now provides a suite of compile-time safe primitives for working with case class schemas. Users can construct case classes incrementally with \Builder\, which enforces that all required fields are set at compile time before \.result\ is called. Structural navigation and mutation are handled by \Focus\ (lenses for get/set/update) and \Modify\ (batched, composable field mutations). Read-only structural comparison is available via \Compare\, which exposes field-level diffs. Additionally, \Convert\ enables type-safe, auto-derived conversions between compatible types. These primitives are supported by internal macros (\BuilderMacro\, \FocusMacro\, \ExpandMacro\) that analyze case class structures at compile time to ensure type safety and field existence.

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

The \Kyo\ companion object has been introduced to provide utility functions for working with Kyo effects, including sequential operations for collections, conditional execution (\when\, \unless\), and zipping multiple effects. Additionally, the \kernel.scala\ file now exposes core kernel types and utilities such as the effect type alias \\<\, \Loop\, \Isolate\, \Id\, and \Const\ at the top-level \kyo\ package, simplifying access to fundamental kernel components.

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

A new concurrent two-level object pooling system, TracePool, has been added to manage Trace objects used in execution tracking. This component utilizes a combination of thread-local and global pooling to minimize contention while efficiently reusing Trace objects. Each thread maintains its own local pool for fast, unsynchronized access, with a shared global pool handling overflow and replenishment. The system ensures traces are automatically cleared before reuse to prevent information leaks between different execution contexts.

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

New compatibility bindings have been added for the JVM Ox runtime, allowing Kyo effects to interoperate with Ox's structured concurrency primitives. This includes a \CIO\ effect type backed by Ox's \Ox\ capability, along with opaque wrappers for core concurrency constructs: \CAtomicBoolean\, \CAtomicInt\, \CAtomicLong\, and \CAtomicRef\ for atomic operations; \CChannel\ for blocking queues; \CFiber\ for cancellable forks; \CLatch\ for countdown latches; \CLocal\ for fiber-local values; \CMeter\ for semaphores; \CPromise\ for single-shot completion; \CChunk\ for immutable vectors; and \CStream\ for reactive flows. These bindings enable users to run Kyo-based code within Ox's supervised scopes, leveraging Ox's thread interruption and structured concurrency while maintaining Kyo's effectful API.

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

The JVM-specific internal implementation for OS signal handling has been added, enabling the framework to install handlers for interruption signals (such as SIGINT) using reflection against \sun.misc.Signal\. This allows applications running on the JVM to gracefully handle termination signals, with a fallback to a no-op handler if the underlying signal classes are unavailable on the specific runtime.

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

The JVM test runner now supports JUnit XML output, writing one \TEST-{suiteName}.xml\ file per suite to a configurable directory for consumption by CI systems like Jenkins and GitHub Actions. Additionally, the runner performs end-of-run leak detection in forked JVMs, checking for open file descriptors, runnable fibers, and non-daemon threads that were not properly released by tests, and fails the build if leaks are detected.

kyo-test/runner/jvm · high confidence

The kyo-net module now includes C-language shims that enable cross-platform support for Native and JavaScript targets. This adds a bundled BoringSSL shim and a system-OpenSSL shim to handle TLS operations, complete with stubs that gracefully report unavailability when the underlying libraries are missing. Additionally, it introduces shims for Linux-specific networking features like epoll and eventfd, as well as POSIX utilities for file descriptor management and hostname resolution, ensuring the network stack links and functions correctly across different operating systems.

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

This change introduces the Scala Native implementation for the kyo-ffi library, enabling cross-platform FFI capabilities on Native targets. It provides native-specific backing for core FFI components, including memory buffer allocation and memory-mapped file access via \BufferFactory\, platform reflection for generated code via \FfiReflect\, and guard management with leak detection via \NativeGuard\ and \NativeLeakDetector\. The implementation also includes a global retained-callback pool with concurrency support in \CallbackRegistry\, ensuring safe interaction between generated code and native callbacks.

kyo-ffi/native · high confidence

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

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

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

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

Introduces a suite of new shell scripts to standardize and improve the CI and local development experience. \build.sh\ serves as the primary entry point, supporting \direct\, \podman\, and \podman-ci\ environments with cross-architecture container builds and deterministic resource caps. \apt-install.sh\ provides robust package installation with mirror failover and retry logic. \ci-monitor.sh\ adds real-time resource tracking (memory, disk, tasks) with optional disk-abort capabilities to preserve logs during OOM or disk-full events. \ci-logs.sh\ and \ci-queue.sh\ offer specialized tools for inspecting CI job logs (filtering failures, viewing totals) and analyzing queue wait times by runner pool. \ci-stabilization.sh\ acts as a preflight check to ensure the local branch and remote state are consistent before dispatching. \build-selftest.sh\ validates the build script's argument and environment handling.

scripts · high confidence

The codegen module now includes a complete TASTy-based inspector (FfiInspector) that extracts binding specifications from traits extending kyo.ffi.Ffi, and platform-specific code emitters for JVM (Panama), Scala.js (koffi), and Scala Native. It also introduces BlockingAllowlist and RetentionAllowlist to warn when C symbols known to block or retain callbacks are used without proper annotations, and adds a ReachabilityMetadataEmitter to generate GraalVM native-image metadata for JVM bindings.

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

This change introduces a new \kyo-compat\ module that provides a \CIO\ effect type and a suite of concurrency primitives (atomic references, channels, latches, semaphers, fiber-local state, promises, and chunks) backed by \scala.concurrent.Future\. This allows users to integrate Kyo-style effect composition with existing Scala Future-based codebases, though it lacks native cancellation support and propagates no Kyo Frames or Traces.

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

The HTTP codec package now includes a compile-time OpenAPI macro (OpenApiMacro) that generates route definitions from OpenAPI specification files, and a high-performance, low-allocation HTTP/1.1 request/response parser (ParsedRequest, ParsedRequestBuilder, ParsedResponse) that uses packed binary layouts for metadata and headers.

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

This change introduces a comprehensive JMH benchmark suite in \kyo-ffi/bench\ to measure FFI performance, including call overhead, array passing strategies (zero-copy pin vs. copy), callback upcall costs, and reflection-based binding loading. It also adds the \BlockingBridge\ runtime component in \kyo-ffi/jvm-native\, which wraps synchronous \@Ffi.blocking\ downcalls into \Fiber.Unsafe\ to allow the Kyo scheduler to recognize blocked carrier threads, alongside supporting internal utilities like \BorrowOwnerHolder\ and \GuardDrainSupport\. Tests for these new components, including \BufferMmapTest\ and \BlockingBridgeTest\, are also included.

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

This change introduces the foundational types and transport layer for the kyo-jsonrpc module. It adds \JsonRpcId\ to model JSON-RPC 2.0 identifiers (string or numeric) with schema support, \JsonRpcIdStrategy\ to configure request ID generation, and \JsonRpcExtrasEncoder\ to attach protocol-specific extra fields to outbound envelopes. It also defines \JsonRpcFramer\ with presets for line-delimited and Content-Length framing, \JsonRpcWireTransport\ for byte-level I/O integration, and \JsonRpcTransport\ with factories for in-memory, stdio, and Unix-domain socket connections. Additionally, \JsonRpcMessageGate\ provides a pre-dispatch hook for authentication, rate limiting, or handshake enforcement, and \JsonRpcRoute\ enables typed request/notification routing with domain error mapping.

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

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 registered blocks execute in order with a consistent snapshot of the parsed CLI data, and includes internal support for platform-specific exit handling and interrupt management.

kyo-case-app/shared · high confidence

This change introduces the core Protobuf reader and writer implementations for the Kyo Schema library. The new ProtobufReader handles decoding of Protocol Buffers wire format, including support for nested messages, repeated fields (both packed and unpacked), and maps, while maintaining read/write symmetry through field ID overrides. The ProtobufWriter encodes values into Protobuf format using stable hash-based field IDs for schema evolution compatibility, with support for nested structures, repeated scalar fields (packed encoding), and map entries. These components enable serialization and deserialization of Kyo Schema types using the Protocol Buffers format.

kyo-schema-protobuf/shared · high confidence

The kyo-actor library now includes a new PubSub type that enables push-based publish/subscribe patterns. Users can create PubSub instances via \init\ for concurrent fan-out or \linearized\ for total ordering of events across all subscribers, with the latter backed by an actor to ensure strand-safe operations. This addition allows subscribers to receive messages directly into their mailboxes, with automatic pruning of closed subscribers and support for concurrent publishing with configurable parallelism limits.

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

Users can now route Kyo's \Log\ effect through the SLF4J API on the JVM via the new \SLF4JLog\ integration. This backend wraps any \org.slf4j.Logger\, allowing runtime reconfiguration (such as changing log levels via Logback) to take immediate effect without restarting the application, and automatically includes source call-site position in log output.

kyo-logging-slf4j/jvm · high confidence

The documentation and marketing site has been rebuilt using the kyo-ui framework, replacing the previous static/docsify setup. This change introduces a unified single-page application shell (SiteApp) that manages a persistent header with live search, version switching, and theme toggling, while rendering reactive content slots. A new landing page (LandingApp) presents the product's value proposition with a hero section and code examples, and a new documentation viewer (DocsApp) features a two-pane layout with a collapsible mobile drawer, active route highlighting, and in-page section outlines. The entire site's styling is now defined programmatically via a kyo-ui stylesheet (WebsiteStyles), ensuring type-safe CSS class usage and consistent theming across light and dark modes.

kyo-website/shared · high confidence

The kyo-zio module introduces bidirectional interoperability between Kyo and ZIO, allowing developers to lift ZIO values into Kyo computations and run Kyo computations as ZIO effects. It provides three pairs of functions for seamless integration: ZIOs.get/run for ZIO values, ZStreams.get/run for streaming data, and ZLayers.get/run for dependency layers. The implementation preserves failure semantics and interruption across the runtime boundary, mapping ZIO failures to Kyo Abort effects and vice versa, while ensuring that ZIO environments are handled via ZLayers rather than direct lifting.

kyo-zio · high confidence

The \kyo-compat\ module now provides a unified \CIO\ effect type and a suite of concurrent primitives (including \CAtomicBoolean\, \CAtomicInt\, \CAtomicLong\, \CAtomicRef\, \CChannel\, \CFiber\, \CLatch\, \CLocal\, \CMeter\, \CPromise\, and \CStream\) that bridge Java's \CompletionStage\ and standard concurrency utilities into either the Kyo or ZIO runtime. This allows users to interoperate with existing Java libraries and migrate incrementally by using a consistent API surface regardless of whether they are running on the Kyo or ZIO backend.

(repo-wide) · high confidence

This release introduces several new concurrency primitives to the core library. The new Access enum allows specifying producer-consumer access patterns (such as SingleProducerSingleConsumer or MultiProducerMultiConsumer) for optimized performance in Channels and Queues. A new Admission control mechanism (Admission object) provides load-shedding capabilities to prevent system overload by probabilistically or deterministically rejecting tasks based on system congestion. Additionally, a new Gate synchronization primitive is added, enabling coordinated passage for concurrent parties with support for fixed or dynamic membership, replacing the previous Barrier concept.

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

The kyo-config module now provides a new configuration API featuring StaticFlag for one-time resolved values (e.g., pool sizes) and DynamicFlag for runtime-mutable values (e.g., feature gates), along with a Rollout DSL for expression-based selection. This change introduces Scala 3-specific equality instances for these types and replaces the previous Murmur hashing implementation with a native Scala port of XXHash (XXH32/XXH64) to optimize hashing performance and avoid store faults on Native platforms.

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

The JSON-RPC module now includes a new internal transport layer that supports multiple connection types, including Unix domain sockets, standard I/O, in-memory channels, and generic network connections. This enables cross-platform compatibility and allows JSON-RPC communication over various backends, improving flexibility for different deployment scenarios.

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

Added a comprehensive suite of Scala and Java fixture classes to the \kyo-tasty/fixtures\ module to enable cross-platform (JVM, JS, Native) testing of TASTy and classfile decoding. The fixtures cover annotation retention, cross-file symbol resolution, context functions, opaque types, parametric enums, and a wide range of Scala 3 type ADTs (intersection, union, match, refined, and recursive types). Java classfile bytes are embedded for JS/Native consumption to ensure consistent decoding paths across platforms.

kyo-tasty/fixtures/shared · high confidence

The kyo-schema-json module now provides a complete JSON serialization and schema generation system. It introduces a new \Json\ codec with \encode\, \decode\, \encodeBytes\, and \decodeBytes\ methods for converting Scala types to and from JSON strings and bytes. The module includes a \JsonSchema\ type that generates JSON Schema Draft 2020-12 compliant schemas from Scala types, enriched with runtime metadata like documentation, constraints, examples, and field renames via the \JsonSchemaEnricher\. It also supports JSONL (JSON Lines) framing and streaming through \Json.Lines\. The implementation features a high-performance \JsonWriter\ using escape lookup tables and the Ryu algorithm for floats/doubles, and a \JsonReader\ that parses UTF-8 bytes directly to avoid string intermediaries. Additionally, it fixes a compilation issue for \derives Schema\ in external packages by making private type references package-safe.

kyo-schema-json/shared · high confidence

This change introduces several new internal components to the kyo-data library. It adds a borrow-checking system (BorrowOwner, BorrowRevoked) to track the lifetime of borrowed buffers and prevent use-after-free errors. It includes pure Scala implementations of SHA-1 and SHA-256 (Sha1, Sha256) to support cross-platform UUID generation without relying on platform-specific security providers. Additionally, it provides low-level off-heap memory management utilities (UnsafeBuffer, UnsafeLayout) and macro-based type reflection tools (ConcreteTagMacro, DeclaredBounds, FieldsMacros, TagMacro) to improve type safety and performance in data encoding and tag derivation.

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

This change introduces the core internal components for the stats system in kyo-stats-registry. It adds a StatsRegistry that manages scoped counters, gauges, counter-gauges, and histograms using a thread-safe store with weak references. It includes a TraceExporter SPI that uses Java ServiceLoader to discover and compose multiple exporter implementations, with isolated discovery to prevent a single failing provider from breaking the system. The implementation provides high-performance, concurrent-safe metric types: UnsafeCounter with delta calculation, UnsafeGauge/CounterGauge, and a fixed-bucket UnsafeHistogram optimized for high throughput with atomic min/max and sum tracking. Tests verify histogram bucket assignment, value observation, and summary generation.

kyo-stats-registry/shared · high confidence

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

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 handling non-deterministic choices, EmitCombinators for managing value emissions and streaming, EnvCombinators for dependency injection via layers, and KyoCombinators for sequencing, repetition, and debugging. It also adds Constructors for creating effects from standard types (Option, Either, Future, etc.), MaybeCombinators for handling Absent/Present states, StreamCombinators for stream unwrapping, and internal Zippable support for combining results.

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

The kyo-compat SBT plugin now enables library authors to generate a \ProjectMatrix\ of per-backend (Future, Kyo, Zio, Ox, Twitter Future) and cross-platform (JVM, JS, Native) rows from a single declaration. It automatically injects the correct \kyo-compat-\<backend\>\ dependency, supports binding external or local backend implementations, and bundles a conformance test suite that extracts into each row's test scope to verify compatibility. The plugin also handles shared source/resource discovery, per-backend overrides, and cross-backend aggregation.

kyo-compat/plugin · high confidence

The kyo-data module introduces several new types and utilities. Ansi provides string coloring, formatting, and syntax highlighting for code snippets. Base64 offers a cross-platform (JVM, Scala.js, Scala Native) encoder/decoder compliant with RFC 4648, avoiding java.util.Base64 dependencies. ByteSize is an opaque type for storage quantities with arithmetic, parsing, and human-readable formatting. Dict is an immutable dictionary with adaptive performance (linear scan for ≤8 entries, HashMap for larger). ChunkBuilder and DictBuilder provide efficient mutable construction with thread-local buffer pooling. Duration and Fields support time spans and field-based record operations. ConstValue materializes compile-time constants at runtime.

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

The kyo-system module introduces a new filesystem abstraction built around the \Path\ type, providing typed read/write capabilities, advisory file locking, and filesystem change watching. It also adds a \Command\ API for spawning and managing OS processes with scoped lifecycle management, including stdin feeding and output streaming. These capabilities are implemented with platform-specific backends (e.g., JVM NIO) and include comprehensive tests for symlink handling, atomic moves, and lock registry behavior.

kyo-system/shared · high confidence

The scheduler now includes two new self-tuning regulators: Admission, which prevents overload by dynamically adjusting the percentage of tasks accepted based on measured queuing delays, and Concurrency, which optimizes the number of worker threads by detecting system scheduling jitter. These components automatically adjust system behavior to maintain stability under varying load conditions.

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

The kyo-data library now provides concrete, platform-specific implementations of the UnsafeBuffer abstraction for both the JVM and Scala Native targets. On the JVM, UnsafeBuffer operations are backed by Java Panama MemorySegments, enabling efficient direct memory access and file mapping via the FileChannel API. On Scala Native, UnsafeBuffer uses raw pointers with pointer arithmetic for primitive access and POSIX mmap for file mapping, ensuring low-level performance parity across platforms. This change also introduces platform-specific Platform objects that resolve OS detection (macOS, Linux, Windows, BSD) at link time for Native and runtime for JVM, and standardizes the maxStackDepth to 256 across both platforms.

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

This change introduces platform-specific implementations for the SQL backend discovery mechanism and test utilities across all supported targets. On JS and Wasm, a new \BackendPlatformSpecific\ trait provides a \register\ method backed by an in-memory \JSServiceLoaderRegistry\, enabling runtime discovery of SQL backends where standard classpath service files are not read. For JVM and Native, \BackendPlatformSpecific\ delegates to \SqlBackendRegistrations\ to supplement the standard service loader with manually registered backends. Additionally, platform-specific \TestProcessId\ and \TestTempRoot\ objects are added to support \SqlTestContainers\ by providing reliable process liveness probes (using Node.js APIs on JS/Wasm, \ProcessHandle\ on JVM, and \kill\/\errno\ on Native) and consistent temporary directory roots for cross-process container ownership.

kyo-sql/js-wasm, kyo-sql/jvm, kyo-sql/native · high confidence

This change introduces platform-specific implementations for system information and process management across the JS/WASM and JVM/Native targets. On JS/WASM, it adds Node.js-backed facades for child processes (handling stdin/stdout/stderr streams, exit codes, and signals) and implements OS name and architecture detection by falling back to Node's \process.platform\ and \process.arch\ when Java system properties are unavailable. On JVM and Native, it provides concrete implementations for process lifecycle management (waiting, destroying, checking liveness) and command building (environment variables, working directory, I/O redirection) using standard Java APIs, along with a \toJava\ extension for \Path\. These changes enable the \kyo-system\ module to function correctly on these platforms by providing the necessary low-level platform abstractions.

kyo-system/js-wasm, kyo-system/jvm-native · high confidence

The repository has been initialized with core documentation and configuration files, including the Apache 2.0 license, a Code of Conduct, and detailed contributor guidelines (CONTRIBUTING.md). An AI agent guide (AGENTS.md) has been added to enforce coding standards and fix protocols. The project also introduces a new changelog (CHANGELOG.md) to track breaking API changes, such as the migration of system-related types (Path, System, Process) to a new kyo-system module and the renaming of fiber initialization methods. Build infrastructure is established with .gitattributes for line-ending consistency, .jvmopts for JVM tuning, and a .readthedocs.yaml for documentation hosting.

(repo-wide) · high confidence

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

The Caliban integration now provides schema definitions for Kyo effects (A \< S), allowing GraphQL resolvers to natively handle computations wrapped in the Kyo effect system. This enables seamless integration of Kyo-based logic into Caliban GraphQL schemas by automatically resolving effectful values through the appropriate ZIO query steps.

kyo-caliban/src/main · high confidence

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.

kyo-ffi · high confidence

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

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

The browser integration now automatically registers a shutdown hook to forcibly terminate any active Chrome process if the host runtime exits unexpectedly (e.g., via System.exit or abrupt termination). This ensures that browser processes do not linger as orphaned tasks after the application stops, providing a safety net for cleanup scenarios that bypass the standard effect scope finalizers.

kyo-browser/jvm-native · high confidence

The browser module now includes internal infrastructure for more reliable testing: \BrowserAssertion\ implements a two-phase stability check (immediate read followed by a configurable sampling window) to prevent flaky assertions caused by DOM flickers, while \BrowserNetworkTracker\ installs in-page interceptors to accurately detect when network activity has settled via \waitForNetworkIdle\. Additionally, \BrowserLauncher\ has been updated to spawn Chrome with flags that disable background timer throttling and startup windows, ensuring consistent test timing and cleaner process management.

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

The documentation site has been replaced with a new Scala-based static site generator (SSG) and single-page application (SPA) architecture. The previous Docsify-based setup, including the \docs/\ directory and legacy workflows, has been removed. The new system generates static HTML from the current repository state (READMEs) and serves it via a client-side bundle, with a new GitHub Actions workflow that deploys on release rather than on every push. This change also introduces forward-only versioning for the current release, with support for appending historical snapshots via a \--content\ flag, and ensures hydration parity between server-side rendering and client-side mounting.

kyo-website/jvm · high confidence

The documentation website now uses a single-page application (SPA) built with Scala.js instead of the previous static/docsify setup. The new bundle boots by reading pre-rendered HTML islands seeded by the static site generator, then handles navigation client-side: clicking links swaps the article content and table of contents without a full page reload, updates the browser history, and keeps the page title and canonical link in sync with the server-side output. It also preserves the user's theme preference and provides a search index seeded from the initial island data.

kyo-website-bundle/js · high confidence

The kyo-pod library now correctly recovers raw (non-multiplexed) stdout/stderr streams that deviate from the expected Docker multiplexed format, preventing silent output loss. This is supported by new internal FrameAssembler and LineAssembler components that robustly parse and stitch log entries. Additionally, several demo applications (CodeSandbox, IntegrationTestScaffold, LogAggregator, PrometheusExporter, ServiceMesh, KyoPodDevRunner) have been added to the test suite to illustrate container orchestration, networking, and observability patterns.

kyo-pod/shared · high confidence

The scheduler now includes a BlockingMonitor that detects when worker threads are blocked in kernel operations (such as I/O or locks) by sampling user CPU time, allowing it to stop routing new tasks to blocked workers and drain their queues to prevent starvation. Additionally, the monitor ensures that fiber interrupts are reliably dispatched to blocked threads by waking them from their blocking operations, and the WorkerQueue has been updated to support runtime key rebuilding to maintain correct priority ordering after interrupts.

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

The \Reducible\ trait and its associated \LowPriorityReducibles\ helper have been moved into the \kyo.internal\ package. This change reorganizes the internal implementation details for effect reduction and elimination, ensuring these core type-level mechanisms are properly encapsulated within the internal API layer.

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

The HTTP client now uses a new internal backend (\HttpClientBackend\) that manages connection pooling, transport, and protocol handling. This change introduces specific error mapping for network failures (DNS, connection refused, timeouts) to distinct HTTP exceptions, allowing callers to distinguish between different connection failure reasons. It also adds logic to handle Unix sockets and TLS configuration merging, and ensures that connections are properly closed if the initial handshake or promise completion fails, preventing resource leaks.

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

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

This change adds three new internal components to support application lifecycle management and logging. KyoAppRunner.scala provides a shared runner trait for Kyo application entrypoints, including logic for handling normal termination (such as signal interrupts) and separating stdout/stderr output for results and errors. LogShared.scala introduces platform-agnostic logging helpers that decouple the logging dispatch and overflow logic from platform-specific daemon state, enabling async logging. OSSignal.scala defines a platform-specific signal handling abstraction with a no-op handler for non-Unix platforms.

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

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

The scheduler now uses a dedicated IOTask implementation to manage asynchronous computations, ensuring that fiber interruptions are delivered reliably and finalizers are executed correctly even during race conditions. This change fixes issues where interrupts could be lost or finalizers leaked by establishing the promise's state as the single source of truth for interruption, and by explicitly handling interrupt cascades and resource cleanup in the task's run and ensureInterrupt methods.

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

The kernel now introduces a unified \Isolate\ abstraction to manage effect state across execution boundaries such as fiber forks and parallel operations. This replaces previous ad-hoc handling with a structured three-phase lifecycle (capture, isolate, restore) that precisely controls which effects are removed, kept, or restored during isolated execution. This change enables proper state management for \ContextEffect\s (simple copying) and complex effects (structured transformation and restoration), ensuring consistency and preventing state leakage when computations are forked or resumed asynchronously.

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

The JVM implementation of the Tasty query engine has been replaced with a memory-mapped architecture to improve performance and concurrency. JAR files are now opened via \java.nio.MappedByteBuffer\ with a thread-safe pool (\JarMappedReaderPool\) to share mappings across concurrent fibers, avoiding repeated file descriptor allocation. The engine now supports reading JDK module descriptors and class files from the \jrt:/\ virtual filesystem, enabling cross-platform reflection on standard library symbols. Additionally, snapshot loading uses memory-mapped files with a process-wide semaphore to bound open file descriptors, and a content-addressed digest mechanism ensures snapshot validity across runs.

kyo-tasty/jvm · high confidence

The JVM scheduler utility layer adds support for Java Loom virtual threads via LoomSupport, which attempts to configure a dedicated thread pool for virtual threads while gracefully falling back to the standard executor if JVM arguments restrict access. It introduces a Singleton base class to ensure the scheduler remains a true JVM-wide singleton across multiple classloaders, preventing conflicting thread-pool adjustments and inaccurate load measurements in plugin-heavy environments. Blocking detection is improved by ThreadUserTime, which uses the batched ThreadMXBean API for efficient per-thread CPU time queries and probes the platform's counter resolution to avoid false positives on systems with coarse timers. Additionally, platform-specific executors are standardized in WorkerExecutors, and a lightweight Sleep utility is provided to minimize measurement noise in the concurrency regulator's jitter probe.

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

The build system has been significantly upgraded, including a major version bump of sbt from 1.6.2 to 1.12.13 and updates to key plugins like sbt-scalafmt, sbt-jmh, and sbt-scoverage. A new unified \testKyo\ command has been introduced to streamline CI and local testing across JVM, JS, Native, and the new WebAssembly platform, supporting granular control over modules, phases, and Scala versions. The build now features a \Repeat\ command for iterative development, a \TestVariant\ code generator for parameterized tests, and a \KyoScalacOptions\ helper for version-aware compiler flags. Additionally, the project now supports WebAssembly via a dedicated \WasmPlatform\, integrates the \kyo-ffi\ plugin directly into the meta-build, and removes the \sbt-github-packages\ and \metals.sbt\ dependencies.

project · high confidence

This change introduces a suite of new lock-free queue implementations for the JVM and Native platforms, including unbounded and bounded variants for single-producer/single-consumer (SPSC), single-producer/multiple-consumer (SPMC), multiple-producer/single-consumer (MPSC), and multiple-producer/multiple-consumer (MPMC) scenarios. These internal components replace previous implementations to provide higher performance and thread-safety guarantees. Additionally, the hash code computation for \Tag\ objects is now cached and computed once per tag instance rather than on every comparison, reducing overhead in hash-based collections.

kyo-data/jvm-native · high confidence

The Scala Native scheduler implementation now includes robustness improvements to handle platform-specific concurrency issues. A new HandoffRetryExecutor wraps the worker thread pool to detect and retry lost task handoffs caused by a known Scala Native ThreadPoolExecutor defect, ensuring tasks are not silently dropped. Worker thread creation is serialized through a gating mechanism to prevent heap corruption from a GC race during thread initialization. Additionally, the scheduler introduces platform-specific utilities: a Sleep object that uses nanosleep on Unix to avoid file descriptor contention, and ThreadUserTime implementations for macOS and Linux that query per-thread CPU time via native bindings to support accurate blocking detection.

kyo-scheduler/native · high confidence

The HTTP/1.1 transport layer has been replaced with a new, zero-copy implementation that improves security and performance. The new parser enforces strict, whole-token header matching to prevent request-smuggling vulnerabilities and validates response headers to block response-splitting attacks. Chunked transfer encoding is now handled by a dedicated decoder that caps accumulated body sizes to prevent unbounded memory growth (CWE-400), while also bounding control-plane buffers to prevent resource exhaustion during malformed framing. The client and server connections now reuse internal buffers and promises across requests to reduce allocation overhead.

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

This change introduces several new internal components in the kernel to support effect handling and execution safety. CanLift provides a soft constraint to prevent accidental nesting of effect computations and disallows lifting of Kyo modules. Context introduces a type-safe storage mechanism for effect values, including logic to handle isolation via a NoninheritableFlag. LiftMacro implements the runtime logic for lifting values into effect types, handling casts, nested effects, and default lifting. Safepoint manages stack safety, thread isolation, and interceptor registration, using a compact bit-packed state to track depth, thread ID, and interceptor presence, while also supporting serialization. Trace implements a fixed-size circular buffer for recording execution frames, with optimized rendering that collapses consecutive identical frames. These components collectively form the foundation for effect nesting prevention, context propagation, and debuggable execution traces.

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

The JVM scheduler now uses a VarHandle-based implementation for IOPromise state management, replacing previous allocation-heavy approaches. This change reduces memory allocation overhead during promise state transitions, improving performance for concurrent operations that rely on IOPromise.

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

The durable execution engine in \kyo-flow/shared\ has been re-architected to use a wait ledger and a claimed capability model. This introduces a new \FlowInterpreter\ that records durable state for dispatch choices, subflow inputs, and compensation handlers before execution, ensuring that replayed executions follow the exact same path and side effects as the original attempt. The system now uses specific durable keys (e.g., \\#chosen\, \\#compensated\) to track progress, allowing for precise recovery from interruptions in loops, foreach fan-outs, and subflows without re-executing completed work or duplicating side effects.

kyo-flow/shared · high confidence

The scheduler now exposes a set of configurable static flags (defined in Flags.scala) allowing users to tune worker counts, scheduling strides, and time-slice duration (defaulting to 10ms). This enables time-slice preemption, where long-running tasks are periodically yielded to ensure fairer scheduling among queued fibers. Additionally, the Task implementation includes logic to reset accumulated runtime for interrupted tasks, ensuring they are prioritized for immediate execution to observe interrupts and run finalizers, thereby preventing interrupt starvation.

kyo-scheduler/shared · high confidence

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

The YAML module in kyo-schema-yaml has been restructured to introduce a Concrete Syntax Tree (CST) layer, enabling precise manipulation of YAML documents while preserving original formatting. New internal components include YamlCstBuilder for constructing CSTs from events or values, YamlCstEdits for performing structural changes (insert, replace, remove) via paths, and YamlCstRenderer for serializing CSTs back to strings with full trivia (comments, whitespace) preservation. The existing event-based pipeline (YamlEventScanner, YamlEventReader) remains as the foundation, but document handling now supports multi-document streams with proper splitting and merging via YamlDocuments. Scalar resolution logic in YamlScalars has been updated to support both YAML 1.1 and 1.2 specifications, including distinct parsing rules for integers, floats, and booleans per version. This change improves reliability and determinism in YAML processing, particularly for round-trip fidelity and structured edits.

kyo-schema-yaml/shared · high confidence

The kyo-aeron module now runs identically on JVM, Scala Native, Scala.js, and Wasm by consolidating the transport implementation onto a single C shim (kyo\_aeron.c) that wraps the Aeron C client and embedded media driver, replacing the previous platform-specific JVM implementation. This change ensures byte-identical wire formats and uniform public APIs across all platforms, while introducing a new build script (build-aeron.sh) to stage the pinned Aeron 1.51.1 static library per OS/architecture. Additionally, comprehensive CONTRIBUTING.md and README.md files have been added to document the module's architecture, unsafe-tier boundaries, and usage patterns.

kyo-aeron · high confidence

The MySQL and Postgres SQL modules now correctly register their database backends at runtime in Scala.js and WebAssembly targets. Previously, the standard Java service-loader mechanism did not function in these environments, causing the backend discovery system to fail silently. This change introduces explicit initialization entry points (\\_\_kyo\_sql\_mysql\init\ and \\\_kyo\_sql\_postgres\_init\) that force the backend factories to register themselves, ensuring that SQL queries can be executed against MySQL and Postgres databases from client-side JavaScript and WebAssembly applications.

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

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

Add test coverage for core concurrency and caching primitives; Added JS-specific network transport tests; Added JVM and Native platform-specific parse tests; Added JVM-specific HTTP resilience and TLS test infrastructure; Added JVM-specific TLS and NIO transport tests; Added JVM-specific serialization tests for STM TRef; Added JVM-specific test infrastructure for allocation probing and reflection; Added JVM-specific tests for Gate race conditions and Stream compression; Added JVM-specific tests for kyo-data internals; 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 requests, long-running tools, prompts, and typed code exploration; Added Node.js file I/O support for snapshot tests in WebAssembly environments; Added browser automation test fixtures and demo applications; Added bytecode size verification tests for kernel effects; Added comprehensive test coverage for kernel effect primitives; Added comprehensive test coverage for kyo-doctest parsing, scoping, and execution; Added comprehensive test coverage for kyo-jsonrpc core components; Added comprehensive test coverage for kyo-net transport reliability and contracts; Added comprehensive test coverage for the \direct\ macro; Added comprehensive test suite for kyo-compat bindings; Added comprehensive test suite for kyo-config flags and rollouts; Added comprehensive test suite for kyo-scheduler on JVM and Native platforms; Added comprehensive test suites for kyo-prelude effects; Added concurrency and ownership tests for the internal network stack; Added flamegraph profiling data for the HTTP server demo; Added golden test files for FFI code generation across JS, JVM, and Native targets; Added integration tests for kyo-ffi cross-platform bindings; Added kyo-caliban integration tests for GraphQL resolvers and server endpoints; Added placeholder for JVM-Native FFI integration tests; Added platform-specific tests for the JavaScript filesystem implementation; Added test coverage for Actor, PubSub, and Subject components; Added test coverage for Kyo collection operations and core effects; Added test coverage for kyo-combinators; Added test coverage for kyo-core effects; Added test coverage for kyo-data core types and utilities; Added test for FatalFiber robustness against scheduling latency; Added test infrastructure for Scala Native support; Added test infrastructure for WebAssembly support; Added test infrastructure for cross-platform SQL backend registration; Added test stubs for ContainerRuntime on JVM and Native platforms; 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 JVM-specific JSON writer behavior; Added tests for Java Scheduler usage and singleton behavior; Added tests for Markdown-to-UI rendering; Added tests for Monad laws in kyo-prelude; Added tests for OS signal handling; Added tests for Safepoint thread safety and TracePool concurrency; Added tests for StatsRegistry scope, counter, histogram, gauge, and counterGauge; Added tests for Zippable combinators; Added tests for external codec extension capabilities; Added tests for internal concurrency primitives and utilities; Added tests for internal kernel components; Added tests for internal schema utilities; Added tests for kyo-offheap Memory API; Added tests for reactive-streams flow interop; Added tests for scheduler top-status reporting components; Added tests for scheduler utility components; Added tests for the Debug effect; Added tests for the SQL backend SPI and cross-engine conformance; Added tests for the sbt-kyo-test plugin and its cross-platform integration; Added unit tests for the Kyo FFI SBT plugin; Expanded JVM-specific test coverage for kyo-ffi; Expanded test coverage for kyo-schema core capabilities; Expanded test coverage for schema encoding, Protobuf round-trips, and JVM class initialization; Integration test suite for kyo-ffi cross-platform bindings; Introduce kyo-test V3 API with new assertion, reporting, and configuration primitives; JVM browser tests verify shared instance isolation and robust cleanup; New HTTP demo applications and test service registration; New sbt-test suite for kyo-ffi plugin capabilities; Removed Cats and ZIO monad law tests; Scripted tests for the kyo-compat sbt plugin.

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

• First survey — no prior run to compare against. CAI 58.

• Code Health 78
• Architecture 98
• Maturity 62
• Readiness 69
• Security 43
• Domain Modelling 100

• 300 commits — 249 feature/other, 51 fixes

• .github/workflows — 38 commits
• kyo-core/shared — 29 commits
• (root) — 19 commits
• kyo-schema/shared — 17 commits
• kyo-ui/shared — 13 commits
• kyo-data/shared — 10 commits
• kyo-scheduler/jvm-native — 10 commits
• kyo-tasty/shared — 9 commits
• kyo-browser/shared — 8 commits
• kyo-http/shared — 8 commits
• kyo-ai/shared — 7 commits
• kyo-ffi/plugin — 7 commits
• kyo-test/runner — 7 commits
• kyo-system/shared — 6 commits
• kyo-net/jvm-native — 5 commits
• kyo-net/shared — 5 commits
• kyo-core/jvm-native — 4 commits
• kyo-pod/shared — 4 commits
• kyo-schema-json/shared — 4 commits
• kyo-sql/shared — 4 commits

• fix: Fix Windows drive letter dropped by Path segment reconstruction (#1678) (#1679)
• fix: Fix schema JSON encoding without private JDK access (#1803)
• fix: Revert "Add shared Kyo companion operations" (#1680)
• fix: Revert "[build] render scaladoc with a forked newer tool"
• fix: Revert "[kyo-stats-machine] make the classpath contract true; generic FFI release" (#1914)
• fix: [aeron] fix TopicTest subscriber-connectedness races
• fix: [build] enable -Werror on Scala 3 and fix all resulting warnings (#1675)
• fix: [build] fix kyo-test-snapshot schema deps, cap CI JS linker memory
• fix: [build] fix scalafmt import order in WasmPlatform.scala
• fix: [build] format TestKyo.scala imports to fix scalafmt check
• fix: [build] serialize scaladoc to fix flaky dottydoc NPE in ci-release
• fix: [build] turn on -Xcheck-macros build-wide and fix what it finds (#1907)
• fix: [ci] revert to GitHub-hosted runners
• fix: [core,browser] bound parallel chunk map concurrency; fix screencast teardown
• fix: [core] fix Gate.passAt lost-wakeup (read promise before phase)
• fix: [core] fix JS Command.text dropping stdout drained on exit
• fix: [docs] add a sponsors funding file and fix the build badge
• fix: [ffi] fix invalid Scala codegen for nested-struct String fields (#1683) (#1684)
• fix: [jsonrpc] Rename JVM JsonRpcTransport file to fix source-jar duplicate entry
• fix: [jsonrpc] fix close race leaking raw Closed to pending calls
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

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.