dk packages /

CommonsLang_OCaml 0.1.20260922101105

Relocatable OCaml compiler toolchains and developer tools (the OCaml compiler, flexdll, dune, opam, and Diskuv's DkML MSVC track) as dk packages for Windows, Linux, and macOS.

Apache-2.0 AND LGPL-2.1-only WITH OCaml-LGPL-linking-exception AND LGPL-2.0-only WITH OCaml-LGPL-linking-exception AND LGPL-3.0-or-later AND GPL-2.0-only AND Zlib AND MIT AND GPL-3.0-or-later AND BSD-2-Clause AND Info-ZIP Source → Generated

Relocatable OCaml compiler toolchains and developer tools (the OCaml compiler, flexdll, dune, opam, and Diskuv's DkML MSVC track) as dk packages for Windows, Linux, and macOS.

CommonsLang_OCaml builds and redistributes an OCaml developer toolchain (the OCaml compiler, runtime, and standard library at 4.14.3, 5.4.1, and 5.5.0-beta1, the flexdll linker, dune 3.23.1, and opam 2.5.1) across the dk build system's Windows, Linux, and macOS slots. It also ships Diskuv's Apache-2.0 DkML MSVC track and an MSYS2 tree used to build and run the Windows toolchain. Because it is assembled from many upstreams, its redistributed payload carries several licenses in combination.

Resolution of imports

When a workspace drives per-package opam builds through Dk.OpamLock.GenerateDriver + Dk.OpamBuild.F_BuildLockedPackage and declares one or more package-import sources (imports[]), the generated driver reuses a locked opam package that a source already built and distributes, fetching the prebuilt object lazily. Resolution runs per package, against the imports[] sources in precedence order.

  1. Read each source's own opam lock. Every import source ships the exact opam lock it was built from. For a CommonsBase_Dk.Dk0.Pkg source that is the dk-opam-lock.jsonc member of its localsrc (CommonsBase_Dk.Dk0.MlFrontSource@<mv>), fetched from the pinned import. That lock is authoritative for which opam package and version each of the source's objects contains.

  2. Map object id to opam package and version. For an opam package <name>.<opamver> in a source's lock, the source provides the dk object <source-lib>.<Segment(name)>@<module-version>, whose version component is the source's release version (imports[].version, for example @2.4.2). The opam version is recorded only in the source's lock, which is what step 3 matches against.

  3. Match on the opam name, version, and dependency environment. For each opam <name>.<needver> the consumer's (with-test) lock requires, a source matches when its lock pins <name> at the same <needver> and records the same dependency environment for it (step 5). On the first matching source the package is imported: the driver stages it with get-object <source-lib>.<Seg>@<mv>, lazily, fetched when a build needs its install.zip, and emits no local build form. A package that no source provides at the required version and dependency environment is built locally through F_BuildLockedPackage, with its own dependencies resolved the same way.

  4. The compiler matches through the top-level ocaml field. Each lock records the OCaml compiler its packages are built with in a top-level ocaml field, a full module id such as CommonsLang_OCaml.DkML@4.14.3001 (or a CommonsLang_OCaml.Base@5.5.x for a 5.5 toolchain); a lock without the field takes the default CommonsLang_OCaml.DkML@4.14.3001. Dk.OpamLock.GenerateDriver reads the ocaml field from both the consumer's lock and each source's lock (already fetched in step 1) and passes it to F_BuildLockedPackage as the ocaml= argument, along with dune=CommonsLang_OCaml.Dune@<v> and (Windows) msys2=CommonsLang_OCaml.MSYS2@<v>. An imported package ships compiled .cmi/.cmx/.cmxa, whose magic numbers are fixed by the compiler, so a source is consumable only when its lock's ocaml equals the consumer's. The dune and msys2 ids leave no trace in the compiled artifacts and stay out of the match.

  5. Match on the dependency environment. A package's built install.zip is a function of which of its optional dependencies were present at build time: the opam solver folds each optional dependency that lands in the solved closure into the package's depends name-set, so that set records the environment. A source's package matches only when, for the package and for every package in its dependency closure, the source's lock and the consumer's lock record the same version and the same depends name-set (compared as a set, since the recorded order follows discovery). Adding an optional dependency to the consumer changes that package's depends set and builds it locally, the way opam rebuilds a package when its optional dependencies change; the same holds when a dependency deeper in the closure resolves to a different version or a different depends set. A package built locally for this reason forces every package whose closure contains it to build locally too. A package the compiler builds into the toolchain, or a purely virtual package, stays out of this comparison; the compiler is already fixed by step 4.

Dk.OpamLock.GenerateDriver imports a package P from a source S when each of these variables is equal between the consumer's lock and S's lock:

  • ocaml: the top-level compiler module id (a lock without the field carries CommonsLang_OCaml.DkML@4.14.3001)
  • version(P): the opam version S pins for P
  • depends(P): P's depends name-set, with the solved-closure optional dependencies folded in, compared as a set
  • version(D): for every package D in P's dependency closure, the opam version S pins for D
  • depends(D): for every package D in P's dependency closure, D's depends name-set, compared as a set

Under skiplocal a package recorded "local":"t" is built in-tree and is never imported. A package that fails any variable is built locally, and that outcome propagates to every package whose closure contains it. The compiler content is checked again at build time by the .dk-provenance gate.

Dk.OpamLock

Run one rule of the CommonsLang_OCaml.Dk.OpamLock scriptmodule so its author-time OpamLock uirule ships in this distribution. Running any rule of a scriptmodule brings in the whole scriptmodule; the marker output is otherwise unused. The value-id is harvested from the first CI run (the DkML pattern).

The scriptmodule carries the uirules a maintainer runs to lock, adopt, and regenerate an opam and dune project: Solve, Adopt, Refresh, OpamVenv, the three Generate rules (GenerateSrc, GenerateDriver, GenerateFinal), and GenerateForms. Each rule declares in M.uirule_capabilities the capabilities it may request: Solve, Adopt, Refresh, and OpamVenv request run and write, and the Generate rules and GenerateForms request write. An engine at 2.4.2.339 or later enforces that manifest as an upper bound and lists every declared capability in its trust prompts and suggested trust grant commands, so a consumer grants a rule's full need in one command.

Adopt carries a first-time adoption end to end: it seeds the pin table, solves, generates the forms, and registers the dk.u assets. It re-solves with --with-test, since the canonical adoption lock is the with-test lock (wtest=f opts out), forwards wdoc=, and takes reuse_lock=t to keep an existing committed lock and regenerate only the build forms. GenerateDriver derives its nine arguments from one pkg=MODULE@VERSION: the formid, pkgpath, version, localsrc, and out path from that token, the roots from the lock's stamped generated.roots, and the rulefn from the CommonsLang_OCaml import. GenerateSrc and GenerateFinal generate the localized-source and thin final forms, GenerateForms runs the fixed trio (Src, driver, Final) from one pkg=, and building the emitted forms requires dk 2.4.2.342 or later.

GenerateSrc emits the assembled tree's dune-workspace root marker: the project's own file, or a minimal (lang dune <X>) that Adopt synthesizes into the dk-owned dk-src/ directory and registers. The marker lets a warm run-object of the final executable read its traces from cache. Adopt forwards its derived root to the form generators, so the reuse_lock=t path works against a minimal-stamp lock whose generated.roots is unrecorded.

The generators emit deterministic archives through the engine's in-process --zip special form: GenerateSrc's localized-source form and GenerateDriver's mergedprefix driver archive produce the same bytes on every platform from the same inputs, and the emitted Src form carries no S7z dependency.

GenerateDriver keys its emission off the rulefn family. An F_BuildLockedClosure rulefn, the default when the import declares one, emits one run-function precommand carrying the whole parameter set, and the closure rule re-derives the per-package plan from the lock at build time. An F_BuildLockedPackage rulefn emits the per-package lines. Import resolution runs at author time, so the emitted line carries resolved impdep_ ids, and it keeps a literal ocaml= token that OpamVenv reads off the raw driver text.

Parallel scheduling is the default; sequential=t opts out, and Refresh injects sequential=t when it replays a driver that stamped neither, so an older driver stays byte-stable. Every stamped tool id and printed message derives from M.id, and in-module cross-calls dispatch through version-unique function bindings (H.Solve, H.GenerateDriver, and the rest).

The generated driver values.jsonc is a committed, on-disk artifact that GenerateDriver and Adopt write, so it costs the maintainer zero typed characters. Its generated stamp powers Refresh mode=check and the CI refresh-check gate, both of which read the on-disk driver; it sits on the include path at scan time, so a fresh clone builds offline before any generator runs; and its formid is a published contract that the thin form and dist/*.u reference by name (Closure@VER). Under the closure shape the driver is one run-function line, so a reviewer reads the build plan as the committed lock plus the closure rule.

How the lock is produced: the OpamLock.Solve uirule launches opam to solve the dependency closure. It runs opam list --resolve to compute the closure and opam show to read each package's version, source, dependencies, and build commands, and never runs opam install. opam has no switch-less solve, since the solver needs a switch's repositories, pins, and os/arch variables, so Solve creates an empty opam switch purely as a throwaway resolution context: it adds the pinned repositories, applies the version pins from dk-opam-pins.txt, path-pins the local packages, then resolves. That switch is an ephemeral local switch in the rule's sandbox, unique per run so no cross-project or cross-run pin leaks into the lock, and the rule removes it once the solve finishes; nothing is installed into it.

The solve universe is hermetic. The opam-lock helper (Apparatus.OpamLockHelper) registers each pin-table repository under a URL-derived dk-owned name and selects only those names for the ephemeral switch, so a pre-existing repository in the machine's opam root stays out of the solve universe. The helper recreates the ephemeral switch on every solve, embeds the work directory in the constraints repository name so concurrent solves sharing one root leave each other's universe intact, and verifies every pin visible in the universe before solving, failing with a message that names the repository that should contain it. Solve passes --with-doc to opam when wdoc is set and stamps wdoc into the lock's generated block, so a with-doc lock carries odoc, the package dune build @doc needs.

Resolving ocaml 5.1.1 as the solve compiler

ocaml is left unpinned so the solve resolves it from the pinned repository commit to 5.1.1, one of the first releases with the corrected ocaml-env, host-arch and conf-mingw-w64 selectors (pinning ocaml in the shared pin table would break the CI build's DkML toolchain). The pinned commit makes that resolution deterministic, and the version is a solve artifact only: the DkML 4.14.3 toolchain ocaml replaces it at build time.

  • ocaml 5.1.1 carries the corrected ocaml-env, host-arch and conf-mingw-w64 selectors, so the solved closure resolves the right platform packages for every slot.
  • The resolved ocaml version drives per-slot mingw selection: 5.1.1 resolves the Windows_x86 slot to the 32-bit ocaml-env-mingw32 toolchain.
  • The DkML 4.14.3 toolchain ocaml replaces this solve compiler at build time, so the lock's ocaml and ocaml-base-compiler entries record only the solve.

Relocatable ocamlfind and ocamlbuild

The solver still resolves ocamlfind and ocamlbuild (so the rest of the closure resolves and both still satisfy their dependents at the resolved version), but when the helper emits these two entries it substitutes a fixed relocatable specification for the solved source and build commands. A stock findlib bakes an absolute stdlib path into topfind and findlib.conf, and a stock ocamlbuild bakes an absolute libdir. Those absolute paths are valid only in the build tree that produced them, so a prebuilt CommonsBase_Dk.Dk0.Pkg.Ocamlfind or Pkg.Ocamlbuild object is unusable once imported into a different build tree (the imported #use "topfind" loads a dead #directory). The relocatable builds write paths relative to the tool's own location, so the imported objects stay usable across build trees.

  • ocamlfind is pinned to dra27's relocatable fork (v1.9.8) and built with -sitelib ".", so findlib writes a relative topfind and findlib.conf.
  • ocamlbuild is pinned to dra27's relocatable-0.14.3 fork (0.14.3 plus the relocatable patch) and built through configure.make with OCAMLBUILD_LIBDIR=.., so ocamlbuild computes its libdir at runtime.
  • Both sources are addressed by git commit, so the pin does not move. The substitution is a property of the lock the helper writes; downstream projects do not list these packages in their dk-opam-pins.txt.
  • The DkML 4.14.3+relocatable toolchain supplies the runtime support the two forks rely on (standard_library_relative, -set-runtime-default), so no compiler change is needed.

Host tools and the hosttoolabi= escape hatch

ocamlfind and ocamlbuild are host tools: their built artifacts are native executables that run on the build host during every later package build (topkg's ocaml pkg/pkg.ml build invokes ocamlfind and ocamlbuild). They are dual-role: the build runs them, and their findlib metadata (stdlib path, ocamlmklib and ocamlc config, arch flags) flows into every later package build. GenerateDriver emits targetabi=Release.target_abi for these two by default, so on a cross slot whose host can emulate the target (Windows_x86 under WOW64, Darwin_x86_64 under Rosetta, Linux_x86 under multilib) the metadata matches the target and the tool still runs. This is the dual-role convention in SPECIFICATION "Object Slot ABI".

The hosttoolabi=SLOT parameter restores Release.execution_abi for a matrix that contains a cross slot the host cannot emulate. Building a host tool at the target ABI there produces a binary the host cannot run: on Release.Linux_x86_64_musl the tool links against the target musl toolchain and becomes a musl-dynamic executable, and the glibc host that runs it during the build lacks the musl loader. The opam-build form is host-keyed and carries the Release.target_abi wildcard in its value-id, so a single such build is stored under one key and shared to every slot, including the glibc Release.Linux_x86_64 one, where the tool then fails to exec. A consumer whose matrix includes such a slot passes hosttoolabi=Release.execution_abi to keep the host tools host-native, guarding that musl hazard.

Refresh: self-describing regeneration

The lock and the driver stamp their inputs, and the Refresh uirule reads those stamps back. Solve records roots and pins (and wtest and local_opam_dir when set) in the lock's generated block, and GenerateDriver records its full parameter set in a top-level generated member of the driver values.jsonc, right after schema_version. MlFront's value reader pulls members by name and ignores an unknown top-level member, so the stamp needs no dk-value schema change. A consumer regenerates from the stamp rather than re-copying the roughly ten parameters, and CI detects a stale driver in seconds.

Refresh has four modes. Default (driver) regenerates the driver from the existing lock using the stamped parameters, so a routine repin never silently changes solved package versions; when the lock is not checked in (a consume-from-archive consumer), it substitutes the target rulefn in place, which equals a full regeneration for a rule-version-only move. mode=solve fetches opam hermetically, re-solves the lock from its stamped roots and pins, then regenerates. mode=check is read-only: it compares each driver's stamped rulefn and tool against the newest the imported etc/dk/i/CommonsLang_OCaml.<ver>.values.json declares (and, when the lock is checked in, the stamped lock-sha256 against the lock on disk), prints the exact fix command, and exits nonzero when stale. version=NEW rewrites the coupled version, formid, and localsrc and regenerates.

An unstamped driver carries no stamp; the first driver-mode Refresh recovers its parameters from the generated text and emits the stamped form. mode=check on an unstamped driver recovers the rulefn, fails when that rulefn is stale, and otherwise prints an "unstamped: run Refresh once to adopt" advisory and exits zero, so CI adoption stays graceful. The rules are co-versioned: a Refresh rule bakes in its sibling Solve, GenerateDriver, and OpamVenv at the same version and, absent an explicit rulefn=, prefers the newest F_BuildLockedClosure the import declares (falling back to F_BuildLockedPackage); rulefn= remains an explicit override.

OpamVenv: a native dune inner loop

dk's incremental unit is the whole package object: editing one source file and rebuilding re-stages the localized-source object and rebuilds the entire leaf package in a fresh hermetic sandbox, which takes minutes even with every dependency cached. The OpamVenv uirule hands the inner loop to dune. It reuses a GenerateDriver mergedprefix=t skiplocal=t driver, whose whole non-local dependency closure merges into one cached prefix.zip object, and stages that prefix, the DkML compiler, and dune into the project's opam-venv/ directory, so source opam-venv/env.sh && dune build -w recompiles only the edited module and its dependents.

OpamVenv discovers the dev-prefix driver (the sole one whose stamp carries mergedprefix=t, or an explicit driver=), reads its stamp for the formid, lock, and lock-sha256, and refuses to run when the lock on disk no longer matches that stamp (pointing at the Refresh fix command). It get-objects the prefix for the requested slot= (default: the host execution ABI), rewrites the staged prefix to be relocatable (the @OPAM_IP@ dune-package sentinel and findlib.conf), and writes env.sh/env.ps1/env.cmd activators plus a dk-opam-venv.json stamp. A re-run is a no-op when that stamp still matches (force=t overrides); after a lock change, Refresh regenerates the dev-prefix driver and the next OpamVenv re-materializes.

A caller can also skip the driver: formid=ID@VER names the merged-prefix form to get-object directly, so a project whose merged prefix is a released object (a released with-test closure form, for one) needs no dev-prefix driver of its own, and lock=PATH names the lock that prefix was solved from so the stamp records its sha256 and a lock edit forces a rebuild. The stamp also records the formid, and the up-to-date check compares it, so a new closure version is never mistaken for the old one.

The activators also carry the project's declared environment modifications. A committed dk-opam-venv.envmods beside dk.u (or envmods=PATH) holds one modification per line in the specification's grammar (+NAME=VALUE, <NAME=VALUE, -NAME; # comments; ${PREFIX} and ${DKML} stand for the staged prefix and compiler), planned by the engine's envmod library so the ordering and dedupe are the engine's. Each of env.ps1, env.cmd and env.sh renders the same plan after its toolchain block: a prepend adds no separator when the variable is empty in all three, a removal is Remove-Item, unset or cmd's set "NAME=", and the stamp records the file and its sha256 so an edit re-materializes. A project with no such file gets the same activators as before.

The opam venv is additive and host-only: opam-venv/ and dune's _build/ are invisible to git and to dune. dk0 drops a self-ignoring .gitignore ("*") and a dune ("(dirs)") into its t/ store, and the OpamVenv dialog does the same for opam-venv/, so a host dune build never scans them and the reproducible run-object release build is unchanged. It resolves to the same dependency versions and the same DkML compiler the release build uses, driven from the same lock.

An activated venv does not reproduce everything the release gate stages, and the gap is a debt ledger rather than a waiver: the maintainer requires parity for every venv use case, so each item below is a thing to close, and an item a later module bump fixes leaves this list. What the venv does not reproduce today, grouped as the gate sees it:

  • Test toggles the gate sets and the venv leaves to the host or a committed dk-opam-venv.envmods: ENABLE_NETWORK_TESTS, ENABLE_ZIPBOMB_TESTS, OCAMLRUNPARAM=b, MLFRONT_STUBS_BUILD_TYPE, FLEXLINKFLAGS, and the dksdk-coder stublib PATH prepend. MLFRONT_GATE and the DK_SBOM_* keys agree (both unset).
  • MSVC capture on Windows_*: the INCLUDE, LIB and LIBPATH values and the vcvarsall architecture. env.ps1 captures them only when cl.exe is absent and hardcodes x64 whatever the slot= is, so a Windows_x86 venv does not get the x86 mapping from assets/table/msvc-arch/Release.<slot>; env.cmd and env.sh capture nothing and print a note. The gate also derives OCAMLFIND_LDCONF, CAML_LD_LIBRARY_PATH and OCAMLLIB at run time and copies the ocaml*.opt executables on Windows, neither of which the venv reproduces.
  • Host tools that switch tests on or off rather than fail them: sh on PATH (the gate stages MSYS2), node, gh and zig.
  • Network access and the GitHub credential the gate serves through GH_TOKEN; a committed envmods file must never carry that secret.
  • Host platform the gate pins: the Linux glibc floor and assembler, the Linux_x86 32-bit userland, the Darwin Command Line Tools clang, the Windows MAX_PATH junction, and a Visual Studio install carrying the VC.Tools.x86.x64 component.

The localized source, the gate's dev-then-release test sequence and its -j 1, the zero-test refusal, and the CommonsLang_OCaml pin-alignment guard are gate mechanics rather than environment, so the venv does not carry them.

Dk.OpamBuild

Run one rule of the CommonsLang_OCaml.Dk.OpamBuild scriptmodule so its per-package build rule ships in this distribution. Running any rule of a scriptmodule brings in the whole scriptmodule; the marker output is otherwise unused. The value-id is harvested from the first CI run (the DkML pattern).

The scriptmodule provides two build rules over one lock, both built on the same per-package form synthesis (H.synth_package) so they cannot drift. F_BuildLockedPackage builds one locked package per rule instantiation. F_BuildLockedClosure builds the entire locked closure from a single instantiation: it fetches and decodes the lock once, then one submit registers every per-package build form (each its own content-addressed Pkg object) plus an aggregate .Built output form whose unordered get-object precommands demand every package concurrently. A rule instantiation cannot be trace-cached, so the closure rule instantiates once for the whole closure and a warm run pays that cost a single time. Registering the whole closure in one values document derives every per-package Pkg value-id from that document's canonical id, so a lock edit that alters any package's form re-keys the whole closure and a consumer re-harvests every \dk.object.

The closure rule emits each external locked source as two mirrors of one asset: the opam content-addressed cache first, named by its hash, and the direct opam URL second, named by its basename. The opam cache mirrors opam-repository sources only, so a source the cache never held, such as the custom relocatable ocamlfind and ocamlbuild forks, falls back to the direct URL. The engine tries the mirrors in order and verifies each against the asset sha256. Per-mirror filenames need a dk0 that supports them. Each synthesized .Src bundle names its origin after the source hash (src-<first8>), so a bundle's opam-cache mirror directory resolves the right asset when one submit registers many bundles.

The mergedprefix aggregate merges each package, and each imported package, straight into the shared p/ prefix with merge-object <Pkg> -m ./install.zip -d p/, the value shell's many-merges-into-one-directory primitive; the single-root path re-emits the root's install.zip. The rule archives each per-package install.zip and the mergedprefix prefix.zip with the engine's in-process --zip special form, which produces the same archive bytes on every platform from the same install prefix. Building these forms requires dk 2.4.2.342 or later, and S7z remains a dependency only where archives are extracted.

The closure rule resolves the toolchain at the drivers' targetabi=Release.target_abi wildcard, which follows dk0's --target-abi through a cross-targeting distribute job whose forms materialize at the host key, so the resolved document differs per invocation target. dk0 2.4.2.338 keeps every distinct imported dependency set and serves a restored pointer when any set matches. A consumer release that adopts a closure revision distributes with store: none, or with an engine whose distribute fails loudly on a stale seal (dk0 2.4.2.336 or later), so the complete object set publishes.

F_BuildLockedPackage runs the OpamBuildWrapper (assets/opam/build-locked-package.sh), which prepares the build environment an imported relocatable toolchain needs. On Windows it gives every bin and sbin destination the .exe suffix, so cmd.exe can run a staged ocamlbuild. Its ocamlbuild-nh shim passes -install-lib-dir p/lib/ocamlbuild, so ocamlbuild -where resolves to the package prefix while the dk0 closure keeps the compiler separate. It exports OCAML_TOPLEVEL_PATH, OCAMLTOP_INCLUDE_PATH, and OCAMLFIND_LDCONF so a topkg #use "topfind" finds the imported relocatable findlib, and it rewrites the imported findlib.conf's stdlib= and ldconf= to the running compiler's lib/ocaml so -package compiler-libs.toplevel resolves. It exports CAML_LD_LIBRARY_PATH pointing at the running compiler's stublibs, as a native path (cygpath -m) on Windows, so a bytecode helper that links unix loads dllunix at runtime.

The wrapper also runs a toolchain-fingerprint gate on both sides. After a successful build the producer records the sha256 of the DkML compiler-libs it linked against (compiler-libs/ocamlcommon.cmxa) into each library dir it produced, as a p/lib-mergeable ip/lib/<pkg>/.dk-provenance sidecar. Before building, the consumer compares every staged dependency's recorded compiler-libs sha against the compiler-libs this build links against and, on a mismatch, fails fast with an actionable [abi-toolchain] message. OCaml native compiler-libs are not bit-reproducible, so one declaration-stable DkML object can hold different .cmx CRCs across CLO releases, and this content fingerprint catches a producer and consumer that resolved different CLO releases even though their DkML module-id string matches. The gate is fail-open for a dependency with no recorded fingerprint and fail-closed only when a present fingerprint differs.

Toolchain checks

What the distscripts and scripts check about the toolchain, each tied to the check that performs it or marked as unchecked:

  • The CommonsLang_OCaml distscript dist/Linux_x86_64.u checks that the Linux_x86_64 DkML compiler names the bare tools gcc, as and ld -r -o, and no check covers the other binutils or the other Linux ABIs.
  • Such a build works for local use with CommonsLang_OCaml release 0.1.20260820083108 or later, whose DkML compiler is relocatable, and no check exercises a build on a newer-glibc host.
  • The CommonsLang_OCaml distscript dist/Linux_x86_64.u fails when a forced -pie link with the Linux_x86_64 DkML or Base compiler fails, and no check covers the Linux_arm64 or Linux_x86 runtime objects.
  • The diskuv/dk-distribute script toolchain-conformance.sh fails a distribution build when vswhere is missing or finds no MSVC installation in the version range [16.0,19.0), and the CommonsLang_OCaml script assets/dune/bootstrap-msvc.bat fails when vswhere finds none or vcvarsall fails.
  • Windows_*: a vcvarsall environment capture supplies INCLUDE, LIB, LIBPATH and PATH, and the slot to vcvarsall architecture mapping is the CommonsLang_OCaml table assets/table/msvc-arch/Release.<slot>. No check confirms the captured variables.
  • A package's distscript can check them, as the CommonsLang_OCaml distscript dist/Linux_x86_64.u does by running file -b on its bin/ocamlopt.

Usage

DkML

  $ get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Darwin_arm64 -d ${RUNTIME}/Darwin_arm64-DkML-4.14.3
  \test(pass)
  \dk.object(abi: "Release.Darwin_arm64", value-id: "ov4hzcigbvcca6mmdcn3dkbcxzrqbyypiygv6uuqyxxi3xud45fza")\;

  $ run-object CommonsBase_FileMagic.File@7.8.50407 -s Release.execution_abi -m ./bin/file.exe -e bin/file.exe --
  >   -b $(get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.target_abi -d : -e file.exe)/bin/ocamlopt
  \test(pass)
  \dk.target(abi: "Darwin_arm64")[Mach-O 64-bit executable, flags:<NOUNDEFS|DYLDLINK|TWOLEVEL|WEAK_DEFINES|BINDS_TO_WEAK|PIE>
  ]\;

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Darwin_arm64 -e 'bin/*' -c bin/ocamlopt -- -version
  \test(pass)
  \dk.target(abi: "Darwin_arm64")[4.14.3+relocatable
  ]\;

  $ get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Darwin_x86_64 -d ${RUNTIME}/Darwin_x86_64-DkML-4.14.3
  \test(pass)
  \dk.object(abi: "Release.Darwin_x86_64", value-id: "ogmn4dosqwicv7htf6q5aets2vpj4k3rvzwkc7uqlmig4gtp7fqha")\;

  $ run-object CommonsBase_FileMagic.File@7.8.50407 -s Release.execution_abi -m ./bin/file.exe -e bin/file.exe --
  >   -b $(get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.target_abi -d : -e file.exe)/bin/ocamlopt
  \test(pass)
  \dk.target(abi: "Darwin_x86_64")[Mach-O 64-bit executable, flags:<NOUNDEFS|DYLDLINK|TWOLEVEL|WEAK_DEFINES|BINDS_TO_WEAK|PIE>
  ]\;

  $ get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_arm64 -d ${RUNTIME}/Linux_arm64-DkML-4.14.3
  \test(pass)

  $ run-object CommonsBase_FileMagic.File@7.8.50407 -s Release.execution_abi -m ./bin/file.exe -e bin/file.exe --
  >   -b $(get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.target_abi -d : -e file.exe)/bin/ocamlopt
  \test(pass)
  \dk.target(abi: "Linux_arm64")[ELF 64-bit LSB executable, ARM aarch64
  ]\;

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_arm64 -e 'bin/*' -c bin/ocamlopt -- -version
  \test(pass)

  $ get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_x86 -d ${RUNTIME}/Linux_x86-DkML-4.14.3
  \test(pass)
  \dk.object(abi: "Release.Linux_x86", value-id: "oqeb7jorj5bljnckopyrptishs4s6tiqltuykdigfqda4yol2hogq")\;

  $ run-object CommonsBase_FileMagic.File@7.8.50407 -s Release.execution_abi -m ./bin/file.exe -e bin/file.exe --
  >   -b $(get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.target_abi -d : -e file.exe)/bin/ocamlopt
  \test(pass)
  \dk.target(abi: "Linux_x86")[ELF 32-bit LSB executable, Intel i386, version 1 (SYSV)
  ]\;

  $ get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_x86_64 -d ${RUNTIME}/Linux_x86_64-DkML-4.14.3
  \test(pass)
  \dk.object(abi: "Release.Linux_x86_64", value-id: "oy4bi6npnczw5wdd2ts6sqa6fcwutpuntrkceqp7agqh5kqeiwmeq")\;

  $ run-object CommonsBase_FileMagic.File@7.8.50407 -s Release.execution_abi -m ./bin/file.exe -e bin/file.exe --
  >   -b $(get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.target_abi -d : -e file.exe)/bin/ocamlopt
  \test(pass)
  \dk.target(abi: "Linux_x86_64")[ELF 64-bit LSB executable, x86-64, version 1 (SYSV)
  ]\;

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_x86_64 -e 'bin/*' -c bin/ocamlopt -- -version
  \test(pass)
  \dk.target(abi: "Linux_x86_64")[4.14.3+relocatable
  ]\;

The native_pack_linker must be a relocatable, PATH-resolved partial linker (a
bare `ld -r -o`), never an absolute build-host path such as the ephemeral
`.../src-ocaml/support/with-host-c-compiler.sh.ld64.sh` a stock build bakes;
otherwise `ocamlopt -pack` fails off the build machine.

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_x86_64 -e 'bin/*' -c bin/ocamlopt -- -config-var native_pack_linker
  \test(pass)
  \dk.target(abi: "Linux_x86_64")[ld -r -o ]\;

The baked C toolchain must be bare PATH-resolved single-word names, never the
absolute /opt/rh/gcc-toolset-14 paths of the manylinux build container
(issue #2): end-user hosts supply their own PATH toolchain, while the release
build still resolves the same gcc-toolset-14 first on PATH.

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_x86_64 -e 'bin/*' -c bin/ocamlopt -- -config-var c_compiler
  \test(pass)
  \dk.target(abi: "Linux_x86_64")[gcc]\;

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_x86_64 -e 'bin/*' -c bin/ocamlopt -- -config-var asm
  \test(pass)
  \dk.target(abi: "Linux_x86_64")[as]\;

The runtime archives must be PIE-safe (issue #3): a link forced to -pie fails
on a non-PIC libasmrun.a with `relocation R_X86_64_32S ... can not be used
when making a PIE object`, reproducing on the non-PIE-default gcc-toolset
builder exactly what PIE-default consumer hosts do by default.

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Linux_x86_64 -e 'bin/*' -c bin/ocamlopt --
  >   -ccopt -pie -o ${RUNTIME}/piecheck.exe
  >   $(get-asset CommonsLang_OCaml.Apparatus.DkMLPieCheck@1.0.1 -p assets/dkml/piecheck.ml -f piecheck.ml)
  \test(pass)
  \dk.target(abi: "Linux_x86_64")\;

  $ get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Windows_x86 -d ${RUNTIME}/Windows_x86-DkML-4.14.3
  \test(pass)
  \dk.object(abi: "Release.Windows_x86", value-id: "op7pbgi75o5tg4d6u6wlhih4ejc6gvte2it5qaduhy4a3ydgeiafq")\;

Release.Windows_x86_64 will be used as Release.execution_abi on normal (64-bit) build + CI machines.

  $ run-object CommonsBase_FileMagic.File@7.8.50407 -s Release.execution_abi -m ./bin/file.exe -e bin/file.exe --
  >   -b $(get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.target_abi -d : -e file.exe)/bin/ocamlopt.exe
  \test(pass)
  \dk.target(abi: "Windows_x86")[PE32 executable for MS Windows 6.00 (console),, 5 sections
  ]\;

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Windows_x86 -c bin/ocamlopt.exe -- -version
  \test(pass)
  \dk.target(abi: "Windows_x86")[4.14.3+relocatable
  ]\;

  $ get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Windows_x86_64 -d ${RUNTIME}/Windows_x86_64-DkML-4.14.3
  \test(pass)
  \dk.object(abi: "Release.Windows_x86_64", value-id: "ofktzn5xipoyg7cwwg3vkgkz2oiijiwuq3j2pb7owy3qnvpitrubq")\;

  $ run-object CommonsBase_FileMagic.File@7.8.50407 -s Release.execution_abi -m ./bin/file.exe -e bin/file.exe --
  >   -b $(get-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.target_abi -d : -e file.exe)/bin/ocamlopt.exe
  \test(pass)
  \dk.target(abi: "Windows_x86_64")[PE32+ executable for MS Windows 6.00 (console),, 6 sections
  ]\;

  $ run-object CommonsLang_OCaml.DkML@4.14.3001 -s Release.Windows_x86_64 -c bin/ocamlopt.exe -- -version
  \test(pass)
  \dk.target(abi: "Windows_x86_64")[4.14.3+relocatable
  ]\;

Base

  $ run-object CommonsLang_OCaml.Base@5.5.0 -s Release.Darwin_arm64 -e 'bin/*' -c bin/ocamlopt -- -version
  \test(pass)
  \dk.target(abi: "Darwin_arm64")[5.5.0
  ]\;

  $ run-object CommonsLang_OCaml.Base@5.5.0 -s Release.Darwin_x86_64 -e 'bin/*' -c bin/ocamlopt -- -version
  \test(pass)
  \dk.target(abi: "Darwin_x86_64")[5.5.0
  ]\;

  $ run-object CommonsLang_OCaml.Base@5.5.0 -s Release.Linux_x86_64 -e 'bin/*' -c bin/ocamlopt -- -version
  \test(pass)
  \dk.target(abi: "Linux_x86_64")[5.5.0
  ]\;

The Base runtime archives must be PIE-safe like the DkML ones (issue #3): the
same forced -pie link exercises the -fPIC CFLAGS/ASPP added to the Base Linux
glibc configure blocks.

  $ run-object CommonsLang_OCaml.Base@5.5.0 -s Release.Linux_x86_64 -e 'bin/*' -c bin/ocamlopt --
  >   -ccopt -pie -o ${RUNTIME}/basepiecheck.exe
  >   $(get-asset CommonsLang_OCaml.Apparatus.DkMLPieCheck@1.0.1 -p assets/dkml/piecheck.ml -f piecheck.ml)
  \test(pass)
  \dk.target(abi: "Linux_x86_64")\;

  $ run-object CommonsLang_OCaml.Base@5.5.0 -s Release.Windows_x86_64 -e 'bin/*' -c bin/ocamlopt.exe -- -version
  \test(pass)
  \dk.target(abi: "Windows_x86_64")[5.5.0
  ]\;

Dune

  $ run-object CommonsLang_OCaml.Dune@3.23.2 -s Release.Darwin_arm64 -e 'bin/*' -c bin/dune.exe -- --version
  \test(pass)
  \dk.target(abi: "Darwin_arm64")[3.23.1
  ]\;

  $ run-object CommonsLang_OCaml.Dune@3.23.2 -s Release.Darwin_x86_64 -e 'bin/*' -c bin/dune.exe -- --version
  \test(pass)
  \dk.target(abi: "Darwin_x86_64")[3.23.1
  ]\;

  $ run-object CommonsLang_OCaml.Dune@3.23.2 -s Release.Linux_arm64 -e 'bin/*' -c bin/dune.exe -- --version
  \test(pass)
  \dk.target(abi: "Linux_arm64")[3.23.1
  ]\;

  $ run-object CommonsLang_OCaml.Dune@3.23.2 -s Release.Linux_x86 -e 'bin/*' -c bin/dune.exe -- --version
  \test(pass)
  \dk.target(abi: "Linux_x86")[3.23.1
  ]\;

  $ run-object CommonsLang_OCaml.Dune@3.23.2 -s Release.Linux_x86_64 -e 'bin/*' -c bin/dune.exe -- --version
  \test(pass)
  \dk.target(abi: "Linux_x86_64")[3.23.1
  ]\;

  $ run-object CommonsLang_OCaml.Dune@3.23.2 -s Release.Windows_x86 -e 'bin/*' -c bin/dune.exe -- --version
  \test(pass)
  \dk.target(abi: "Windows_x86")[3.23.1
  ]\;

  $ run-object CommonsLang_OCaml.Dune@3.23.2 -s Release.Windows_x86_64 -e 'bin/*' -c bin/dune.exe -- --version
  \test(pass)
  \dk.target(abi: "Windows_x86_64")[3.23.1
  ]\;

Opam

  $ run-object CommonsLang_OCaml.Opam@2.5.2 -s Release.Darwin_arm64 -e 'bin/*' -c bin/opam.exe -- --version
  \test(pass)
  \dk.target(abi: "Darwin_arm64")[2.5.1
  ]\;

  $ run-object CommonsLang_OCaml.Opam@2.5.2 -s Release.Darwin_x86_64 -e 'bin/*' -c bin/opam.exe -- --version
  \test(pass)
  \dk.target(abi: "Darwin_x86_64")[2.5.1
  ]\;

  $ run-object CommonsLang_OCaml.Opam@2.5.2 -s Release.Linux_arm64 -e 'bin/*' -c bin/opam.exe -- --version
  \test(pass)
  \dk.target(abi: "Linux_arm64")[2.5.1
  ]\;

  $ run-object CommonsLang_OCaml.Opam@2.5.2 -s Release.Linux_x86 -e 'bin/*' -c bin/opam.exe -- --version
  \test(pass)
  \dk.target(abi: "Linux_x86")[2.5.1
  ]\;

  $ run-object CommonsLang_OCaml.Opam@2.5.2 -s Release.Linux_x86_64 -e 'bin/*' -c bin/opam.exe -- --version
  \test(pass)
  \dk.target(abi: "Linux_x86_64")[2.5.1
  ]\;

  $ run-object CommonsLang_OCaml.Opam@2.5.2 -s Release.Windows_x86 -e 'bin/*' -c bin/opam.exe -- --version
  \test(pass)
  \dk.target(abi: "Windows_x86")[2.5.1
  ]\;

  $ run-object CommonsLang_OCaml.Opam@2.5.2 -s Release.Windows_x86_64 -e 'bin/*' -c bin/opam.exe -- --version
  \test(pass)
  \dk.target(abi: "Windows_x86_64")[2.5.1
  ]\;

Dk.OpamLock

Only the current OpamLock revision ships. The retired Export@1.0.0-@1.1.7
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.1.22 -f ${RUNTIME}/OpamLock.Export-1.1.22.zip
  \test(pass)
  \dk.object(abi: "Release.Darwin_arm64", value-id: "o5vllo5gpdgwbs63gtxlfvdguztyxizeykgw76egto6x4nvywah7a")\;


Only the current OpamLock revision ships. The retired Export@1.0.0-@1.1.7
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.1.22 -f ${RUNTIME}/OpamLock.Export-1.1.22.zip
  \test(pass)
  \dk.object(abi: "Release.Darwin_arm64", value-id: "orcsi27hcpmurnaje77hkszppivma3seg5xmpv22h4ude5zkmejna")\;


Only the current OpamLock revision ships. The retired Export@1.0.0-@1.1.7
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy). As before on this arm64 slot
the marker output is unused (no object value-id is recorded).

  $ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.1.22 -f ${RUNTIME}/OpamLock.Export-1.1.22.zip
  \test(pass)

Only the current OpamLock revision ships. The retired Export@1.0.0-@1.1.7
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.1.22 -f ${RUNTIME}/OpamLock.Export-1.1.22.zip
  \test(pass)
  \dk.object(abi: "Release.Linux_x86_64", value-id: "onciw23mbjeycgelmtk6mqflnvyedww2llqemclmptdlit3dyhmcq")\;


Only the current OpamLock revision ships. The retired Export@1.0.0-@1.1.7
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.1.22 -f ${RUNTIME}/OpamLock.Export-1.1.22.zip
  \test(pass)
  \dk.object(abi: "Release.Linux_x86_64", value-id: "owqfoom6rt4lhmmxuzoy4g6yimeqaskrwpzc4fknsedu5fhapodma")\;


Only the current OpamLock revision ships. The retired Export@1.0.0-@1.1.7
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.1.22 -f ${RUNTIME}/OpamLock.Export-1.1.22.zip
  \test(pass)
  \dk.object(abi: "Release.Windows_x86_64", value-id: "o3jbpgkdxedk6umphkznsdodo6pfusrxqetux7x3qzljlknpxpfxq")\;


Only the current OpamLock revision ships. The retired Export@1.0.0-@1.1.7
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.1.22 -f ${RUNTIME}/OpamLock.Export-1.1.22.zip
  \test(pass)
  \dk.object(abi: "Release.Windows_x86_64", value-id: "ohivxrneuv7wsqfuc6ws3na4xtgbikcxctqmugrrq5rdlvatta5ma")\;


Dk.OpamBuild

Only the current OpamBuild revision ships. The retired Export@1.0.0-@1.0.15
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.29 -f ${RUNTIME}/OpamBuild.Export-1.0.29.zip
  \test(pass)
  \dk.object(abi: "Release.Darwin_arm64", value-id: "ot36qu3466etoe2n4fwegx5oven5jtringcjn4njmy7n4ayspxb6q")\;
Only the current OpamBuild revision ships. The retired Export@1.0.0-@1.0.15
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.29 -f ${RUNTIME}/OpamBuild.Export-1.0.29.zip
  \test(pass)
  \dk.object(abi: "Release.Darwin_arm64", value-id: "ofkhb4fn4p2mz32lrqhtbpisau6yyjvdxswq2y6scqwogdj2rqf5a")\;
Only the current OpamBuild revision ships. The retired Export@1.0.0-@1.0.15
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.29 -f ${RUNTIME}/OpamBuild.Export-1.0.29.zip
  \test(pass)
  \dk.object(abi: "Release.Linux_arm64", value-id: "o0000000000000000000000000000000000000000000000000000")\;
Only the current OpamBuild revision ships. The retired Export@1.0.0-@1.0.15
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.29 -f ${RUNTIME}/OpamBuild.Export-1.0.29.zip
  \test(pass)
  \dk.object(abi: "Release.Linux_x86_64", value-id: "o2vpwyvntt4ufm6ongpqbd6wgoqzztry4r3x5ixyawn55s6ssya3q")\;
Only the current OpamBuild revision ships. The retired Export@1.0.0-@1.0.15
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.29 -f ${RUNTIME}/OpamBuild.Export-1.0.29.zip
  \test(pass)
  \dk.object(abi: "Release.Linux_x86_64", value-id: "ox2yguwbuo7ev3o5ovs5vcjgsljpqjev73hi6ze6isy6mmksrfasq")\;
Only the current OpamBuild revision ships. The retired Export@1.0.0-@1.0.15
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.29 -f ${RUNTIME}/OpamBuild.Export-1.0.29.zip
  \test(pass)
  \dk.object(abi: "Release.Windows_x86_64", value-id: "ohbdeipwjlbjfj3gpfsgorska7y44vbvddn3ciuxsiqnjceebesua")\;
Only the current OpamBuild revision ships. The retired Export@1.0.0-@1.0.15
ladder lives in pre-2026-08 release tags and git history (see dk.u
"## Assets" for the keep-latest-only policy).

  $ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.29 -f ${RUNTIME}/OpamBuild.Export-1.0.29.zip
  \test(pass)
  \dk.object(abi: "Release.Windows_x86_64", value-id: "orlivsdhgqn6hmk3yq3gm35adggjgmx3bccn6nyluhahl4wl27cvq")\;

MSYS2

MSYS2 tree for `opam init --cygwin-local-install --cygwin-location=<obj>` in
the Dk.OpamLock hermetic bootstrap (opam detects MSYS2 via
usr/bin/cygpath.exe). Windows x86_64 only: x86/arm64 Windows hosts run the
x64 tree through WOW64/emulation.

  $ get-object CommonsLang_OCaml.MSYS2@2026.6.11 -s Release.Windows_x86_64 -f ${RUNTIME}/Windows_x86_64-MSYS2-2026.6.11.zip
  \test(pass)
  \dk.object(abi: "Release.Windows_x86_64", value-id: "ozjqpoyewgl2wsnrk5uekbleo3644auhcyri2gexstfr3k5slof5q")\;

Provides

ModuleVersionPlatformvalue-id
CommonsLang_OCaml.DkML 4.14.3001 Darwin_arm64 ov4hzcigbvcc…
CommonsLang_OCaml.DkML 4.14.3001 Darwin_x86_64 ogmn4dosqwic…
CommonsLang_OCaml.DkML 4.14.3001 Linux_x86 oqeb7jorj5bl…
CommonsLang_OCaml.DkML 4.14.3001 Linux_x86_64 oy4bi6npnczw…
CommonsLang_OCaml.DkML 4.14.3001 Windows_x86 op7pbgi75o5t…
CommonsLang_OCaml.DkML 4.14.3001 Windows_x86_64 ofktzn5xipoy…
CommonsLang_OCaml.Base 5.5.0 apparatus
CommonsLang_OCaml.Dune 3.23.2 apparatus
CommonsLang_OCaml.Opam 2.5.2 apparatus
CommonsLang_OCaml.Dk.OpamLock.Export 1.1.22 Darwin_arm64 o5vllo5gpdgw…
CommonsLang_OCaml.Dk.OpamLock.Export 1.1.22 Darwin_arm64 orcsi27hcpmu…
CommonsLang_OCaml.Dk.OpamLock.Export 1.1.22 Linux_x86_64 onciw23mbjey…
CommonsLang_OCaml.Dk.OpamLock.Export 1.1.22 Linux_x86_64 owqfoom6rt4l…
CommonsLang_OCaml.Dk.OpamLock.Export 1.1.22 Windows_x86_64 o3jbpgkdxedk…
CommonsLang_OCaml.Dk.OpamLock.Export 1.1.22 Windows_x86_64 ohivxrneuv7w…
CommonsLang_OCaml.Dk.OpamBuild.Export 1.0.29 Darwin_arm64 ot36qu3466et…
CommonsLang_OCaml.Dk.OpamBuild.Export 1.0.29 Darwin_arm64 ofkhb4fn4p2m…
CommonsLang_OCaml.Dk.OpamBuild.Export 1.0.29 Linux_arm64 o00000000000…
CommonsLang_OCaml.Dk.OpamBuild.Export 1.0.29 Linux_x86_64 o2vpwyvntt4u…
CommonsLang_OCaml.Dk.OpamBuild.Export 1.0.29 Linux_x86_64 ox2yguwbuo7e…
CommonsLang_OCaml.Dk.OpamBuild.Export 1.0.29 Windows_x86_64 ohbdeipwjlbj…
CommonsLang_OCaml.Dk.OpamBuild.Export 1.0.29 Windows_x86_64 orlivsdhgqn6…
CommonsLang_OCaml.MSYS2 2026.6.11 Windows_x86_64 ozjqpoyewgl2…

Workspace assets

Files and directories in the package repo, bundled into the build.

AssetProject pathType
Patches assets/p directory
Scripts assets/s directory
Tables assets/table directory
WineHostShim assets/wine-hostshim directory
DkMLRoot assets/dkml/dkmlroot.2.4.2-29.txt file
DkMLPatchRelocatableVersion assets/dkml/patch-r-c-ocaml-1-setup-relocatable-version.sh file
DkMLRunBuildHost assets/dkml/run-build-host.sh file
DkMLDetectVsEnvBat assets/dkml/detect-vsenv.bat file
DkMLCleanupSlot assets/dkml/cleanup-dkml-slot.sh file
DkMLPatchStandardCompilerEnvWv18 assets/dkml/patch-standard-compiler-env-wv18.sh file
DkMLMuslWrap assets/dkml/musl-tool-wrapper.sh file
DkMLMuslBuildHost assets/dkml/run-musl-build-host.sh file
DkMLX86Wrap assets/dkml/x86-tool-wrapper.sh file
DkMLX86BuildHost assets/dkml/run-x86-build-host.sh file
DkMLGlibcEnv assets/dkml/glibc-compiler-env-to-ocaml-configure-env.sh file
DkMLPieCheck assets/dkml/piecheck.ml file
DuneBootstrapMsvc assets/dune/bootstrap-msvc.bat file
OpamBuildWin assets/opam/opam-build-win.sh file
OpamBuildWinVcvars assets/opam/opam-build-win-vcvars.bat file
OpamMsvsDetectStub assets/opam/msvs-detect-stub.sh file
OpamMccsGlpkStub assets/opam/mccs-glpk-wrmip-stub.c file
OpamBuildSeqMeta assets/opam/seq-META file
OpamFileFormat assets/opam-lock/opam_file_format.ml file
OpamBuildWrapper assets/opam/build-locked-package.sh file
DkMLMuslEnv assets/dkml/musl-compiler-env-to-ocaml-configure-env.sh file
DkMLX86Env assets/dkml/x86-compiler-env-to-ocaml-configure-env.sh file
OpamLockHelper assets/opam-lock/dk_opam_lock.ml file

Downloaded assets

Third-party sources fetched and checksum-verified during the build.

AssetSizesha256Source
ocaml-5.4.1.tar.gz 6.2 MB d4528517aaa1a44b… https://github.com/ocaml/ocaml/releases/download/5.4.1/ocaml-5.4.1.tar.gz
2.5.1.tar.gz 1.2 MB 459a57cb84c3ea16… https://github.com/ocaml/opam/archive/refs/tags/2.5.1.tar.gz
menhir-20250903-no-symlinks.tar 4.2 MB 087792aff8fb1238… https://github.com/dkpkg/CommonsLang_OCaml/releases/download/opam-menhir-20250903-no-symlinks/menhir-20250903-no-symlinks.tar
msys2-base-x86_64-20260611.tar.xz 51.1 MB a2d047e8ee213c3c… https://github.com/dkpkg/CommonsLang_OCaml/releases/download/msys2-20260611-assets/msys2-base-x86_64-20260611.tar.xzhttps://github.com/msys2/msys2-installer/releases/download/2026-06-11/msys2-base-x86_64-20260611.tar.xz
2.4.2-51.zip 1.5 MB 052a8b265832187c… https://github.com/diskuv/dkml-compiler/archive/refs/tags/2.4.2-51.zip
src.zip 61 KB 6dde51c5f6605a83… https://github.com/diskuv/dkml-runtime-common/releases/download/2.4.2-26/src.zip
x86_64-linux-musl-cross.tgz 107.2 MB c6226824d6b7214c… https://github.com/dkpkg/CommonsLang_OCaml/releases/download/muslcc-x86_64-11.2.1/x86_64-linux-musl-cross.tgzhttps://more.musl.cc/11.2.1/x86_64-linux-musl/x86_64-linux-musl-cross.tgz
4.14.3.tar.gz 5.3 MB e510689183b2d62b… https://github.com/ocaml/ocaml/archive/refs/tags/4.14.3.tar.gz
5.5.0.tar.gz 4.8 MB c018052c8264a379… https://github.com/ocaml/ocaml/archive/5.5.0.tar.gz
3.23.1.tar.gz 3.5 MB 63fbef75d09dd4a0… https://github.com/ocaml/dune/archive/refs/tags/3.23.1.tar.gz

Dependencies

PackageVersionsha256
CommonsBase_FileMagic 0.1.20260920144347 9795f60a23f31355…
CommonsBase_LLVM 0.1.20260920144347 56312cd1d2868eff…
CommonsBase_Win32 0.1.20260920144347 4c1ae11415083c10…
NotMitEdu_Kerberos 0.1.20260920144347 85cd3dd87bb48561…
NotMatveevKondratyev_Libinotify 0.1.20260920144347 33f86058acc7b9f1…
CommonsBase_GNU 0.1.20260920144347 53e60fcbf502ffbd…
CommonsBase_Std 2.6.20260920144347 b3c67724e0994259…
CommonsBase_Build 0.1.20260920144347 eb05f811a4e114f4…

Producer signing key

Releases of this package are signed with this OpenBSD signify key. After you import the package, dk1 trust list prints the same public key and fingerprint; compare them here to confirm you are trusting the intended publisher over a channel independent of the download.

Fingerprint 2b19619c380dd657
Public key RWQrGWGcOA3WV93QbuXdm8aAWjDkYvCM5jgFAanfDRiW9n3PzSvLESmR