Adopt

Four commands, then the one that judges us instead. Each was run before it was printed here, against the tag it names. Which of these is worth your time is Cases.

A version appears below only where a command has to pin one, and it is the tag that command was run at — never a claim about which tag is newest. A tag list cannot drift, so each command links the one that answers "which release". Commands 1, 3 and 4 checked 2026-09-10 against the tags they name, with Go 1.26.5 on Windows 11, in an empty module cache with no workspace: each resolved from the Go proxy and was verified against sum.golang.org, and the program in step 3 compiled against the modules it fetched. Command 2 was last run 2026-09-08, against an earlier tag, in a store in a scratch directory (ABSTRACTION_STORE): the transfer was killed by process id at 33.7 MiB of 87.6, the second run picked up at 33.7 MiB after the dead lease's thirty seconds, and the file's SHA-256 matched the one Hugging Face publishes for it. Linux was last checked 2026-09-08, against earlier tags; macOS is UNPROVEN.

1 · Run it

go install github.com/openabstractions/abstraction-download/go/cmd/dl@v0.4.1

Go 1.26 or later. That pin is the tag the command was run at; the tag list is the answer to "which release". No file to download and no checksum to compare: Go builds dl from source and checks every module against sum.golang.org, which proves the bytes are the ones everyone else fetched and says nothing about who wrote them. Nine modules, eight of them ours and golang.org/x/sys. Nothing is signed.

2 · Fetch something, kill it, fetch it again

dl https://huggingface.co/bartowski/SmolLM2-135M-Instruct-GGUF/resolve/main/SmolLM2-135M-Instruct-Q4_0.gguf

The first line printed is dl: nothing on this machine answers questions; fetching from huggingface.co unasked: before reaching a host for the first time dl asks whatever on this machine answers questions a program may put to a person — the asks and rights layers — and on a machine with neither it says so and proceeds. Ctrl+C it halfway. dl list still shows the job and how far it got. Run the same line again: it resumes from the last byte it can prove, with no flag — after waiting out the dead run's thirty-second lease, which it does in silence. dl watch is the live view. -o <path> names the destination; --digest sha256:… makes a corrupt answer from the server a refusal rather than a file — without it, dl corrupts exactly as curl does. A flag dl does not know, or a flag with nothing after it, is refused with exit 2 before anything is fetched — measured at the tag step 1 names; an earlier tag ignored both without a word, and a mistyped --digest was an unverified file and exit 0.

What is on disk after the kill: the partial file beside the destination, and under the store — the directory of job records — a record naming the URL, the destination, the progress and the lease. Where that store is: dl tiers prints it, along with the ordered list of places a download may run — a NAS, a platform service, this process. Here it prints supervisor none — downloads run in this process and stop when it does. The recording on the overview is the other arrangement: jobd running, a request dropped into its wanted/ folder, and nothing to re-run. service-jobd has the commands that set it up; they were not run for this page.

3 · Call it from a program

go get github.com/openabstractions/abstraction-facade/go@v0.4.0

The pin is the tag this was run at; the tag list is the answer to "which release".

package main

import (
	"fmt"
	"os"

	abstraction "github.com/openabstractions/abstraction-facade/go"
)

func main() {
	a, err := abstraction.Discover()
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	h, err := a.Download().Get(os.Args[1], os.Args[2])
	fmt.Println(h, err)
}

Discover() reads the machine — no path, no flag in the caller — and answers with the layers as this machine provides them: Download(), Jobs(), Storage(), Log(). Get returns at once with a handle; h.Wait(ctx) blocks until the bytes are here and takes delivery — moves the finished file to its destination and marks the job complete. Whether the transfer runs in this process, in a service on this machine, or on a NAS is the machine's configuration, not the call site's: one binary written against this interface was run against three providers in nine situations (the table). What every method promises is on the reference. The application learns no word from that page; the words are for step 4.

4 · Implement it, or wrap a downloader an application already has

go get github.com/openabstractions/abstraction-download/go@v0.4.1

The pin is the tag this was run at; the tag list is the answer to "which release".

The download module carries the Client interface, the Runner that claims a record and drives it to delivery, the fetchers that move the bytes, and the scenario corpus every implementation is replayed through. The worked example of such a wrapper is dlc: one C++ header over curl, no dependency, sharing no transfer code with dl. It takes the same flags, answers in the same five words — delivered, working, unavailable, forbidden, unknown — and agrees with dl on all eighteen HTTP statuses in the contract's list and on 50 of 54 wire cases — the matrix. It is not published yet. The naming convention for an implementation over somebody else's engine is abstraction-<layer>-over-<engine>; ours is -over-native, one implementation among peers, and none is published under that name yet because interface and implementation still share one module.

The rules an implementation must satisfy are the contract pages, where every rule carries a tag a scenario can cite — job, its state machine, download — and the scenario corpus: each scenario is a text file of commands and the transcript they must produce, replayed against every implementation and compared byte for byte. A scenario an implementation cannot reach is printed as UNPROVEN and counted; it is never skipped. You do not have to take our replay for it: step 5 is the same corpus, run by you against your own program.

5 · Judge it without our help

The conformance suite judges your implementation against the rules on the contract pages. It needs a POSIX shell and your own program. It does not need our source tree, our build, or Go.

curl -L https://codeload.github.com/openabstractions/abstractions/tar.gz/refs/heads/main | tar xz
cd abstractions-main/conformance
sh selftest.sh
sh run.sh -- ./my-driver

DRIVER.md is the whole of what your driver must do — a page of behaviour: it applies a scenario and prints what an observer saw. --capabilities is how it says what it does not implement, and a scenario needing something it did not declare is reported unreachable with the missing capability named, rather than failing a rule it never claimed. sh run.sh --scenarios identity -- ./my-driver asks for the identity rules instead of the download and job ones. The wire scenarios want a Python 3 for the fixture that serves a lying Content-Range and the rest; without one, --no-fixture, and every wire scenario reports unreachable, which is the honest answer.

Out of reach is never a pass. A scenario your driver cannot run, a fixture that would not start, a capability you did not declare — each is counted and named, and the run exits 2. Exit 0 means every rule the suite could reach was kept; 1 means a rule broke. The rules have tags, every expectation cites one, and a run with no contract page compares steps and judges no rule: contracts.list names each page and where to fetch it, and a page the run needed and did not have is named with the command that gets it. With the pages in place the runner also reports which written rules no scenario reaches.

sh selftest.sh is the suite checking itself: toy drivers that declare nothing, answer ok to everything, admit they have no HTTP, or answer with a superset of the right answer — the runner has to call each of them not set up, failed, incomplete or refused. If it calls any of them green, do not trust the rest.

A passing run says your implementation keeps the rules these scenarios reach. It does not say the contract is complete, and it does not say ours is right. If your driver fails a rule you believe you keep, that is worth telling us — a suite only we can run cannot tell a correct contract from one design transcribed three times. The suite's own page says the same, at length.

The four lines above were run in that order on 2026-09-10, on a desktop-class Windows 11 machine, in an empty scratch directory, with no clone of our tree and nothing of ours built: the tarball unpacked, the selftest passed, every page contracts.list names was fetched, and run.sh judged a deliberately generous toy driver and returned FAILED with the rule and the step. Linux and macOS were not used: UNPROVEN.

Python and C++

Python is going onto PyPI a layer at a time; C++ has no tagged release. No install line is printed here, because none has been run from a clean machine, and which layers are up is not typed here: the index is the answer to that, the way a tag list is the answer to "which release". Both live beside Go in each layer's repository — python/ and cpp/ under abstraction-download and abstraction-job — and each is held to the same corpus: Go and Python finish each other's downloads in both directions (XLANG-DOWNLOAD.txt), and six writers in three languages made 600 changes to one file and lost none (CAS-MIXED1.txt). Python is standard library only; C++ takes nothing, including a JSON library.

The services, and what is not here

service-jobd is the supervisor that finishes work nobody is watching; addon-synology packages it for a Synology NAS and docker-jobd for a container; adopter-comfyui puts ComfyUI-Manager's model downloads behind a job record without forking ComfyUI. Each builds from its repository. None has a release file to download yet, and none is signed; when a package is published here it will say which of those two things is still true.

Faults and governance

A fault goes through SECURITY.md. A proposal to change a contract is a pull request carrying the scenario that would prove it. Who decides, and what happens if the maintainer stops, is GOVERNANCE.md. Apache-2.0 throughout; nothing copyleft comes in.