Horizon.Config.Schema

A git repository, as a URL.

A source subdirectory within a repo or tarball. A real relative directory (parsed at the fold boundary), so the writers can place it into cabal2nix's subpath directly.

A Hackage package pinned to a version.

A git package: repo, revision, optional subdirectory.

A tarball package: url, optional subdirectory.

A local package: its source is a subdirectory of the config's own repo (inputs.self), not a fetched artifact. Lets a set include a project developed alongside it — the code you are writing here — rather than only upstream releases.

A secure cabal repository a set pins packages from: its name (the one cabal keeps its index under), its URL, how many root keys must sign its root metadata, and the root key ids.

A package pinned to a version in a secure repository other than Hackage. The repository is part of the source, so a pin that moves to another repository, or a repository that changes its URL or keys, is a different pin.

Where a package's source comes from.

Per-package build modifiers the writer applies (jailbreak, run tests, include benchmarks, …).

The default: build the library (and executables) only, no tests/benchmarks, no jailbreak, no profiling, haddock on.

A cabal flag toggle for a package.

A native library a package binds: the callPackage argument its derivation takes and the nixpkgs attribute that supplies it, e.g. libblst from pkgs.blst. Usually the two are the same name.

A package in the set. What is genuinely per-package: where its source comes from, source patches, native (system) libraries it binds, and its cabal flags. Build policy (jailbreak, tests, …) is NOT here — that is a neighbourhood property of the whole set (Modifiers on PackageSet), all-or-nothing by design.

A package from a source, with no per-package overrides.

The packages in a set, by name.

A whole package set: a compiler, the set-wide build policy (Modifiers — the neighbourhood property applied uniformly), and the packages.

An overlay: the packages a base set is missing, as a package set.

What a repository declares about the Haskell it builds, beyond its pins: the licence, the warnings contract, the default language and extensions of its packages, and the nixConfig of its flake. A set that declares none of it is noRepoScope.

A test suite of a local package: its name and the file it runs.

What a repository declares about one of its local packages beyond its pin: the modules it exposes and keeps internal, its test suites and the backends it builds for. A package with none is noPackageFacts.

The directory the per-package .nix files are written into (pkgs).

The file a whole package set is written to (e.g. initial-packages.nix).

The file an overlay is written to (e.g. overlay.nix).

Everything the writer needs to emit a package set.

Everything the writer needs to emit an overlay.

Which export a config asked for.

Where a repository lives: forge "nixlab.openfp.net/…".

The branch a repository is followed on: branch "lts/ghc-10.0.x". The commit is the flake lock's, not the config's.

A repository and the branch it is followed on.

A package set another set is layered on: its name and where it lives.

What a set is built on. A Toolchain is the bottom of a chain: the set is built from scratch with its compiler and build tools. A Layer is an overlay on a lower package set, whose packages, versions and compiler the set takes as given.

A lower package set, as a base: set "horizon-core" (forge …) (branch …).

A toolchain root, as a base: toolchain (forge …) (branch …).

The flake input a base is: a lower set's name, or a toolchain's repository name, the last segment of its path.

A Hackage package at a version.

A git package: repo, revision, optional subdirectory.

A tarball package: url, optional subdirectory.

A package whose source is a subdirectory of the config's own repo.

A package at a version from a secure repository other than Hackage.