# proba

> What a consumer actually gets when they add your library: proba reads a published Maven artefact from the other side of the wire, and confirms what reading cannot with a real consumer build. A CLI, a GitHub Action and a badge.

Page: https://kotlin.website/proba

## 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](https://github.com/youndie/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](https://kotlin.website/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

```bash
./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:

```yaml
- 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.
