youndie@kotlin.website:~/src$ cat proba/README.md

proba

jvm · maven · publishing · github action
What a consumer actually gets when they add your library: reads a published artefact from the other side of the wire — module metadata, POMs, jars, klibs — and confirms what reading cannot with a real consumer build. A CLI, a GitHub Action and a badge.

Why it exists

The build is green, the tests are green, the publish is green — and the artefact is still wrong. Everything that checks a library runs inside its own build and shares the author's assumptions. A module whose every dependency is implementation compiles, tests and publishes without a word of complaint, and the metadata it ships says a consumer needs nothing but the standard library. Only a consumer finds out.

proba looks from the consumer's side. It reads what is actually published — Gradle module metadata, POMs, jars, klibs — and, where reading is not enough, resolves the coordinate with a real build and reports what lands on the classpath.

What it looks for

check the question
version-in-declared-name does the file a consumer receives carry the version that was published?
dangling-redirect is every target the root module points at actually there?
component-matches-path does the module document agree with the coordinate it is published under?
api-omits-sibling does what the api variant advertises cover the siblings the run time gets?
api-unreachable can a consumer name every type the public API hands out?
bytecode-java-version is the Java the classes require one a consumer can find out about?

Findings come in three severities, and each is a word before it is a colour. A defect is wrong and can be pointed at. A suspicion is a shape defects take that the metadata cannot tell apart from the correct case — which is why the confirming tier exists. An undetermined is a check that could not run here, and it never fails a build.

The first thing it found

Two published versions of kompot put a file with the same name on the consumer's classpath — 0.27.0.45 and 0.27.0.46 both arrived as kompot-core-jvm-0.27.0.jar. Anything that tells artefacts apart by file name — an SBOM, a licence scanner, fat-jar deduplication — could not tell them apart. It was reported, fixed, and on 0.27.1 the same check is silent. That loop is the shape of the whole thing.

Running it

./gradlew :resolver:installDist
./resolver/build/install/resolver/bin/resolver io.ktor:ktor-client-core:3.4.0          # from the repository alone
./resolver/build/install/resolver/bin/resolver io.ktor:ktor-client-core:3.4.0 --deep   # with a real consumer build

In a build, as a GitHub Action that runs on the runner — so a publication you have not released yet is never handed to somebody else's service:

- uses: youndie/proba@main
  with:
    coordinate: io.github.youndie:kompot-core:0.27.1.50
    deep: "true"        # the only way to confirm a suspicion
    fail-on: defect     # defect | suspicion | none
    badge-dir: badges   # optional: a badge written by the build

The badge's left half names the artefact, not the tool, and its state is a word — clean, 2 defects, 1 unchecked — because 1 unchecked is not clean.

How it is kept honest

A check without a case where it must fire is not written. Staying quiet is also what a check does when it cannot run, so every check carries a case on each side, and a guard per check fails the build when one is missing. The library published with a defect on purpose lives in the repository beside the correct one, switched by one word.

The server is Kotlin and Ktor and describes each report as a kompot screen; the shareable report pages are Next.js with a React renderer for kompot screens. Its documentation is in Russian.