lysine-dev/okio

Okio is a Kotlin Multiplatform library that provides a unified API for byte manipulation and file system operations across JVM, Android, Native, JavaScript, and WebAssembly targets. It abstracts platform-specific I/O details through a consistent FileSystem interface, supporting local files, Android assets, Node.js, and WebAssembly environments. The system also includes utilities for streaming compression (ZIP, GZIP), cryptographic hashing, and performance benchmarking, ensuring reliable data handling across diverse runtime environments.

19 changes.

This period focused on migrating Okio's core APIs to Kotlin Multiplatform by consolidating common code and implementing native support for file I/O, hashing, and compression. The work also involved modernizing the JVM interface with extension functions, establishing comprehensive cross-platform testing, and setting up automated documentation and release pipelines.

17 changes.

This period focused on expanding Okio's platform support to include Kotlin/JS, Kotlin/Native (Windows and Unix), and Kotlin/Wasm, alongside the introduction of the WASI file system. The work involved implementing platform-specific file handle backends, centralizing build configuration for multiplatform targets, and enhancing the testing infrastructure with new modules and comprehensive coverage for these new environments.

12 changes.

This period focused on expanding Okio's multiplatform capabilities by introducing native support for ZIP, GZIP, and Zlib compression across Kotlin/Native and JavaScript targets. It also established foundational file system abstractions, including initial implementations for Node.js and WebAssembly (Wasi), alongside performance optimizations for hex decoding and platform-specific file metadata handling.

A new android-test module has been added to run Okio's test suite on connected Android emulators or devices. This includes the necessary Android manifest with internet and storage permissions, a multidex configuration, and a network security configuration. Users can now execute tests using Gradle commands against a connected device.

android-test · high confidence

The samples directory now includes a comprehensive set of Java and Kotlin examples demonstrating Okio capabilities on the JVM. These samples cover file I/O (reading/writing files, reading line-by-line), integration with Java NIO channels (ByteChannelSource/Sink, FileChannelSource/Sink), data processing (hashing with MD5/SHA/HMAC, BMP encoding, serialization), and advanced buffering techniques (mark/reset, interceptors, random sources).

samples/src/jvmMain/java · high confidence

This change introduces multiplatform support for Zlib compression and ZIP file handling in Okio. It adds expect/actual declarations for Deflater and Inflater, along with their corresponding Sink/Source wrappers (DeflaterSink, InflaterSource), enabling DEFLATE compression and decompression across platforms. It also includes GzipSink and GzipSource implementations for GZIP format support. Additionally, a new openZip() extension function is added to FileSystem, allowing users to open a read-only file system view of a ZIP archive, which utilizes the new InflaterSource for decompressing stored entries.

okio/src/zlibMain/kotlin/okio · high confidence

A new JMH benchmark suite (BufferPerformanceBenchmark) has been added to the JVM module to measure the throughput of Okio's Buffer operations. This tool allows developers and users to profile buffer read/write performance under various thread counts and workload configurations (hot vs. cold), helping to identify performance bottlenecks in buffer handling.

jmh · high confidence

This change introduces a new internal module in okio containing platform-independent implementations of common cryptographic hash functions (MD5, SHA-1, SHA-256, SHA-512) and HMAC. These classes implement a shared HashFunction interface and are designed to support non-JVM platforms, providing the underlying hashing capabilities required for features like Hmac hashing sources and sinks.

okio/src/hashFunctions · high confidence

The \ByteString\ implementation for Apple platforms now includes an \NSData.toByteString()\ extension function, allowing seamless conversion from Apple's native \NSData\ type. Additionally, the class exposes an \equals(other, constantTime)\ overload, enabling users to perform timing-safe comparisons of byte strings, which is critical for security-sensitive operations like signature verification.

okio/src/appleMain · high confidence

This change introduces the foundational platform-specific implementations required to run Okio on Kotlin/Wasm targets. It adds the \FileSystem\ implementation for the WASM environment, providing concrete behavior for file operations such as reading, writing, listing directories, and managing metadata, while delegating common logic to shared internal utilities. Additionally, it defines the \WasmPlatform\ to specify the forward slash (\/\) as the directory separator, ensuring correct path handling on the WASM runtime.

okio/src/wasmMain · high confidence

This change introduces the \NodeJsFileSystem\ implementation, allowing Okio to interact with the local file system when running on Node.js. It adds the core \NodeJsFileSystem\ object along with supporting classes (\FileSource\, \FileSink\, \NodeJsFileHandle\) and manual JavaScript externals (\FsJs.kt\) to bridge Okio's API with Node.js synchronous file system calls. A corresponding test suite (\NodeJsFileSystemTest\) is also included to verify the implementation against the standard file system contract.

okio-nodefilesystem · high confidence

The repository is initialized with essential configuration and documentation files. This includes \.editorconfig\ and \.gitattributes\ to standardize code formatting and line endings, a \.gitignore\ for build artifacts, and the \gradlew\/\gradlew.bat\ wrapper scripts for building. Documentation is established via \README.md\, \CHANGELOG.md\, \CONTRIBUTING.md\ (including a policy against generative AI tools), \BUG-BOUNTY.md\, and \LICENSE.txt\. Additionally, \mkdocs.yml\ is added to configure the static site generator for the project's documentation website.

(repo-wide) · high confidence

Added a new \WasiFileSystem\ implementation that enables file system operations on WebAssembly targets by wrapping the WASI preview1 API. This change introduces the core file handle classes (\FileSink\, \FileSource\, \WasiFileHandle\) and the \WasiFileSystem\ singleton, which maps Okio's \FileSystem\ interface to WASI functions like \path\_open\, \fd\_read\, and \fd\_write\. The implementation includes internal support for WASI types (such as \Errno\, \Rights\, and \OFlags\) and handles preopened directories to restrict file access to allowed paths.

okio-wasifilesystem/src · high confidence

Adds an expect declaration for the FileSystem.SYSTEM property in the shared source set, establishing the contract for accessing the host file system across platforms. This change provides the foundational API definition that allows platform-specific implementations to supply the actual system file system instance, enabling consistent access to the host file system in multiplatform code.

okio/src/systemFileSystemMain · high confidence

This change adds the \UnixFileHandle\ class and \UnixPosixVariant\ implementation to the \okio/src/unixMain\ source set, providing the concrete native backend for file operations on Unix-like systems. \UnixFileHandle\ implements low-level file I/O (read, write, flush, resize, close) using POSIX functions like \fstat\, \pread\, \pwrite\, and \ftruncate\, while \UnixPosixVariant\ supplies the platform-specific logic for the \PosixFileSystem\ interface, including directory listing, canonicalization, and file opening modes. This constitutes the core native implementation layer for file system access on these platforms.

okio/src/unixMain · high confidence

This change introduces the first-class implementation of Okio's file system APIs for the mingwX64 (Windows) target. It adds Windows-specific source files that provide native file handle operations (read, write, flush, resize, close) using Windows API calls, implements platform-specific file system variants (such as path canonicalization, directory listing, and metadata retrieval), and defines the temporary directory and path separator conventions for Windows. Users can now perform file I/O operations on Windows via the mingwX64 platform with parity to other supported platforms.

okio/src/mingwX64Main · high confidence

Okio now provides a complete native file system implementation for Kotlin/Native, exposing a \FileSystem.SYSTEM\ singleton that wraps POSIX operations (reading, writing, listing, symlinks, and directory management) via \PosixFileSystem\. This change introduces native-backed \FileSource\ and \FileSink\ for direct file access, along with \InflaterSource\ and \DeflaterSink\ that leverage the platform's zlib bindings for on-the-fly decompression and compression, allowing users to handle compressed streams natively without JVM dependencies.

okio/src/nativeMain/kotlin/okio · high confidence

Okio now provides native implementations for CRC32 checksums and DOS date parsing on Kotlin/Native. The new CRC32 class wraps the platform zlib library to compute checksums for data streams, while the internal date math functions enable correct handling of file modification times in ZIP archives without relying on external date libraries. These changes ensure that compression and archive features work correctly on native targets.

okio/src/nativeMain/kotlin/okio/internal · high confidence

The FakeFileSystem API surface has been updated to include a new close() method, allowing users to explicitly release resources. Additionally, the class now supports initialization with a Clock parameter (both kotlin.time.Clock and kotlinx.datetime.Clock), enabling time-based testing scenarios. The API also exposes properties for configuring file system behaviors such as allowing symlinks, clobbering empty directories, and managing open file access rules.

okio-fakefilesystem/api · high confidence

This release introduces the \okio-assetfilesystem\ module, providing a \FileSystem\ implementation that exposes an Android application's \assets/\ directory. Users can convert an \AssetManager\ to an Okio \FileSystem\ using the new \asFileSystem()\ extension function, enabling standard read-only file operations (such as \source\, \list\, and \metadataOrNull\) on bundled app assets. The implementation includes comprehensive instrumentation tests to verify path canonicalization, directory listing, and file reading behaviors.

okio-assetfilesystem · high confidence

Added a suite of new Kotlin sample files in the JVM samples directory to demonstrate Okio capabilities, including a BMP BitmapEncoder, UTF-8 charset exploration, SHA-256 and HMAC hashing, Java IO file integration, a TeeSink for dual-output writing, a SOCKS v5 proxy server implementation, and serialization via GoldenValue.

samples/src/jvmMain/kotlin · high confidence

A new build-support module has been introduced to centralize and standardize the project's build logic. This includes a new BuildSupport plugin that enforces JVM 1.8 compatibility and integrates Dokka and the Binary Compatibility Validator. The module also introduces comprehensive Kotlin Multiplatform platform configuration (kmp.kt, platforms.kt), enabling JS, Native (including Apple Silicon, Linux ARM64, and various watchOS/tvOS targets), and WASM targets, with the ability to selectively disable JS, Native, or WASM via system properties. Additionally, it adds automatic BOM constraint collection for published subprojects and standardizes source set creation for shared code.

build-support · high confidence

The okio-testing-support module has been introduced to provide utilities and support for testing Okio itself, explicitly noting it is not intended for use by other projects or consumers. This module includes a comprehensive AbstractFileSystemTest suite that validates filesystem behaviors such as symlink traversal, canonicalization, and metadata handling across various platforms. It also introduces platform-specific implementations for environment variable access (getEnv) and browser detection (isBrowser) for JVM, JS, Native, and WASM/WASI targets, alongside testing infrastructure like FakeClock, TestDirectory, and TestExecutor to manage temporary directories and execution contexts during tests.

okio-testing-support · high confidence

This change provides the actual implementations for Okio's core I/O abstractions and hashing utilities on non-JVM targets (such as Kotlin/Native and Kotlin/JS). It introduces the \Buffer\, \BufferedSource\, and \BufferedSink\ interfaces along with their \RealBufferedSource\ and \RealBufferedSink\ implementations, enabling standard read/write operations. It also adds \HashingSource\ and \HashingSink\ classes that allow users to compute MD5, SHA-1, SHA-256, and SHA-512 hashes (including HMAC variants) while streaming data. Additionally, it includes \ForwardingSource\ for delegation patterns, \Path\ for file path manipulation, and foundational platform types like \Timeout\, \Sink\, \Source\, and \Closeable\.

okio/src/nonJvmMain · high confidence

The foundational Okio types—Buffer, BufferedSource, BufferedSink, ByteString, and the FileSystem abstraction—have been moved into the commonMain source set, making them available across all Kotlin platforms (JVM, Native, and JS) without platform-specific workarounds. This change introduces expect/actual declarations for core classes and interfaces, standardizes Base64 encoding/decoding with optional padding, and provides a unified FileHandle API for streaming and random-access file I/O, allowing developers to write file and byte manipulation logic once for all targets.

okio/src/commonMain/kotlin/okio · high confidence

File metadata retrieval on Apple platforms now uses the appropriate system call for each architecture: macOS x64 uses \stat64\ and \lstat64\, while other Apple platforms (e.g., iOS, tvOS) use \stat\ and \lstat\. This ensures correct file attribute access across different Apple targets by selecting the variant that matches the platform's ABI requirements.

okio/src/appleNonMacosX64Main, okio/src/macosX64Main · high confidence

The build process now automatically generates API documentation using Dokka (HTML output) and publishes it via MkDocs on the CI server. The new \prepare\_mkdocs.sh\ script handles the Dokka generation and organizes the output under the \docs/3.x\ directory, while also copying essential files like the changelog and contributing guide. Additionally, a \restore\_v1\_docs.sh\ script has been added to facilitate the restoration of legacy 1.x and 2.x documentation from specific git commits, ensuring historical API references remain accessible on the website.

.buildscript · high confidence

A new ABI dump file has been added to define the public API surface of the okio-wasifilesystem library for the wasmWasi target. This change enforces binary compatibility by explicitly listing the public symbols of the WasiFileSystem class, ensuring that future releases maintain a stable interface for consumers relying on this Kotlin/Native library.

okio-wasifilesystem/api · high confidence

The in-memory FakeFileSystem now operates in a strict mode by default, preventing dangerous operations such as moving or deleting files that are currently open for reading or writing, moving files to replace empty directories, and opening the same file for both reading and writing simultaneously. This change improves test reliability by catching resource leaks and invalid file operations that might be silently ignored or behave inconsistently on real file systems. Users can still opt out of these restrictions by setting properties like allowMovingOpenFiles or allowDeletingOpenFiles to true, or by calling emulateWindows() or emulateUnix() to apply platform-specific constraints.

okio-fakefilesystem/src · high confidence

The ByteString hex decoding implementation for JavaScript has been replaced with a custom, native JavaScript function to significantly improve performance. This change addresses the inefficiency of the previous Kotlin-transpiled code, reducing CPU usage for hex decoding operations from approximately 25% to 0% in benchmark measurements.

okio/src/jsMain/kotlin/okio/internal · high confidence

On Linux platforms, Okio now prefers the \statx\ system call over \stat\ to retrieve file metadata. This change enables access to the file creation time (birth time) when the underlying kernel supports it, providing more accurate timestamp information for files. The implementation includes a fallback to the traditional \stat\ call for older kernels that do not support \statx\, ensuring compatibility across different Linux versions.

okio/src/linuxMain · high confidence

The internal implementation details for core Okio components—specifically Buffer, ByteString, SegmentedByteString, RealBufferedSink, RealBufferedSource, Path, and FileSystem—have been consolidated into shared Kotlin/Common code. This change centralizes the logic for operations such as UTF-8/UTF-16 encoding, hex/base64 conversion, path resolution, and segment management, ensuring consistent behavior across all supported platforms rather than relying on separate platform-specific implementations.

okio/src/commonMain/kotlin/okio/internal · high confidence

The internal ZIP and GZIP implementations in the zlib module are now multiplatform, enabling these features on Kotlin/Native. This change introduces platform-specific expectations for core utilities like CRC32 calculation and date conversion, and updates the ZipEntry logic to prefer NTFS timestamps when available, falling back to extended or DOS timestamps. Additionally, GzipSink and GzipSource are now available across all supported platforms.

okio/src/zlibMain/kotlin/okio/internal · high confidence

The library introduces a new internal \DefaultSocket\ implementation that wraps \java.net.Socket\ to provide independent \Source\ and \Sink\ streams, allowing input and output to be closed separately without shutting down the entire socket. This implementation includes robust error handling for specific Android SSLSocket crashes and timeout scenarios. Additionally, \ResourceFileSystem\ has been updated to lazily initialize its classpath roots and explicitly disable URL connection caching for JAR files to prevent stale resource reads.

okio/src/jvmMain/kotlin/okio/internal · high confidence

A new \ByteStringNonJs.kt\ file provides the \commonDecodeHex\ implementation for non-JavaScript platforms, parsing hex strings into byte arrays. This change establishes the platform-specific logic for hex decoding on non-JS targets, ensuring consistent behavior across the library's multiplatform architecture.

okio/src/nonJsMain · high confidence

This change introduces the Okio 2.x API surface on the JVM, replacing the legacy static utility classes (Okio, Utf8) with extension functions and sealed interfaces (BufferedSource, BufferedSink). It provides the concrete JVM implementations for core types like Buffer, ByteString, and FileSystem, including support for file system operations (symlinks, mustCreate/mustExist flags), asynchronous timeouts, and cryptographic/compression sinks (CipherSink, DeflaterSink). Legacy static methods are deprecated with ERROR-level deprecation to guide users toward the new extension-based API.

okio/src/jvmMain/kotlin/okio · high confidence

The public API surface for Okio has been updated to include new features such as unsigned number extensions (read/write UByte, UShort, UInt, ULong), a new \Socket\ interface with cancellation support, and additional methods on \BufferedSource\ and \BufferedSink\ like \utf8Appendable\ and \select\ with \TypedOptions\. The \FileSystem\ now exposes a \SYSTEM\ property and a \close()\ method, while \AsyncTimeout\ and \Timeout\ implementations now support cancellation. This change also introduces binary compatibility validation for Kotlin/Native to ensure stable public APIs across platforms.

okio/api · high confidence

The Okio library has restored support for Kotlin/JS targets, including both Node.js and browser environments. The new implementation in \JsPlatform.kt\ provides platform-specific utilities by dynamically requiring Node.js \os\ and \path\ modules where available, while falling back to safe defaults (such as \/tmp\ for the temporary directory) to ensure compatibility in browser contexts where Node.js globals are absent. This change re-enables file system operations on JS platforms by introducing a concrete \FileSystem\ implementation that delegates to these platform-specific helpers.

okio/src/jsMain/kotlin/okio · high confidence

Add common multiplatform test suite for Okio core types; Added JVM tests for internal utilities; Added JVM tests for sample channel and source marker functionality; Added native test coverage for compression and file system APIs; Added test resources for non-ASCII file paths; Added tests for CRC32 and ZIP DOS date handling; Added tests for Gzip and ZipFileSystem functionality; Added tests for NSData to ByteString conversion on Apple platforms; Added tests for non-WASM file system implementations; Migrated JVM tests to JUnit 5 and adopted Burst for parameterized testing; New JMH benchmarks for Okio performance profiling.

This release updates the project's build configuration to use Gradle version catalogs (defined in gradle/libs.versions.toml) and upgrades key dependencies, including Kotlin to 2.2.21, the Android Gradle Plugin to 9.4.0, and Spotless to 8.0.0. It also introduces new build modules for Android testing (android-test), a Bill of Materials (okio-bom), and a WASI filesystem implementation (okio-wasifilesystem), while configuring the Vanniktech Maven publish plugin for automatic releases to Maven Central.

(dependencies) · high confidence

The project's Gradle wrapper has been updated to use Gradle 9.7.1. This ensures that builds are executed with this specific version of the Gradle build tool, providing consistency across development environments and leveraging any improvements or bug fixes included in this release.

gradle · high confidence

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

• CAI 41 → 58 (+17.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 90 → 90 (-0.1)
• Architecture 94 → 100 (+5.9)
• Maturity 50 → 50 (+0.2)
• Readiness 26 → 55 (+29.4)
• Security 40 → 62 (+21.8)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (12 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (13 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (13 lines × 2) (okio/src/commonMain/kotlin/okio/HashingSource.kt)
• Duplicated block (13 lines × 2) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• Duplicated block (14 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (14 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (14 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (15 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (15 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (15 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (16 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (16 lines × 2) (okio/src/commonMain/kotlin/okio/internal/ByteString.kt)
• Duplicated block (16 lines × 3) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (16 lines × 5) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (17 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (17 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• Duplicated block (18 lines × 2) (okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt)
• …and 87 more

• Base64Kt.decodeBase64ToArray (cognitive 19) (okio/src/commonMain/kotlin/okio/Base64.kt)
• Base64Kt.decodeBase64ToArray (cyclomatic 19) (okio/src/commonMain/kotlin/okio/Base64.kt)
• BufferKt.commonIndexOfElement (cognitive 25) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• BufferKt.commonReadDecimalLong (cognitive 31) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• BufferKt.commonReadDecimalLong (cyclomatic 19) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• BufferKt.commonReadHexadecimalUnsignedLong (cognitive 24) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• BufferKt.commonSeek (cognitive 16) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• BufferKt.commonWrite (cognitive 16) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• BufferKt.commonWriteUtf8 (cognitive 17) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• BufferKt.selectPrefix (cognitive 65) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• BufferKt.selectPrefix (cyclomatic 19) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Duplicated block (10 lines × 4) (okio/src/hashFunctions/kotlin/okio/internal/Md5.kt)
• Duplicated block (11 lines × 2) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• Duplicated block (11 lines × 2) (okio/src/jvmMain/kotlin/okio/JvmOkio.kt)
• Duplicated block (11 lines × 3) (okio/src/hashFunctions/kotlin/okio/internal/Sha1.kt)
• Duplicated block (12 lines × 2) (okio/src/commonMain/kotlin/okio/internal/Buffer.kt)
• Duplicated block (14 lines × 2) (okio/src/appleNonMacosX64Main/kotlin/okio/NonMacosX64PosixVariant.kt)
• Duplicated block (14 lines × 2) (okio/src/jvmMain/kotlin/okio/HashingSource.kt)
• Duplicated block (15 lines × 2) (okio/src/hashFunctions/kotlin/okio/internal/Sha256.kt)
• …and 109 more

• 25 commits — 23 feature/other, 2 fixes

• .github/workflows — 11 commits
• gradle/libs.versions.toml — 6 commits
• (root) — 3 commits
• gradle/wrapper — 2 commits
• okio/src — 2 commits
• .github/renovate.json5 — 1 commit

• fix: Fix an unintended behavior change with base64 padding (#1869)
• fix: Update BUG-BOUNTY.md (#1872)
• change: Document Okio 3.18.2
• change: JamesIves/github-pages-deploy-action 3.7.0
• change: Migrated JVM tests from JUnit 4 to JUnit 5 (#1862)
• change: New 'No Generative Tools' section in contributing doc (#1847)
• change: Pin actions/setup-python action to 5fda3b9 (#1859)
• change: Update Gradle to v9.7.0 (#1843)
• change: Update Gradle to v9.7.1 (#1850)
• change: Update JamesIves/github-pages-deploy-action action to v3.7.1 (#1860)
• change: Update JamesIves/github-pages-deploy-action action to v4 (#1861)
• change: Update actions/checkout action to v7.0.1 (#1854)
• change: Update actions/setup-java action to v5.7.0 (#1856)
• change: Update actions/setup-java action to v6 (#1867)
• change: Update actions/setup-java action to v6.0.1 (#1873)
• change: Update actions/upload-artifact action to v7.0.1 (#1855)
• change: Update dependency biz.aQute.bnd:biz.aQute.bnd.gradle to v7.4.0 (#1848)
• change: Update dependency com.android.tools.build:gradle to v9.3.2 (#1866)
• change: Update dependency com.android.tools.build:gradle to v9.4.0 (#1870)
• change: Update dependency com.google.jimfs:jimfs to v1.3.2 (#1849)
• …and 5 more

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

• jmh
• okio
• okio-testing-support
• okio-wasifilesystem
• samples

• okio-testing-support → okio
• okio-wasifilesystem → okio
• samples → okio

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

lysine-dev/okio 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.