$ get-object CommonsLang_OCaml.DkML@4.14.3 -s Release.Darwin_arm64 -d ${RUNTIME}/Darwin_arm64-DkML-4.14.3
\test(pass)
\dk.object(abi: "Release.Darwin_arm64", value-id: "omazl3zdevzgvni5a3audg2gwt3vfs3cckdearnvx4zsi5lac4rya")\;
$ 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.3 -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.3 -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.3 -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: "oaftselzqfnqpsym3e4bxyxszyo4worywq5sbp6dr6dmfdchdx6sq")\;
$ 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.3 -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.3 -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.3 -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.3 -s Release.Linux_arm64 -e 'bin/*' -c bin/ocamlopt -- -version
\test(pass)
$ get-object CommonsLang_OCaml.DkML@4.14.3 -s Release.Linux_x86 -d ${RUNTIME}/Linux_x86-DkML-4.14.3
\test(pass)
\dk.object(abi: "Release.Linux_x86", value-id: "ohpjasgizzqwot4a7mstj6tweggsxa3dolyoby7owwvitgzwwgvlq")\;
$ 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.3 -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.3 -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: "o5mirv4qjdaoy3bfdgtz7uk5gw7lyqbuxow4rtn3qouuckfnygqha")\;
$ 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.3 -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.3 -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.3 -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 ]\;
$ get-object CommonsLang_OCaml.DkML@4.14.3 -s Release.Linux_x86_64_musl -d ${RUNTIME}/Linux_x86_64_musl-DkML-4.14.3
\test(pass)
\dk.object(abi: "Release.Linux_x86_64_musl", value-id: "ounhvq6pmc7fsih6j5iirtkgraf56gkk343xdvgvr3zsbemtrobma")\;
The musl ocamlopt is a musl binary (ELF interpreter /lib/ld-musl-x86_64.so.1),
so it runs wherever the musl loader is present: natively on musl hosts, and on
the glibc manylinux build host because the build provisions the loader at that
path (see the per-ABI dynamic linker in DK0-REFERENCE.md). The file(1) string
below is harvested from the first CI run.
$ 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.3 -s Release.target_abi -d : -e file.exe)/bin/ocamlopt
\test(pass)
\dk.target(abi: "Linux_x86_64_musl")[ELF 64-bit LSB ${x?pie executable:shared object}, x86-64, version 1 (SYSV)
]\;
$ run-object CommonsLang_OCaml.DkML@4.14.3 -s Release.Linux_x86_64_musl -e 'bin/*' -c bin/ocamlopt -- -version
\test(pass)
\dk.target(abi: "Linux_x86_64_musl")[4.14.3+relocatable
]\;
The native_pack_linker must be a relocatable, PATH-resolved partial linker (a
bare `x86_64-linux-musl-ld -r -o`, resolved through the slot's
bin/x86_64-linux-musl-* dispatch wrappers), 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. The
musl partial linker is required because the host `ld` cannot read the musl
toolchain's compressed debug sections.
$ run-object CommonsLang_OCaml.DkML@4.14.3 -s Release.Linux_x86_64_musl -e 'bin/*' -c bin/ocamlopt -- -config-var native_pack_linker
\test(pass)
\dk.target(abi: "Linux_x86_64_musl")[x86_64-linux-musl-ld -r -o ]\;
The baked C compiler must be the bare musl cross driver, resolved through the
bin/x86_64-linux-musl-* dispatch wrappers shipped in the same slot, so
consumer machines link static musl executables wherever the slot's bin/ is on
PATH.
$ run-object CommonsLang_OCaml.DkML@4.14.3 -s Release.Linux_x86_64_musl -e 'bin/*' -c bin/ocamlopt -- -config-var c_compiler
\test(pass)
\dk.target(abi: "Linux_x86_64_musl")[x86_64-linux-musl-gcc]\;
$ get-object CommonsLang_OCaml.DkML@4.14.3 -s Release.Windows_x86 -d ${RUNTIME}/Windows_x86-DkML-4.14.3
\test(pass)
\dk.object(abi: "Release.Windows_x86", value-id: "o56wqacou2uoowgr7jfhskdjodil2ubc4wrk2i54k43okaeeca6ka")\;
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.3 -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.3 -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.3 -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: "owlmowkfztyo22bqesxelr2gri5l4wiunqjnulgb7x2gpxmaugouq")\;
$ 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.3 -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.3 -s Release.Windows_x86_64 -c bin/ocamlopt.exe -- -version
\test(pass)
\dk.target(abi: "Windows_x86_64")[4.14.3+relocatable
]\;
$ run-object CommonsLang_OCaml.Dune@3.23.1 -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.1 -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.1 -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.1 -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.1 -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.1 -s Release.Linux_x86_64_musl -e 'bin/*' -c bin/dune.exe -- --version
\test(pass)
\dk.target(abi: "Linux_x86_64_musl")[3.23.1
]\;
$ run-object CommonsLang_OCaml.Dune@3.23.1 -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.1 -s Release.Windows_x86_64 -e 'bin/*' -c bin/dune.exe -- --version
\test(pass)
\dk.target(abi: "Windows_x86_64")[3.23.1
]\;
$ run-object CommonsLang_OCaml.Opam@2.5.1 -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.1 -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.1 -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.1 -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.1 -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.1 -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.1 -s Release.Windows_x86_64 -e 'bin/*' -c bin/opam.exe -- --version
\test(pass)
\dk.target(abi: "Windows_x86_64")[2.5.1
]\;
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).
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/deps/build commands, and
never `opam install`s. opam has no switch-less solve (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. By default that switch is an ephemeral LOCAL
switch in the rule's sandbox -- unique per run (no cross-project or cross-run
pin contamination, so the lock is reproducible) and removed once the solve
finishes; nothing is ever installed into it.
### 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, where 4.14.2
resolves the wrong 64-bit one.
+ The DkML 4.14.3 toolchain ocaml replaces this solve compiler at build time,
so the lock's ocaml and ocaml-base-compiler entries are solve artifacts, not
build inputs.
$ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.0.0 -f ${RUNTIME}/OpamLock.Export.zip
\test(pass)
\dk.object(abi: "Release.Darwin_arm64", value-id: "ow6itgcoxmhhcyhnh76cz576ptu3t6xpuyghxqtyki7ixhykaltka")\;
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).
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/deps/build commands, and
never `opam install`s. opam has no switch-less solve (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. By default that switch is an ephemeral LOCAL
switch in the rule's sandbox -- unique per run (no cross-project or cross-run
pin contamination, so the lock is reproducible) and removed once the solve
finishes; nothing is ever installed into it.
### 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, where 4.14.2
resolves the wrong 64-bit one.
+ The DkML 4.14.3 toolchain ocaml replaces this solve compiler at build time,
so the lock's ocaml and ocaml-base-compiler entries are solve artifacts, not
build inputs.
$ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.0.0 -f ${RUNTIME}/OpamLock.Export.zip
\test(pass)
\dk.object(abi: "Release.Darwin_arm64", value-id: "ow6itgcoxmhhcyhnh76cz576ptu3t6xpuyghxqtyki7ixhykaltka")\;
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).
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/deps/build commands, and
never `opam install`s. opam has no switch-less solve (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. By default that switch is an ephemeral LOCAL
switch in the rule's sandbox -- unique per run (no cross-project or cross-run
pin contamination, so the lock is reproducible) and removed once the solve
finishes; nothing is ever installed into it.
### 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, where 4.14.2
resolves the wrong 64-bit one.
+ The DkML 4.14.3 toolchain ocaml replaces this solve compiler at build time,
so the lock's ocaml and ocaml-base-compiler entries are solve artifacts, not
build inputs.
$ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.0.0 -f ${RUNTIME}/OpamLock.Export.zip
\test(pass)
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).
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/deps/build commands, and
never `opam install`s. opam has no switch-less solve (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. By default that switch is an ephemeral LOCAL
switch in the rule's sandbox -- unique per run (no cross-project or cross-run
pin contamination, so the lock is reproducible) and removed once the solve
finishes; nothing is ever installed into it.
### 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, where 4.14.2
resolves the wrong 64-bit one.
+ The DkML 4.14.3 toolchain ocaml replaces this solve compiler at build time,
so the lock's ocaml and ocaml-base-compiler entries are solve artifacts, not
build inputs.
$ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.0.0 -f ${RUNTIME}/OpamLock.Export.zip
\test(pass)
\dk.object(abi: "Release.Linux_x86_64", value-id: "o7mmvaocrhvy765tkdtsbp76eyj2423m3espmw34kthkdoqvl3cdq")\;
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).
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/deps/build commands, and
never `opam install`s. opam has no switch-less solve (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. By default that switch is an ephemeral LOCAL
switch in the rule's sandbox -- unique per run (no cross-project or cross-run
pin contamination, so the lock is reproducible) and removed once the solve
finishes; nothing is ever installed into it.
### 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, where 4.14.2
resolves the wrong 64-bit one.
+ The DkML 4.14.3 toolchain ocaml replaces this solve compiler at build time,
so the lock's ocaml and ocaml-base-compiler entries are solve artifacts, not
build inputs.
$ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.0.0 -f ${RUNTIME}/OpamLock.Export.zip
\test(pass)
\dk.object(abi: "Release.Linux_x86_64", value-id: "o7mmvaocrhvy765tkdtsbp76eyj2423m3espmw34kthkdoqvl3cdq")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.0.0 -f ${RUNTIME}/OpamLock.Export.zip
\test(pass)
\dk.object(abi: "Release.Linux_x86_64", value-id: "o7mmvaocrhvy765tkdtsbp76eyj2423m3espmw34kthkdoqvl3cdq")
\dk.object(abi: "Release.Linux_x86_64_musl", value-id: "odx35phn7zbcsqd3u6oimt5ga4chrzhaimrl73snmj2dk6yxztvpq")\;
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).
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/deps/build commands, and
never `opam install`s. opam has no switch-less solve (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. By default that switch is an ephemeral LOCAL
switch in the rule's sandbox -- unique per run (no cross-project or cross-run
pin contamination, so the lock is reproducible) and removed once the solve
finishes; nothing is ever installed into it.
### 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, where 4.14.2
resolves the wrong 64-bit one.
+ The DkML 4.14.3 toolchain ocaml replaces this solve compiler at build time,
so the lock's ocaml and ocaml-base-compiler entries are solve artifacts, not
build inputs.
$ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.0.0 -f ${RUNTIME}/OpamLock.Export.zip
\test(pass)
\dk.object(abi: "Release.Windows_x86_64", value-id: "o4z5z3zdrecgprn5m46h7hczhygs6tra4jc4tjxwtfdqxagnsik2a")\;
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).
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/deps/build commands, and
never `opam install`s. opam has no switch-less solve (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. By default that switch is an ephemeral LOCAL
switch in the rule's sandbox -- unique per run (no cross-project or cross-run
pin contamination, so the lock is reproducible) and removed once the solve
finishes; nothing is ever installed into it.
### 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, where 4.14.2
resolves the wrong 64-bit one.
+ The DkML 4.14.3 toolchain ocaml replaces this solve compiler at build time,
so the lock's ocaml and ocaml-base-compiler entries are solve artifacts, not
build inputs.
$ run-function CommonsLang_OCaml.Dk.OpamLock.Export@1.0.0 -f ${RUNTIME}/OpamLock.Export.zip
\test(pass)
\dk.object(abi: "Release.Windows_x86_64", value-id: "o4z5z3zdrecgprn5m46h7hczhygs6tra4jc4tjxwtfdqxagnsik2a")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.0 -f ${RUNTIME}/OpamBuild.Export.zip
\test(pass)
\dk.object(abi: "Release.Darwin_arm64", value-id: "ot36qu3466etoe2n4fwegx5oven5jtringcjn4njmy7n4ayspxb6q")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.0 -f ${RUNTIME}/OpamBuild.Export.zip
\test(pass)
\dk.object(abi: "Release.Darwin_arm64", value-id: "ot36qu3466etoe2n4fwegx5oven5jtringcjn4njmy7n4ayspxb6q")
\dk.object(abi: "Release.Darwin_x86_64", value-id: "ow53l5vi6n5qcxrcherm65hd2t3u245u6uthawrgryjjeospk5kjq")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.0 -f ${RUNTIME}/OpamBuild.Export.zip
\test(pass)
\dk.object(abi: "Release.Linux_arm64", value-id: "ow53l5vi6n5qcxrcherm65hd2t3u245u6uthawrgryjjeospk5kjq")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.0 -f ${RUNTIME}/OpamBuild.Export.zip
\test(pass)
\dk.object(abi: "Release.Linux_x86", value-id: "ow53l5vi6n5qcxrcherm65hd2t3u245u6uthawrgryjjeospk5kjq")
\dk.object(abi: "Release.Linux_x86_64", value-id: "ox2yguwbuo7ev3o5ovs5vcjgsljpqjev73hi6ze6isy6mmksrfasq")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.0 -f ${RUNTIME}/OpamBuild.Export.zip
\test(pass)
\dk.object(abi: "Release.Linux_x86_64", value-id: "ox2yguwbuo7ev3o5ovs5vcjgsljpqjev73hi6ze6isy6mmksrfasq")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.0 -f ${RUNTIME}/OpamBuild.Export.zip
\test(pass)
\dk.object(abi: "Release.Linux_x86_64", value-id: "ox2yguwbuo7ev3o5ovs5vcjgsljpqjev73hi6ze6isy6mmksrfasq")
\dk.object(abi: "Release.Linux_x86_64_musl", value-id: "ofwoywfonzbccnnyo6uhzrxd5allydjh4mgiqjlzo37364avaonga")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.0 -f ${RUNTIME}/OpamBuild.Export.zip
\test(pass)
\dk.object(abi: "Release.Windows_x86", value-id: "ow53l5vi6n5qcxrcherm65hd2t3u245u6uthawrgryjjeospk5kjq")
\dk.object(abi: "Release.Windows_x86_64", value-id: "orlivsdhgqn6hmk3yq3gm35adggjgmx3bccn6nyluhahl4wl27cvq")\;
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).
$ run-function CommonsLang_OCaml.Dk.OpamBuild.Export@1.0.0 -f ${RUNTIME}/OpamBuild.Export.zip
\test(pass)
\dk.object(abi: "Release.Windows_x86_64", value-id: "orlivsdhgqn6hmk3yq3gm35adggjgmx3bccn6nyluhahl4wl27cvq")\;
