Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • TristanCacqueray/ghc-wasm-meta
  • normalcoder/ghc-wasm-meta
  • plusgut/ghc-wasm-meta
  • haskell-wasm/ghc-wasm-meta
  • amesgen/ghc-wasm-meta
  • andystopia/ghc-wasm-meta
  • 414owen/ghc-wasm-meta
  • qbane/ghc-wasm-meta
  • fetsorn/ghc-wasm-meta
  • Anut-py/ghc-wasm-meta
10 results
Show changes
Commits on Source (307)
default:
interruptible: true
workflow:
rules:
- if: $CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
- if: $CI_PIPELINE_SOURCE == "merge_request_event"
- if: $CI_PIPELINE_SOURCE == "web"
- if: $UPSTREAM_GHC_FLAVOUR != null
variables:
DOCKER_REV: 205afce5c7ebdb8666b96638f6758fe527f40a7f
GIT_DEPTH: "1"
DOCKER_REV: 6e9f8f17086e56e83adae4a8a9d63e2fec3cb6c7
GIT_DEPTH: 1
GIT_STRATEGY: clone
.x86_64-linux:
.x86_64-linux-ubuntu:
tags:
- x86_64-linux
image: registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-ubuntu20_04:$DOCKER_REV
image: registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-ubuntu24_04:$DOCKER_REV
rules:
- if: $UPSTREAM_GHC_FLAVOUR == null
- if: $UPSTREAM_GHC_FLAVOUR == $FLAVOUR
variables:
PLAYWRIGHT: 1
before_script:
- |
sudo apt update
sudo apt full-upgrade -y
sudo apt install -y \
zstd
curl -f -L https://packages.mozilla.org/apt/repo-signing-key.gpg | sudo tee /usr/share/keyrings/packages.mozilla.org.asc
echo "deb [signed-by=/usr/share/keyrings/packages.mozilla.org.asc] https://packages.mozilla.org/apt mozilla main" | sudo tee /etc/apt/sources.list.d/mozilla.list
curl -f -L https://dl.google.com/linux/linux_signing_key.pub | sudo tee /usr/share/keyrings/google.asc
echo "deb [signed-by=/usr/share/keyrings/google.asc] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee /etc/apt/sources.list.d/google-chrome.list
sudo apt update
sudo apt install -y \
google-chrome-stable
sudo apt install -y --target-release=mozilla \
firefox
- sudo chown ghc:ghc -R .
script:
- |
PREFIX=/tmp/.ghc-wasm ./setup.sh
sed -i -e "s/\$ncpus/$CPUS/" /tmp/.ghc-wasm/.cabal/config
. /tmp/.ghc-wasm/env
pushd "$(mktemp -d)"
echo 'main = putStrLn "hello world"' > hello.hs
wasm32-wasi-ghc hello.hs -o hello.wasm
wasm-run ./hello.wasm
popd
.x86_64-linux-ubuntu-head:
extends: .x86_64-linux-ubuntu
allow_failure: true
script:
- ./tests/ghci.sh
- ./tests/canary.sh
- ./tests/foundation.sh
- ./tests/network.sh
- ./tests/jsaddle-wasm.sh
- ./tests/ghc-wasm-earthly.sh
- ./tests/miso.sh
- ./tests/reflex-dom.sh
- ./tests/time.sh
- ./tests/clock.sh
- ./tests/unix-compat.sh
- ./tests/hashtables.sh
- ./tests/bzlib.sh
- ./tests/hfsnotify.sh
- ./tests/xxhash-ffi.sh
- ./tests/misc.sh
- ./tests/miso-reflex-examples.sh
- ./tests/pandoc.sh
- ./tests/tinyapl.sh
- ./tests/agda.sh
x86_64-linux-int_gmp:
extends: .x86_64-linux
x86_64-linux-ubuntu-gmp:
extends: .x86_64-linux-ubuntu-head
variables:
BIGNUM_BACKEND: gmp
FLAVOUR: gmp
x86_64-linux-int_native:
extends: .x86_64-linux
x86_64-linux-ubuntu-native:
extends: .x86_64-linux-ubuntu-head
variables:
BIGNUM_BACKEND: native
FLAVOUR: native
x86_64-linux-nix:
x86_64-linux-ubuntu-unreg:
extends: .x86_64-linux-ubuntu-head
variables:
FLAVOUR: unreg
x86_64-linux-ubuntu-9.6:
extends: .x86_64-linux-ubuntu
variables:
FLAVOUR: "9.6"
script:
- ./tests/foundation.sh
- ./tests/network.sh
- ./tests/clock.sh
- ./tests/bzlib.sh
- ./tests/xxhash-ffi.sh
- ./tests/misc.sh
- ./tests/agda.sh
x86_64-linux-ubuntu-9.8:
extends: .x86_64-linux-ubuntu
variables:
FLAVOUR: "9.8"
script:
- ./tests/foundation.sh
- ./tests/time.sh
- ./tests/network.sh
- ./tests/clock.sh
- ./tests/bzlib.sh
- ./tests/xxhash-ffi.sh
- ./tests/misc.sh
- ./tests/agda.sh
x86_64-linux-ubuntu-9.10:
extends: .x86_64-linux-ubuntu
variables:
FLAVOUR: "9.10"
script:
- ./tests/ghci.sh
- ./tests/canary.sh
- ./tests/foundation.sh
- ./tests/network.sh
- ./tests/jsaddle-wasm.sh
- ./tests/ghc-wasm-earthly.sh
- ./tests/miso.sh
- ./tests/reflex-dom.sh
- ./tests/time.sh
- ./tests/clock.sh
- ./tests/unix-compat.sh
- ./tests/hashtables.sh
- ./tests/bzlib.sh
- ./tests/hfsnotify.sh
- ./tests/xxhash-ffi.sh
- ./tests/misc.sh
- ./tests/miso-reflex-examples.sh
- ./tests/pandoc.sh
- ./tests/tinyapl.sh
- ./tests/agda.sh
x86_64-linux-ubuntu-9.12:
extends: .x86_64-linux-ubuntu
variables:
FLAVOUR: "9.12"
script:
- ./tests/ghci.sh
- ./tests/canary.sh
- ./tests/foundation.sh
- ./tests/network.sh
- ./tests/jsaddle-wasm.sh
- ./tests/ghc-wasm-earthly.sh
- ./tests/miso.sh
- ./tests/reflex-dom.sh
- ./tests/time.sh
- ./tests/clock.sh
- ./tests/unix-compat.sh
- ./tests/hashtables.sh
- ./tests/bzlib.sh
- ./tests/hfsnotify.sh
- ./tests/xxhash-ffi.sh
- ./tests/misc.sh
- ./tests/miso-reflex-examples.sh
- ./tests/pandoc.sh
- ./tests/tinyapl.sh
- ./tests/agda.sh
x86_64-linux-chimera-9.12:
tags:
- x86_64-linux
image: nixos/nix:2.11.1
image: terrorjack/chimera:bash
rules:
- if: $UPSTREAM_GHC_FLAVOUR == null
before_script:
- |
apk upgrade --no-interactive
apk add --no-interactive \
curl \
firefox \
gmake \
jq \
libarchive-progs
cd /usr/bin
ln -s bsdunzip unzip
cd $OLDPWD
script:
- |
PREFIX=/tmp/.ghc-wasm ./setup.sh
sed -i "" "s/\$ncpus/$CPUS/" /tmp/.ghc-wasm/.cabal/config
. /tmp/.ghc-wasm/env
- ./tests/ghci.sh
.nix:
rules:
- if: $UPSTREAM_GHC_FLAVOUR == null
variables:
NIXPKGS_ALLOW_UNFREE: "1"
script:
- |
nix build --json --no-link $NIX_FLAKE_OUTPUTS
nix shell --impure $NIX_BROWSERS .#all_9_12 --command ./tests/ghci.sh
nix shell --impure $NIX_BROWSERS .#all_9_10 --command ./tests/ghci.sh
.linux-nix:
extends: .nix
image: nixos/nix
before_script:
- echo "experimental-features = nix-command flakes" >> /etc/nix/nix.conf
- echo "cores = $CPUS" >> /etc/nix/nix.conf
- echo "max-jobs = $CPUS" >> /etc/nix/nix.conf
x86_64-linux-nix:
extends: .linux-nix
tags:
- x86_64-linux
variables:
NIX_FLAKE_OUTPUTS: .#all_gmp .#all_native .#all_unreg .#all_9_12 .#all_9_10 .#all_9_8 .#all_9_6
NIX_BROWSERS: nixpkgs#firefox-bin nixpkgs#google-chrome
aarch64-linux-nix:
extends: .linux-nix
tags:
- aarch64-linux
variables:
NIX_FLAKE_OUTPUTS: .#all_9_12 .#all_9_10
NIX_BROWSERS: nixpkgs#firefox-bin
aarch64-darwin-nix:
extends: .nix
tags:
- aarch64-darwin
variables:
NIX_FLAKE_OUTPUTS: .#all_9_12 .#all_9_10
NIX_BROWSERS: nixpkgs#google-chrome
.ghcup:
rules:
- if: $UPSTREAM_GHC_FLAVOUR == null
script:
- |
nix build --json --no-link .
curl -f -L --retry 5 https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh
. ~/.ghcup/env
ghcup install cabal latest --set
- |
SKIP_GHC=1 ./setup.sh
. ~/.ghc-wasm/env
- |
ghcup config add-release-channel file://$PWD/ghcup-wasm-0.0.9.yaml
ghcup install ghc wasm32-wasi-9.12 -- $CONFIGURE_ARGS
ghcup install ghc wasm32-wasi-9.10 -- $CONFIGURE_ARGS
ghcup set ghc wasm32-wasi-9.12
./tests/ghci.sh
ghcup set ghc wasm32-wasi-9.10
./tests/ghci.sh
.linux-ghcup:
extends: .ghcup
image: rockylinux:8
before_script:
- |
dnf upgrade -y
dnf install -y \
epel-release
crb enable
dnf install -y \
chromium \
firefox \
jq \
make \
unzip \
zstd
x86_64-linux-ghcup:
extends: .linux-ghcup
tags:
- x86_64-linux
aarch64-linux-ghcup:
extends: .linux-ghcup
tags:
- aarch64-linux
aarch64-darwin-ghcup:
extends: .ghcup
tags:
- aarch64-darwin
before_script:
- |
export HOME=$(mktemp -d)
trap 'rm -rf "$HOME"' EXIT
- |
mkdir wrappers
echo '#!/bin/sh' >> wrappers/firefox
echo 'exec "/Applications/Firefox.app/Contents/MacOS/firefox" ${1+"$@"}' >> wrappers/firefox
chmod +x wrappers/firefox
echo '#!/bin/sh' >> wrappers/google-chrome-stable
echo 'exec "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" ${1+"$@"}' >> wrappers/google-chrome-stable
chmod +x wrappers/google-chrome-stable
export PATH=$PATH:$PWD/wrappers
# `ghc-wasm-meta`
This repo provides convenient methods of using x86_64-linux binary
artifacts of GHC's wasm backend.
[![Chat on Matrix](https://matrix.to/img/matrix-badge.svg)](https://matrix.to/#/#haskell-wasm:matrix.org)
This repo provides convenient methods of using binary artifacts of
GHC's wasm backend. It's also a staging area for the GHC wasm backend
documentation.
## Getting started as a nix flake
......@@ -9,7 +12,7 @@ This repo is a nix flake. The default output is a derivation that
bundles all provided tools:
```sh
$ nix shell https://gitlab.haskell.org/ghc/ghc-wasm-meta/-/archive/master/ghc-wasm-meta-master.tar.gz
$ nix shell 'gitlab:haskell-wasm/ghc-wasm-meta?host=gitlab.haskell.org'
$ echo 'main = putStrLn "hello world"' > hello.hs
$ wasm32-wasi-ghc hello.hs -o hello.wasm
[1 of 2] Compiling Main ( hello.hs, hello.o )
......@@ -19,67 +22,517 @@ hello world
```
First start will download a bunch of stuff, but won't take too long
since it just patches the binaries and performs little real
compilation. There is no need to set up a binary cache.
since it just patches the binaries and performs no compilation. There
is no need to set up a binary cache.
Note that there are different GHC flavours available. The default
flake output uses the `all_9_12` flavour, though you can also use the
`all_native`, `all_gmp` etc flake outputs to get different flavours.
See the next subsection for explanations of these flavours.
## Getting started without nix
For Ubuntu 20.04 and similar glibc-based distros, this repo provides a
`setup.sh` script that installs the provided tools to `~/.ghc-wasm`:
This repo also provides an installation script that installs the
provided tools to `~/.ghc-wasm`:
```sh
$ ./setup.sh
$ curl https://gitlab.haskell.org/haskell-wasm/ghc-wasm-meta/-/raw/master/bootstrap.sh | sh
...
Everything set up in /home/username/.ghc-wasm.
Run 'source /home/username/.ghc-wasm/env' to add tools to your PATH.
```
After installing, `~/.ghc-wasm` will contain:
After installing, `~/.ghc-wasm` will contain all the installed tools,
plus:
- `env` which can be sourced into the current shell to add the tools
to `PATH`
- `add_to_github_path.sh` which can be run in GitHub actions, so
later steps in the same job can access the tools from `PATH`
- `~/.ghc-wasm/env` which can be sourced into the current shell to
add the tools to `PATH`, plus all the environment variables needed
to build `wasm32-wasi-ghc`
- `~/.ghc-wasm/add_to_github_path.sh` which can be run in GitHub
actions, so later steps in the same job can access the same
environment variables set by `env`
`setup.sh` can be configured via these environment variables:
`bootstrap.sh` is just a thin wrapper to download the `ghc-wasm-meta`
repo tarball and invoke `setup.sh`. These scripts can be configured
via these environment variables:
- `PREFIX`: installation destination, defaults to `~/.ghc-wasm`
- `BIGNUM_BACKEND`: which `ghc-bignum` backend to use, can be either
`gmp` or `native`, defaults to `gmp`
- `FLAVOUR`:
- The `gmp` flavour tracks GHC's `master` branch and uses the
`gmp` bignum backend & the wasm native codegen. It offers good
compile-time and run-time performance.
- `native` uses the `native` bignum backend and the wasm native
codegen. Compared to the `gmp` flavour, the run-time performance
may be slightly worse if the workload involves big `Integer`
operations. May be useful if you are compiling proprietary
projects and have concerns about statically linking the
LGPL-licensed `gmp` library.
- The `unreg` flavour uses the `gmp` bignum backend and the
unregisterised C codegen. Compared to the default flavour,
compile-time performance is noticeably worse. May be useful for
debugging the native codegen, since there are less GHC test
suite failures in the unregisterised codegen at the moment.
- The `9.6`/`9.8`/`9.10`/`9.12` flavour tracks the
`ghc-9.6`/`ghc-9.8`/`ghc-9.10`/`ghc-9.12` release branches in
our [fork](https://gitlab.haskell.org/haskell-wasm/ghc) instead
of the upstream `master` branch. It uses the `gmp` bignum
backend and the wasm native codegen.
- `SKIP_GHC`: set this to skip installing `cabal` and `ghc`
`setup.sh` requires `cc`, `curl`, `jq`, `unzip` to run.
The default flavour is `9.12`. Note that if you use the
`9.6`/`9.8`/`9.10`/`9.12` flavour, the `wasm32-wasi-cabal` wrapper
won't automatically set up `head.hackage` in the global config file.
In the early days of `ghc-9.12`, this may result in more packages
being rejected at compile time. This is true for both nix/non-nix
installation methods.
`setup.sh` requires `curl`, `jq`, `unzip`, `zstd` to run.
## Using `ghcup`
We also maintain our own `ghcup` channel in this repo. In case you
prefer to use `ghcup` to install `wasm32-wasi-ghc`:
```sh
$ curl https://gitlab.haskell.org/haskell-wasm/ghc-wasm-meta/-/raw/master/bootstrap.sh | SKIP_GHC=1 sh
$ source ~/.ghc-wasm/env
$ ghcup config add-release-channel https://gitlab.haskell.org/haskell-wasm/ghc-wasm-meta/-/raw/master/ghcup-wasm-0.0.9.yaml
$ ghcup install ghc wasm32-wasi-9.12 -- $CONFIGURE_ARGS
$ cabal --with-compiler=wasm32-wasi-ghc-9.12 --with-hc-pkg=wasm32-wasi-ghc-pkg-9.12 --with-hsc2hs=wasm32-wasi-hsc2hs-9.12 --with-haddock=wasm32-wasi-haddock-9.12 build
```
In case you encounter any issue with `ghcup` based installation,
please seek support in our [matrix
channel](https://matrix.to/#/#haskell-wasm:matrix.org) and do not open
a `ghcup` issue or involve `ghcup` maintainer. Our `ghcup` channel is
*not* affiliated with the `ghcup` project.
## What it emits when it emits a `.wasm` file?
Besides wasm MVP, these extensions are used, given they have been
supported by default in latest versions of major wasm runtimes:
Besides wasm MVP, certain extensions are used. The feature flags are
enabled globally in our
[wasi-sdk](https://gitlab.haskell.org/haskell-wasm/wasi-sdk) build, passed at
GHC configure time, and the wasm NCG may make use of the features. The
rationale of post-MVP wasm feature inclusion:
- Supported by default in latest versions of
Chrome/Firefox/Safari/wasmtime (check wasm
[roadmap](https://webassembly.org/roadmap) for details)
- LLVM support has been stable enough (doesn't get into our way when
enabled globally)
- nontrapping-fptoint
- sign-ext
- bulk-memory
- mutable-globals
- reference-types
List of wasm extensions that we use:
- [128-bit packed
SIMD](https://github.com/WebAssembly/spec/blob/master/proposals/simd/SIMD.md)
- [Non-trapping Float-to-int
Conversions](https://github.com/WebAssembly/spec/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md)
- [Sign-extension
operators](https://github.com/WebAssembly/spec/blob/master/proposals/sign-extension-ops/Overview.md)
- [Bulk Memory
Operations](https://github.com/WebAssembly/spec/blob/master/proposals/bulk-memory-operations/Overview.md)
- [Import/Export mutable
globals](https://github.com/WebAssembly/mutable-global/blob/master/proposals/mutable-global/Overview.md)
- [Multi-value](https://github.com/WebAssembly/spec/blob/master/proposals/multi-value/Overview.md)
- [Reference
Types](https://github.com/WebAssembly/spec/blob/master/proposals/reference-types/Overview.md)
- [Tail
Call](https://github.com/WebAssembly/tail-call/blob/main/proposals/tail-call/Overview.md)
The target triple is `wasm32-wasi`, and it uses WASI snapshot 1 as
used in `wasi-libc`.
## What runtimes support those `.wasm` files?
The output `.wasm` modules are known to run on latest versions of at
least these runtimes:
The output `.wasm` modules are known to run on these runtimes:
### Non-browser non-JavaScript runtimes
- [`wasmtime`](https://wasmtime.dev)
- [`wasmedge`](https://wasmedge.org)
- [`wasmer`](https://wasmer.io)
- [`wasm3`](https://github.com/wasm3/wasm3) (needs latest `main`
revision)
- [`deno`](https://deno.land) (using
[`wasi`](https://deno.land/std/wasi/snapshot_preview1.ts) as WASI
implementation)
- [`node`](https://nodejs.org)
- [`toywasm`](https://github.com/yamt/toywasm)
- [`wasmi`](https://github.com/wasmi-labs/wasmi)
### Non-browser JavaScript runtimes
- [`node`](https://nodejs.org), using the builtin
[`wasi`](https://nodejs.org/api/wasi.html) module to provide WASI
implementation
- [`bun`](https://bun.sh), using the builtin WASI
[implementation](https://github.com/oven-sh/bun/blob/main/src/js/node/wasi.ts)
- [`deno`](https://deno.land), using a legacy WASI
[implementation](https://deno.land/std@0.206.0/wasi/snapshot_preview1.ts)
in `std`
### Browsers
Latest releases of Chrome/Firefox/Safari. A JavaScript library is
needed to provide the WASI implementation, the following one is known
to work for our use cases:
- [`browser_wasi_shim`](https://www.jsdelivr.com/package/npm/@bjorn3/browser_wasi_shim)
## Compiling to WASI reactor module with user-specified exports
Note: if you are using the GHC wasm backend to target browsers, we
already support JSFFI in `master` as well as upcoming 9.10 releases.
See the relevant
[section](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/wasm.html#javascript-ffi-in-the-wasm-backend)
in the GHC user's guide for details. The following content is archived
here for the time being, but eventually we'll move all documentation
to the GHC user's guide.
If you want to embed the compiled wasm module into a host language,
like in JavaScript for running in a browser, then it's highly likely
you want to compile Haskell to a WASI reactor module.
### What is a WASI reactor module?
The WASI spec includes certain
[syscalls](https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md)
that are provided as the `wasi_snapshot_preview1` wasm imports.
Additionally, the current WASI
[ABI](https://github.com/WebAssembly/WASI/blob/main/legacy/application-abi.md)
specifies two different kinds of WASI modules: commands and reactors.
A WASI command module is what you get by default when using
`wasm32-wasi-ghc` to compile & link a Haskell program. It's called
"command" as in a conventional command-line program, with similar
usage and lifecycle: run it with something like `wasmtime`, optionally
passing some arguments and environment variables, it'll run to
completion and probably causing some side effects using whatever
capabilities granted. After it runs to completion, the program state
is finalized.
A WASI reactor module is produced by special link-time flags. It's
called "reactor" since it reacts to external calls of its exported
functions. Once a reactor module is initialized, the program state is
persisted, so if calling an export changes internal state (e.g. sets a
global variable), subsequent calls will observe that change.
### Why the distinction and why should you care?
When linking a program for almost any platform out there, the linker
needs to handle ctors(constructors) & dtors(destructors). ctors and
dtors are special functions that need to be invoked to correctly
initialize/finalize certain runtime state. Even if the user program
doesn't use ctors/dtors, as long as the program links to libc,
ctors/dtors will need to be handled.
The wasm spec does include a [start
function](https://webassembly.github.io/spec/core/syntax/modules.html#syntax-start).
However, due to technical
[reasons](https://github.com/WebAssembly/design/issues/1160), what a
start function can do is rather limited, and may not be sufficient to
support ctors/dtors in libc and other places. So the WASI spec needs
to address this fact, and the command/reactor distinction arises:
- A WASI command module must export a `_start` function. You can see
how `_start` is defined in `wasi-libc`
[here](https://gitlab.haskell.org/haskell-wasm/wasi-libc/-/blob/master/libc-bottom-half/crt/crt1-command.c).
It'll call the ctors, then call the main function in user code, and
finally call the dtors. Since the dtors are called, the program
state is finalized, so attempting to call any export after this
point is undefined behavior!
- A WASI reactor module may export an `_initialize` function, if it
exists, it must be called exactly once before any other exports are
called. See its definition
[here](https://gitlab.haskell.org/haskell-wasm/wasi-libc/-/blob/master/libc-bottom-half/crt/crt1-reactor.c),
it merely calls the ctors. So after `_initialize`, you can call the
exports freely, reusing the instance state. If you want to
"finalize", you're in charge of exporting and calling
`__wasm_call_dtors` yourself.
The command module works well for wasm modules that are intended to be
used like a conventional CLI app. On the otherhand, for more advanced
use cases like running in a browser, you almost always want to create
a reactor module instead.
### Creating a WASI reactor module from `wasm32-wasi-ghc`
Suppose there's a `Hello.hs` that has a `fib :: Int -> Int`. To invoke
it from the JavaScript host, first you need to write down a `foreign
export` for it:
```haskell
foreign export ccall fib :: Int -> Int
```
GHC will create a C function `HsInt fib(HsInt)` that calls into the
actual `fib` Haskell function. Now you need to compile and link it
with special flags:
```sh
$ wasm32-wasi-ghc Hello.hs -o Hello.wasm -no-hs-main -optl-mexec-model=reactor -optl-Wl,--export=hs_init,--export=myMain
```
Some explainers:
- `-no-hs-main`, since we only care about manually exported functions
and don't have a default `main :: IO ()`
- `-optl-mexec-model=reactor` passes `-mexec-model=reactor` to `clang`
when linking, so it creates a WASI reactor instead of a WASI command
- `-optl-Wl,--export=hs_init,--export=fib` passes the linker flags to
export `hs_init` and `fib`
- `-o Hello.wasm` is necessary, otherwise the output name defaults to
`a.out` which can be confusing
The flags above also work in the `ghc-options` field of a cabal
executable component, see
[here](https://github.com/tweag/ormolu/blob/master/ormolu-live/ormolu-live.cabal)
for an example.
Now, here's an example `deno` script to load and run `Hello.wasm`:
```javascript
import WasiContext from "https://deno.land/std@0.206.0/wasi/snapshot_preview1.ts";
const context = new WasiContext({});
const instance = (
await WebAssembly.instantiate(await Deno.readFile("Hello.wasm"), {
wasi_snapshot_preview1: context.exports,
})
).instance;
// The initialize() method will call the module's _initialize export
// under the hood. This is only true for the wasi implementation used
// in this example! If you're using another wasi implementation, do
// read its source code to figure out whether you need to manually
// call the module's _initialize export!
context.initialize(instance);
// This function is a part of GHC's RTS API. It must be called before
// any other exported Haskell functions are called.
instance.exports.hs_init(0, 0);
console.log(instance.exports.fib(10));
```
For simplicity, we call `hs_init` with `argc` set to `0` and `argv`
set to `NULL`, assuming we don't use things like
`getArgs`/`getProgName` in the program. Now, we can call `fib`, or any
function with `foreign export` and the correct `--export=` flag.
Before we add first-class JavaScript interop feature, it's only
possible to use the `ccall` calling convention for foreign exports.
It's still possible to exchange large values between Haskell and
JavaScript:
- Add `--export` flag for `malloc`/`free`. You can now allocate and
free linear memory buffers that can be visible to the Haskell world,
since the entire linear memory is available as the `memory` export.
- In the Haskell world, you can pass `Ptr` as foreign export
argument/return values.
- You can also use `mallocBytes` in `Foreign.Marshal.Alloc` to
allocate buffers in the Haskell world. A buffer allocated by
`mallocBytes` in Haskell can be passed to JavaScript and be freed by
the exported `free`, and vice versa.
If you pass a buffer `malloc`ed in JavaScript into Haskell, before
`free`ing that buffer after the exported Haskell function returns,
look into the Haskell code and double check if that buffer is indeed
fully consumed in Haskell! Otherwise, use-after-free bugs await.
Which functions can be exported via the `--export` flag?
- Any C function which symbol is externally visible. For libc, there
is a
[list](https://gitlab.haskell.org/haskell-wasm/wasi-libc/-/blob/master/expected/wasm32-wasip1/defined-symbols.txt)
of all externally visible symbols. For the GHC RTS, see
[`HsFFI.h`](https://gitlab.haskell.org/ghc/ghc/-/blob/master/rts/include/HsFFI.h)
and
[`RtsAPI.h`](https://gitlab.haskell.org/ghc/ghc/-/blob/master/rts/include/RtsAPI.h)
for the functions that you're likely interested in. For instance,
`hs_init` is in `HsFFI.h`, other variants of `hs_init*` is in
`RtsAPI.h`.
- Any Haskell function that has been exported via a `foreign export`
declaration.
Further reading:
- [Using the FFI with
GHC](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/ffi.html#using-the-ffi-with-ghc)
- [WebAssembly lld port](https://lld.llvm.org/WebAssembly.html)
### Custom imports
In addition to the standard `wasi_snapshot_preview1` import module,
you can add other import modules to import host JavaScript functions
which can be called in C/Haskell. Of course, the resulting wasm module
is not completely compliant to the WASI spec, and cannot be run in
non-browser runtimes that only supports WASI (like `wasmtime`), but
it's not an issue if it's only intended to be run in browsers.
Here's an example:
```c
#include <stdint.h>
## Accessing the host file system
void _fill(void *buf, uint32_t len) __attribute__((
__import_module__("env"),
__import_name__("foo")
));
void fill(void *buf, uint32_t len) {
_fill(buf, len);
}
```
The above assembly source file can be saved as `fill.c`, and
compiled/linked with other C/Haskell sources. The `fill` function can
be called in C as long as you write down its prototype; it can also be
called in Haskell just like any other normal C function.
Now, when creating the instance, in addition to providing the
`wasi_snapshot_preview1` import module, you also need to provide the
`env` import module which has a `foo` function. Whatever `foo` can do
is up to you, reader. It may take a buffer's pointer/length and fill
in something interesting. Since the WASI module has a `memory` export,
`foo` has access to the instance memory and can do whatever it wants.
Custom imports is a powerful feature and provides more than one way to
do things. For instance, if your Haskell program needs to read a large
blob, you may either put that blob in a memfs and read it as if
reading a file; or you can just feed that blob via a custom import. In
this case, a custom import may be simpler, and it further lowers the
requirement on the WASI implementation, since not even a virtual memfs
implementation will be needed at run-time.
It's even possible for the imported function to invoke Haskell
computation by calling exported Haskell functions! This kind of RTS
re-entrance is permitted in GHC RTS, as long as the custom import is
marked with `foreign import ccall safe`.
### Using `wizer` to pre-initialize a WASI reactor module
[`wizer`](https://github.com/bytecodealliance/wizer) is a tool that
takes a wasm module, runs a user-specified initialization function,
then snapshots the wasm instance state into a new wasm module. Since
`wizer` is based on `wasmtime`, it supports WASI modules out of the
box.
I recommend using `wizer` to pre-initialize your WASI reactor module
compiled from Haskell. It's not just about avoiding the overhead of
`_initialize`; the initialization function run by `wizer` is capable
of much more tasks, including but not limited to:
- Set up custom RTS flags and other command line arguments
- Perform arbitrary Haskell computation
- Perform Haskell garbage collection to re-arrange the heap in an
optimal way
It requires a bit of knowledge about GHC's RTS API to write this
initialization function, here's an example:
```c
// Including this since we need access to GHC's RTS API. And it
// transitively includes pretty much all of libc headers that we need.
#include <Rts.h>
// When GHC compiles the Test module with foreign export, it'll
// generate Test_stub.h that declares the prototypes for C functions
// that wrap the corresponding Haskell functions.
#include "Test_stub.h"
// The prototype of hs_init_with_rtsopts is "void
// hs_init_with_rtsopts(int *argc, char **argv[])" which is a bit
// cumbersome to work with, hence this convenience wrapper.
STATIC_INLINE void hs_init_with_rtsopts_(char *argv[]) {
int argc;
for (argc = 0; argv[argc] != NULL; ++argc) {
}
hs_init_with_rtsopts(&argc, &argv);
}
void malloc_inspect_all(void (*handler)(void *start, void *end,
size_t used_bytes, void *callback_arg),
void *arg);
static void malloc_inspect_all_handler(void *start, void *end,
size_t used_bytes, void *callback_arg) {
if (used_bytes == 0) {
memset(start, 0, (size_t)end - (size_t)start);
}
}
extern char __stack_low;
extern char __stack_high;
// Export this function as "wizer.initialize". wizer also accepts
// "--init-func <init-func>" if you dislike this export name, or
// prefer to pass -Wl,--export=my_init at link-time.
//
// By the time this function is called, the WASI reactor _initialize
// has already been called by wizer. The export entries of this
// function and _initialize will both be stripped by wizer.
__attribute__((export_name("wizer.initialize"))) void __wizer_initialize(void) {
// The first argument is what you get in getProgName.
//
// -H64m sets the "suggested heap size" to 64MB and reserves so much
// memory when doing GC for the first time. It's not a hard limit,
// the RTS is perfectly capable of growing the heap beyond it, but
// it's still recommended to reserve a reasonably sized heap in the
// beginning. And it doesn't add 64MB to the wizer output, most of
// the grown memory will be zero anyway!
char *argv[] = {"test.wasm", "+RTS", "-H64m", "-RTS", NULL};
// The WASI reactor _initialize function only takes care of
// initializing the libc state. The GHC RTS needs to be initialized
// using one of hs_init* functions before doing any Haskell
// computation.
hs_init_with_rtsopts_(argv);
// Not interesting, I know. The point is you can perform any Haskell
// computation here! Or C/C++, whatever.
fib(10);
// Perform major GC to clean up the heap. The second run will invoke
// the C finalizers found during the first run.
hs_perform_gc();
hs_perform_gc();
// Zero out the unused RTS memory, to prevent the garbage bytes from
// being snapshotted into the final wasm module. Otherwise it
// wouldn't affect correctness, but the wasm module size would bloat
// significantly. It's only safe to call this after hs_perform_gc()
// has returned.
rts_clearMemory();
// Zero out the unused heap space. `malloc_inspect_all` is a
// dlmalloc internal function which traverses the heap space and can
// be used to zero out some space that's previously allocated and
// then freed. Upstream `wasi-libc` doesn't expose this function
// yet, we do since it's useful for this specific purpose.
malloc_inspect_all(malloc_inspect_all_handler, NULL);
// Zero out the entire stack region in the linear memory. This is
// only suitable to do after all other cleanup has been done and
// we're about to exit `__wizer_initialize`. `__stack_low` and
// `__stack_high` are linker generated symbols which resolve to the
// two ends of the stack region.
memset(&__stack_low, 0, &__stack_high - &__stack_low);
}
```
Then you can compile & link the C code above with a regular Haskell
module, and pre-initialize using `wizer`:
```sh
wasm32-wasi-ghc test.hs test_c.c -o test.wasm -no-hs-main -optl-mexec-model=reactor -optl-Wl,--export=fib
wizer --allow-wasi --wasm-bulk-memory true test.wasm -o test.wizer.wasm
```
Note that `test.wizer.wasm` will be slightly larger than `test.wasm`,
which is expected behavior here, given some computation has already
been run and the linear memory captures more runtime data.
If you run `wasm-opt` to minimize the `wasm` module, it's recommend to
only run it for the `wizer` output. `wasm-opt` will be able to strip
away some unused initialization functions that are no longer reachable
via wasm exports or function table.
## Accessing the host file system in non-browsers
By default, only stdin/stdout/stderr is supported. To access the host
file system, one needs to map the allowed root directory into `/` as a
......@@ -90,7 +543,130 @@ another working directory other than `/` in the virtual filesystem,
use the `PWD` environment variable. This is not a WASI standard, just
a workaround we implemented in the GHC RTS shall the need arises.
## Reporting issues
## Building guide
If you intend to build the GHC's wasm backend, here's a building
guide, assuming you already have some experience with building native
GHC.
### Install `wasi-sdk`
To build the wasm backend, the systemwide C/C++ toolchain won't work.
You need to install our `wasi-sdk`
[fork](https://gitlab.haskell.org/haskell-wasm/wasi-sdk). Upstream `wasi-sdk`
won't work yet.
If your host system is one of `{x86_64,aarch64}-{linux,darwin}`, then
you can avoid building and simply download & extract the GitLab CI
artifact from the latest `master` commit. The linux artifacts are
statically linked and work out of the box on all distros; the macos
artifact contains universal binaries and works on either apple silicon
or intel mac.
If your host system is `x86_64-linux`, you can use the `setup.sh`
script to install it, as documented in previous sections.
For simplicity, the following subsections all assume `wasi-sdk` is
installed to `~/.ghc-wasm/wasi-sdk`, and
`~/.ghc-wasm/wasi-sdk/bin/wasm32-wasi-clang` works.
### Install `libffi-wasm`
Skip this subsection if `wasi-sdk` is installed by `setup.sh` instead
of extracting CI artifacts directly.
Extract the CI artifact of
[`libffi-wasm`](https://gitlab.haskell.org/haskell-wasm/libffi-wasm), and copy
its contents:
- `cp *.h ~/.ghc-wasm/wasi-sdk/share/wasi-sysroot/include/wasm32-wasi`
- `cp *.a ~/.ghc-wasm/wasi-sdk/share/wasi-sysroot/lib/wasm32-wasi`
### Set environment variables
If you used `setup.sh` to install `wasi-sdk`/`libffi-wasm`, then you
can `source ~/.ghc-wasm/env` into your current shell to set the
following environment variables required for building. Otherwise, you
can save this to somewhere else and source that script.
```bash
export AR=~/.ghc-wasm/wasi-sdk/bin/llvm-ar
export CC=~/.ghc-wasm/wasi-sdk/bin/wasm32-wasi-clang
export CC_FOR_BUILD=cc
export CXX=~/.ghc-wasm/wasi-sdk/bin/wasm32-wasi-clang++
export LD=~/.ghc-wasm/wasi-sdk/bin/wasm-ld
export NM=~/.ghc-wasm/wasi-sdk/bin/llvm-nm
export OBJCOPY=~/.ghc-wasm/wasi-sdk/bin/llvm-objcopy
export OBJDUMP=~/.ghc-wasm/wasi-sdk/bin/llvm-objdump
export RANLIB=~/.ghc-wasm/wasi-sdk/bin/llvm-ranlib
export SIZE=~/.ghc-wasm/wasi-sdk/bin/llvm-size
export STRINGS=~/.ghc-wasm/wasi-sdk/bin/llvm-strings
export STRIP=~/.ghc-wasm/wasi-sdk/bin/llvm-strip
export CONF_CC_OPTS_STAGE2="-Wno-error=int-conversion -O3 -mcpu=lime1 -mreference-types -msimd128 -mtail-call"
export CONF_CXX_OPTS_STAGE2="-fno-exceptions -Wno-error=int-conversion -O3 -mcpu=lime1 -mreference-types -msimd128 -mtail-call"
export CONF_GCC_LINKER_OPTS_STAGE2="-Wl,--error-limit=0,--keep-section=ghc_wasm_jsffi,--keep-section=target_features,--stack-first,--strip-debug "
export CONFIGURE_ARGS="--target=wasm32-wasi --with-intree-gmp --with-system-libffi"
```
### Checkout GHC
Checkout GHC.
### Boot & configure & build GHC
The rest is the usual boot & configure & build process. You need to
ensure the environment variables described earlier are correctly set
up; for `ghc.nix` users, it sets up a default `CONFIGURE_ARGS` in the
nix-shell which is incompatible, and the `env` script set up by
`setup.sh` respects existing `CONFIGURE_ARGS`, so don't forget to
unset it first!
Configure with `./configure $CONFIGURE_ARGS`, then build with hadrian.
After the build completes, you can compile stuff to wasm using
`_build/stage1/bin/wasm32-wasi-ghc`.
Happy hacking!
## When something goes wrong
### Reporting issues
If you suspect there's something wrong that needs fixing in the wasm
backend (e.g. runtime crashes), you're more than welcome to open a
ticket in the GHC issue tracker! The `wasm` tag will be added to the
ticket by one of the triagers, which ensures it ends up in my inbox.
It would be very nice to have a self-contained Haskell source file to
reproduce the bug, but it's not a strict necessity to report the bug.
It's fine as long as the project source code and build instruction is
available.
Do include the following info in the ticket:
- Which `ghc-wasm-meta` revision is used to install `wasm32-wasi-ghc`?
Or if you're building it yourself, which GHC revision are you using?
### Getting more insight on the bug
To get some more insight on the bug, there are a few things worth
checking, importance ranked from high to low:
For reporting issues, please use the GHC issue tracker instead. Issues
with the `wasm` tag will be sent to the GHC wasm backend maintainer.
- Try a different runtime environment. If it is a WASI command module
(self-contained `.wasm` file), does it work in `wasmtime` or some
other runtime? If it is meant for the browser, try switching to a
different WASI implementation, does the same bug still occur? It's
known that all current JavaScript implementations of WASI are not
100% feature complete and may have bugs.
- Try a different optimization level in GHC. If it's a cabal project,
you can configure the
[`optimization:`](https://cabal.readthedocs.io/en/latest/cabal-project.html#cfg-field-optimization)
field in `cabal.project`. In case of a code generation bug, it may
be the case that one of the passes during GHC optimization resulted
in buggy code.
- Try enabling `-dlint` at compile-time to check consistency.
- If it crashes, make it crash as early/verbose as possible. Use the
GHC `-debug` flag at link time to link with the debug RTS that
enables certain internal checks. On top of that, pass RTS flags to
enable certain checks, e.g. `+RTS -DS` for sanity checks, see
[here](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/runtime_control.html#rts-options-for-hackers-debuggers-and-over-interested-souls)
for details.
......@@ -6,68 +6,13 @@ async function fetchJSON(url) {
return r.json();
}
async function fetchGitLabMRArtifactURL(
gitlab_domain,
project_id,
merge_request_iid,
job_name,
artifact_path
) {
const pipeline_id = (
await fetchJSON(
`https://${gitlab_domain}/api/v4/projects/${project_id}/merge_requests/${merge_request_iid}/pipelines`
)
)[0].id;
const job_id = (
await fetchJSON(
`https://${gitlab_domain}/api/v4/projects/${project_id}/pipelines/${pipeline_id}/jobs`
)
).find((e) => e.name === job_name).id;
return artifact_path
? `https://${gitlab_domain}/api/v4/projects/${project_id}/jobs/${job_id}/artifacts/${artifact_path}`
: `https://${gitlab_domain}/api/v4/projects/${project_id}/jobs/${job_id}/artifacts`;
}
async function fetchGitLabArtifactURL(
gitlab_domain,
project_id,
ref,
job_name,
artifact_path
) {
const pipeline_id = (
await fetchJSON(
`https://${gitlab_domain}/api/v4/projects/${project_id}/pipelines?status=success&source=push&ref=${ref}`
)
)[0].id;
const job_id = (
await fetchJSON(
`https://${gitlab_domain}/api/v4/projects/${project_id}/pipelines/${pipeline_id}/jobs`
)
).find((e) => e.name === job_name).id;
return artifact_path
? `https://${gitlab_domain}/api/v4/projects/${project_id}/jobs/${job_id}/artifacts/${artifact_path}`
: `https://${gitlab_domain}/api/v4/projects/${project_id}/jobs/${job_id}/artifacts`;
}
const _stableBindists = fetchJSON(
"https://raw.githubusercontent.com/haskell-wasm/ghc-wasm-bindists/main/meta.json"
);
async function fetchGitHubArtifactURL(
owner,
repo,
branch,
workflow_name,
artifact_name
) {
const run_id = (
await fetchJSON(
`https://api.github.com/repos/${owner}/${repo}/actions/runs?branch=${branch}&event=push`
)
).workflow_runs.find((e) => e.name && e.name === workflow_name).id;
const artifact_id = (
await fetchJSON(
`https://api.github.com/repos/${owner}/${repo}/actions/runs/${run_id}/artifacts`
)
).artifacts.find((e) => e.name === artifact_name).id;
return `https://nightly.link/${owner}/${repo}/actions/artifacts/${artifact_id}.zip`;
async function fetchStableBindist(id) {
const dist = (await _stableBindists)[id];
return { url: dist.mirrorUrl, hash: dist.sriHash };
}
async function fetchGitHubLatestReleaseURL(owner, repo, suffix) {
......@@ -78,183 +23,116 @@ async function fetchGitHubLatestReleaseURL(owner, repo, suffix) {
).assets.find((e) => e.name.endsWith(suffix)).browser_download_url;
}
function parseActualHash(msg) {
return Array.from(msg.matchAll(/sha256:[0-9a-z]+/g))
.at(-1)[0]
.split("sha256:")[1];
}
async function fetchHash(fetcher, fetcher_opts) {
const proc = Deno.run({
cmd: [
"nix",
"eval",
"--expr",
`${fetcher}(builtins.fromJSON(${JSON.stringify(
JSON.stringify(fetcher_opts)
)}))`,
],
async function fetchurl(url) {
const cmd = new Deno.Command("nix", {
args: ["store", "prefetch-file", "--hash-type", "sha512", "--json", url],
stdin: "null",
stdout: "null",
stderr: "piped",
stderr: "null",
});
const msg = new TextDecoder().decode(await proc.stderrOutput());
const hash = parseActualHash(msg);
return hash;
const { stdout } = await cmd.output();
return {
url,
hash: JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(stdout))
.hash,
};
}
async function fetchGitLabMRArtifact(
fetcher,
gitlab_domain,
project_id,
merge_request_iid,
job_name,
artifact_path
) {
const url = await fetchGitLabMRArtifactURL(
gitlab_domain,
project_id,
merge_request_iid,
job_name,
artifact_path
);
const sha256 = await fetchHash(fetcher, { url, sha256: "" });
return { url, sha256 };
}
async function fetchGitLabArtifact(
fetcher,
gitlab_domain,
project_id,
ref,
job_name,
artifact_path
) {
const url = await fetchGitLabArtifactURL(
gitlab_domain,
project_id,
ref,
job_name,
artifact_path
);
const sha256 = await fetchHash(fetcher, { url, sha256: "" });
return { url, sha256 };
}
async function fetchGitHubArtifact(
owner,
repo,
branch,
workflow_name,
artifact_name
) {
const url = await fetchGitHubArtifactURL(
owner,
repo,
branch,
workflow_name,
artifact_name
);
const sha256 = await fetchHash("builtins.fetchTarball", { url, sha256: "" });
return { url, sha256 };
}
async function fetchGitHubLatestRelease(fetcher, owner, repo, suffix) {
async function fetchGitHubLatestRelease(owner, repo, suffix) {
const url = await fetchGitHubLatestReleaseURL(owner, repo, suffix);
const sha256 = await fetchHash(fetcher, { url, sha256: "" });
return { url, sha256 };
return fetchurl(url);
}
async function fetchurl(url) {
const sha256 = await fetchHash("builtins.fetchurl", { url, sha256: "" });
return { url, sha256 };
}
const _wasm32_wasi_ghc_gmp = fetchGitLabArtifact(
"builtins.fetchTarball",
"gitlab.haskell.org",
1,
"master",
"x86_64-linux-ubuntu20_04-cross_wasm32-wasi-int_gmp-release",
"ghc-x86_64-linux-ubuntu20_04-cross_wasm32-wasi-int_gmp-release.tar.xz"
const _wasm32_wasi_ghc_gmp = fetchStableBindist("wasm32-wasi-ghc-gmp");
const _wasm32_wasi_ghc_native = fetchStableBindist("wasm32-wasi-ghc-native");
const _wasm32_wasi_ghc_unreg = fetchStableBindist("wasm32-wasi-ghc-unreg");
const _wasm32_wasi_ghc_9_6 = fetchStableBindist("wasm32-wasi-ghc-9.6");
const _wasm32_wasi_ghc_9_8 = fetchStableBindist("wasm32-wasi-ghc-9.8");
const _wasm32_wasi_ghc_9_10 = fetchStableBindist("wasm32-wasi-ghc-9.10");
const _wasm32_wasi_ghc_9_12 = fetchStableBindist("wasm32-wasi-ghc-9.12");
const _wasm32_wasi_ghc_gmp_aarch64_darwin_9_10 = fetchStableBindist(
"wasm32-wasi-ghc-gmp-aarch64-darwin-9.10"
);
const _wasm32_wasi_ghc_gmp_aarch64_darwin_9_12 = fetchStableBindist(
"wasm32-wasi-ghc-gmp-aarch64-darwin-9.12"
);
const _wasm32_wasi_ghc_native = fetchGitLabArtifact(
"builtins.fetchTarball",
"gitlab.haskell.org",
1,
"master",
"x86_64-linux-ubuntu20_04-cross_wasm32-wasi-int_native-release",
"ghc-x86_64-linux-ubuntu20_04-cross_wasm32-wasi-int_native-release.tar.xz"
const _wasm32_wasi_ghc_gmp_aarch64_linux_9_10 = fetchStableBindist(
"wasm32-wasi-ghc-gmp-aarch64-linux-9.10"
);
const _wasi_sdk = fetchGitLabArtifact(
"builtins.fetchTarball",
"gitlab.haskell.org",
3212,
"main",
"x86_64-linux",
"dist/wasi-sdk-16-linux.tar.gz"
const _wasm32_wasi_ghc_gmp_aarch64_linux_9_12 = fetchStableBindist(
"wasm32-wasi-ghc-gmp-aarch64-linux-9.12"
);
const _libffi_wasm = fetchGitLabArtifact(
"builtins.fetchTarball",
"gitlab.haskell.org",
3214,
"master",
"x86_64-linux",
null
const _wasi_sdk = fetchStableBindist("wasi-sdk");
const _wasi_sdk_aarch64_darwin = fetchStableBindist("wasi-sdk-aarch64-darwin");
const _wasi_sdk_x86_64_darwin = fetchStableBindist("wasi-sdk-x86_64-darwin");
const _wasi_sdk_aarch64_linux = fetchStableBindist("wasi-sdk-aarch64-linux");
const _libffi_wasm = fetchStableBindist("libffi-wasm");
const _nodejs = fetchGitHubLatestRelease(
"haskell-wasm",
"node-static",
"linux-x64-static.tar.xz"
);
const _deno = fetchGitHubLatestRelease(
"builtins.fetchTarball",
"denoland",
"deno",
"unknown-linux-gnu.zip"
const _nodejs_aarch64_linux = fetchGitHubLatestRelease(
"haskell-wasm",
"node-static",
"linux-arm64-static.tar.xz"
);
const _nodejs_aarch64_darwin = fetchurl(
"https://nodejs.org/dist/latest/node-v24.3.0-darwin-arm64.tar.xz"
);
const _nodejs_x86_64_darwin = fetchurl(
"https://nodejs.org/dist/latest/node-v24.3.0-darwin-x64.tar.xz"
);
const _binaryen = fetchGitHubLatestRelease(
"builtins.fetchTarball",
"haskell-wasm",
"binaryen",
"x86_64-linux-static.tar.gz"
);
const _binaryen_aarch64_linux = fetchGitHubLatestRelease(
"haskell-wasm",
"binaryen",
"aarch64-linux-static.tar.gz"
);
const _binaryen_aarch64_darwin = fetchGitHubLatestRelease(
"WebAssembly",
"binaryen",
"x86_64-linux.tar.gz"
"arm64-macos.tar.gz"
);
const _wabt = fetchGitHubLatestRelease(
"builtins.fetchTarball",
const _binaryen_x86_64_darwin = fetchGitHubLatestRelease(
"WebAssembly",
"wabt",
"ubuntu.tar.gz"
"binaryen",
"x86_64-macos.tar.gz"
);
const _wasmtime = fetchGitHubLatestRelease(
"builtins.fetchTarball",
"bytecodealliance",
"wasmtime",
"x86_64-linux.tar.xz"
"haskell-wasm",
"wasm-tools-static",
"x86_64-linux.tar.zst"
);
const _wasmedge = fetchGitHubLatestRelease(
"builtins.fetchTarball",
"WasmEdge",
"WasmEdge",
"ubuntu20.04_x86_64.tar.gz"
const _wasmtime_aarch64_linux = fetchGitHubLatestRelease(
"haskell-wasm",
"wasm-tools-static",
"aarch64-linux.tar.zst"
);
const _wasmer = fetchGitHubLatestRelease(
"builtins.fetchurl",
"wasmerio",
"wasmer",
"linux-amd64.tar.gz"
const _wasmtime_aarch64_darwin = fetchGitHubLatestRelease(
"haskell-wasm",
"wasm-tools-static",
"darwin-aarch64.tar.zst"
);
const _wizer = fetchGitHubArtifact(
"bytecodealliance",
"wizer",
"main",
"Release",
"bins-x86_64-linux"
const _wasmtime_x86_64_darwin = fetchGitHubLatestRelease(
"haskell-wasm",
"wasm-tools-static",
"darwin-x86_64.tar.zst"
);
const _cabal = fetchurl(
"https://downloads.haskell.org/cabal/cabal-install-3.8.1.0/cabal-install-3.8.1.0-x86_64-linux-deb10.tar.xz"
"https://downloads.haskell.org/cabal/cabal-install-3.14.2.0/cabal-install-3.14.2.0-x86_64-linux-alpine3_18.tar.xz"
);
const _cabal_aarch64_linux = fetchurl(
"https://downloads.haskell.org/cabal/cabal-install-3.14.2.0/cabal-install-3.14.2.0-aarch64-linux-alpine3_18.tar.xz"
);
const _cabal_aarch64_darwin = fetchurl(
"https://downloads.haskell.org/cabal/cabal-install-3.14.2.0/cabal-install-3.14.2.0-aarch64-darwin.tar.xz"
);
const _proot = fetchGitLabArtifact(
"builtins.fetchurl",
"gitlab.com",
9799675,
"master",
"dist",
"dist/proot"
const _cabal_x86_64_darwin = fetchurl(
"https://downloads.haskell.org/cabal/cabal-install-3.14.2.0/cabal-install-3.14.2.0-x86_64-darwin.tar.xz"
);
await Deno.writeTextFile(
......@@ -263,17 +141,40 @@ await Deno.writeTextFile(
{
"wasm32-wasi-ghc-gmp": await _wasm32_wasi_ghc_gmp,
"wasm32-wasi-ghc-native": await _wasm32_wasi_ghc_native,
"wasm32-wasi-ghc-unreg": await _wasm32_wasi_ghc_unreg,
"wasm32-wasi-ghc-9.6": await _wasm32_wasi_ghc_9_6,
"wasm32-wasi-ghc-9.8": await _wasm32_wasi_ghc_9_8,
"wasm32-wasi-ghc-9.10": await _wasm32_wasi_ghc_9_10,
"wasm32-wasi-ghc-9.12": await _wasm32_wasi_ghc_9_12,
"wasm32-wasi-ghc-gmp-aarch64-darwin-9.10":
await _wasm32_wasi_ghc_gmp_aarch64_darwin_9_10,
"wasm32-wasi-ghc-gmp-aarch64-darwin-9.12":
await _wasm32_wasi_ghc_gmp_aarch64_darwin_9_12,
"wasm32-wasi-ghc-gmp-aarch64-linux-9.10":
await _wasm32_wasi_ghc_gmp_aarch64_linux_9_10,
"wasm32-wasi-ghc-gmp-aarch64-linux-9.12":
await _wasm32_wasi_ghc_gmp_aarch64_linux_9_12,
"wasi-sdk": await _wasi_sdk,
"wasi-sdk-aarch64-darwin": await _wasi_sdk_aarch64_darwin,
"wasi-sdk-x86_64-darwin": await _wasi_sdk_x86_64_darwin,
"wasi-sdk-aarch64-linux": await _wasi_sdk_aarch64_linux,
"libffi-wasm": await _libffi_wasm,
deno: await _deno,
nodejs: await _nodejs,
nodejs_aarch64_linux: await _nodejs_aarch64_linux,
nodejs_aarch64_darwin: await _nodejs_aarch64_darwin,
nodejs_x86_64_darwin: await _nodejs_x86_64_darwin,
binaryen: await _binaryen,
wabt: await _wabt,
binaryen_aarch64_linux: await _binaryen_aarch64_linux,
binaryen_aarch64_darwin: await _binaryen_aarch64_darwin,
binaryen_x86_64_darwin: await _binaryen_x86_64_darwin,
wasmtime: await _wasmtime,
wasmedge: await _wasmedge,
wasmer: await _wasmer,
wizer: await _wizer,
wasmtime_aarch64_linux: await _wasmtime_aarch64_linux,
wasmtime_aarch64_darwin: await _wasmtime_aarch64_darwin,
wasmtime_x86_64_darwin: await _wasmtime_x86_64_darwin,
cabal: await _cabal,
proot: await _proot,
cabal_aarch64_linux: await _cabal_aarch64_linux,
cabal_aarch64_darwin: await _cabal_aarch64_darwin,
cabal_x86_64_darwin: await _cabal_x86_64_darwin,
},
null,
2
......
{
"wasm32-wasi-ghc-gmp": {
"url": "https://gitlab.haskell.org/api/v4/projects/1/jobs/1229004/artifacts/ghc-x86_64-linux-ubuntu20_04-cross_wasm32-wasi-int_gmp-release.tar.xz",
"sha256": "13finpih2lk72vngbag3353pwnkxwkymrw4anwwya155ps2s2zv4"
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp.tar.xz",
"hash": "sha256-DdArQIBqMlFsZn8FKAtPVXo7+/6yDTFch7tDQ1Ph2hQ="
},
"wasm32-wasi-ghc-native": {
"url": "https://gitlab.haskell.org/api/v4/projects/1/jobs/1229005/artifacts/ghc-x86_64-linux-ubuntu20_04-cross_wasm32-wasi-int_native-release.tar.xz",
"sha256": "06wwjk2qnqk4szk9hw314fza6rmpck55amrn203ppbnzx4x8nrfw"
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-native.tar.xz",
"hash": "sha256-nYBEDYsq4rQR3qp6O7sXzOaNV3s0ZhJSjXU4xpfX2HE="
},
"wasm32-wasi-ghc-unreg": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-unreg.tar.xz",
"hash": "sha256-OgXq7OxFIeUusFBKNaCbo1TwrwDylJ9GateW+qHwtO0="
},
"wasm32-wasi-ghc-9.6": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250207T172205/wasm32-wasi-ghc-9.6.tar.xz",
"hash": "sha256-bD9mSqjNw4CEj2IuRe3or7QH/gjd4D3vKNtxEKP5pxk="
},
"wasm32-wasi-ghc-9.8": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250207T172205/wasm32-wasi-ghc-9.8.tar.xz",
"hash": "sha256-k6ZwDW2yG3icZQFzBRimB31rgW86S+ijutvPRLb0LzY="
},
"wasm32-wasi-ghc-9.10": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-9.10.tar.xz",
"hash": "sha256-IK7CHdnW2seSPvAG6qSi9BCOCaMK0xRtx8Ch+77IwpE="
},
"wasm32-wasi-ghc-9.12": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-9.12.tar.xz",
"hash": "sha256-QQz1MtqRm2J3yBT4LFYxci1f+FvxsQGdzSVyoMTOsZM="
},
"wasm32-wasi-ghc-gmp-aarch64-darwin-9.10": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp-aarch64-darwin-9.10.tar.xz",
"hash": "sha256-43+tvX746IBtY3Segln3z6cc/g6LxbX7oxGX4gR5054="
},
"wasm32-wasi-ghc-gmp-aarch64-darwin-9.12": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp-aarch64-darwin-9.12.tar.xz",
"hash": "sha256-Np6ehB0A/ENBsBS13wWAb4IJfls3/e8LGfxAfArw4u4="
},
"wasm32-wasi-ghc-gmp-aarch64-linux-9.10": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp-aarch64-linux-9.10.tar.xz",
"hash": "sha256-1hAHBVdvJKkJeYaOqtDUDqtMjuHtu3QgCtu3loo1J+I="
},
"wasm32-wasi-ghc-gmp-aarch64-linux-9.12": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp-aarch64-linux-9.12.tar.xz",
"hash": "sha256-rbq3R3TliaEk7FYDK88nDDC2DAqjxZlPGqNyYBW/Xs8="
},
"wasi-sdk": {
"url": "https://gitlab.haskell.org/api/v4/projects/3212/jobs/1227986/artifacts/dist/wasi-sdk-16-linux.tar.gz",
"sha256": "1xaaj7l91wwmmdmhl1apcl20gbj1prpjpklbj67wmjqjhrapznh0"
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250701T113726/wasi-sdk.tar.gz",
"hash": "sha256-zCOVApZpm44aokgnljESCaL5y1pxpX+LfahTM2tjTpw="
},
"wasi-sdk-aarch64-darwin": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250701T113726/wasi-sdk-aarch64-darwin.tar.gz",
"hash": "sha256-bykjEEfW927jeEm26e8khKngjA/aC1HhHsZHjUgOXI0="
},
"wasi-sdk-x86_64-darwin": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250701T113726/wasi-sdk-x86_64-darwin.tar.gz",
"hash": "sha256-rV/lgYWF2ADDir5bWVp9lKbysjCn4eR6ui3OgQlp0wc="
},
"wasi-sdk-aarch64-linux": {
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250701T113726/wasi-sdk-aarch64-linux.tar.gz",
"hash": "sha256-oYI9E6xGF8bfISdO6C4h24an7Pwhl0FzkqCD5c4iWSE="
},
"libffi-wasm": {
"url": "https://gitlab.haskell.org/api/v4/projects/3214/jobs/1227903/artifacts",
"sha256": "1rj03kdjn1ppkymcbixwa96gcgyw7gg49vmib861q6wvsm721ia0"
"url": "https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250310T060803/libffi-wasm",
"hash": "sha256-Um9Gcu9zKl0pzFYL3RmAnyFJozOPKVoq1NnU2jilI0s="
},
"nodejs": {
"url": "https://github.com/haskell-wasm/node-static/releases/download/v24.3.0/node-v24.3.0-linux-x64-static.tar.xz",
"hash": "sha512-aXLfvKeg90/iuFkmKHVzyc7toSYi1hAztoeBXXJJmq6RQuLu8fFslOkSCJJyesqOGfJ2AVIReBBknALIt8AyYg=="
},
"nodejs_aarch64_linux": {
"url": "https://github.com/haskell-wasm/node-static/releases/download/v24.3.0/node-v24.3.0-linux-arm64-static.tar.xz",
"hash": "sha512-UD6CRpCnnKKani+7zqgghsXbMMRArHcTfEYRONpHDl8JjpEfYYxFmo7aqJ82DiTRj91VBl9tpP52P3tMT74duA=="
},
"nodejs_aarch64_darwin": {
"url": "https://nodejs.org/dist/latest/node-v24.3.0-darwin-arm64.tar.xz",
"hash": "sha512-zLKowTRdNFiS2es4mnhXTVIE/V8CMf/tjuk0g3jJPMPz7YKik4IPcthT1X2FB61pwBUa6sLBSnKxkU4gOrPORQ=="
},
"deno": {
"url": "https://github.com/denoland/deno/releases/download/v1.27.2/deno-x86_64-unknown-linux-gnu.zip",
"sha256": "07ck4jjgmxd79ifcxbb60789fp4kbk5vvipvl4awkxs15wnp1h9f"
"nodejs_x86_64_darwin": {
"url": "https://nodejs.org/dist/latest/node-v24.3.0-darwin-x64.tar.xz",
"hash": "sha512-EL5IAjjLJrlSA7WodKuvwnY625ibTzbwtMEHRs8N4RtgrFXztQHL3ZclkEkIRLqOxIfmQqFEhShMgS0bABZp9w=="
},
"binaryen": {
"url": "https://github.com/WebAssembly/binaryen/releases/download/version_110/binaryen-version_110-x86_64-linux.tar.gz",
"sha256": "1ck6c2wvhba54y87hb2nbqckp8p7i1nzg3cvk0n2hl1xm568m12g"
"url": "https://github.com/haskell-wasm/binaryen/releases/download/version_123/binaryen-version_123-x86_64-linux-static.tar.gz",
"hash": "sha512-I5THvfPiwhh3STm5i+X06LdJhF5BEjc+ke7ott3ZI0ECZNyO3R4Av00Fo/embP0FXWkA6fe3gWgCY8RWB3PLxQ=="
},
"wabt": {
"url": "https://github.com/WebAssembly/wabt/releases/download/1.0.30/wabt-1.0.30-ubuntu.tar.gz",
"sha256": "0zvbabnrxgy6hr8ijy4z36si2glyk5f4bhw2win43nl1sbxh8kni"
"binaryen_aarch64_linux": {
"url": "https://github.com/haskell-wasm/binaryen/releases/download/version_123/binaryen-version_123-aarch64-linux-static.tar.gz",
"hash": "sha512-ClDIvcIIQb6CZqem4TZyFRpeeXaz91nm9artML3woc1bmkB5E8aSquVlZEWmo9vxr6KOIwbnXdzkv7zNrd+xfQ=="
},
"binaryen_aarch64_darwin": {
"url": "https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-arm64-macos.tar.gz",
"hash": "sha512-BkITiT3XaNRL294ZPiME8pwl09ZiIFC7urm0wXribcF3Gn44xhAtJzxwE1uSiyqvVxG2geSiw2YPTG+ZzT2K8w=="
},
"binaryen_x86_64_darwin": {
"url": "https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-x86_64-macos.tar.gz",
"hash": "sha512-teemLcIwnSEI0SUx+cADbi0g5Nc1VJa+OrwIbL/TYy5yaTNF+dinvNXE8ZrX3+XfJlC7QfmAFXdixlXm3RCvLg=="
},
"wasmtime": {
"url": "https://github.com/bytecodealliance/wasmtime/releases/download/v2.0.2/wasmtime-v2.0.2-x86_64-linux.tar.xz",
"sha256": "1kqs0f24afqdma781209jb5icpi6anr4jd7i797q3jlqyifgppmm"
"url": "https://github.com/haskell-wasm/wasm-tools-static/releases/download/250630/wasm-tools-250630-x86_64-linux.tar.zst",
"hash": "sha512-463xTD4HWeo5cmwe/fulIl68AuBmuvNnqxFtpNGrR2ILNhyb4xzS3+f92KvIIEY3bAz6bjO/k4M/ZI24D7Q3zg=="
},
"wasmedge": {
"url": "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.2/WasmEdge-0.11.2-ubuntu20.04_x86_64.tar.gz",
"sha256": "12529cz889vp2lrvwzga94qa0b6ff4fhi4j25ivym7m22g7yad6q"
"wasmtime_aarch64_linux": {
"url": "https://github.com/haskell-wasm/wasm-tools-static/releases/download/250630/wasm-tools-250630-aarch64-linux.tar.zst",
"hash": "sha512-040ZN9f/nRedBw1GuoQwkLRwrtrEVjkNy4b9z4I/KGfK2YdWha+wEAZ1NwIX2ioNQC5mv2ySoM3qGjUS60UtGg=="
},
"wasmer": {
"url": "https://github.com/wasmerio/wasmer/releases/download/2.3.0/wasmer-linux-amd64.tar.gz",
"sha256": "1ivid43xrki55h0145digkf3xx9sb566hz1xzkigfllq3nwhxabr"
"wasmtime_aarch64_darwin": {
"url": "https://github.com/haskell-wasm/wasm-tools-static/releases/download/250630/wasm-tools-250630-darwin-aarch64.tar.zst",
"hash": "sha512-kAMFQGhyMww/0vbaa8N43ryY3+KbTicVCjB7Y3CEmiZkmukq5PfFGtnjOi1+a1ZmHz6ajtxJsX1OJWeIyIKv8w=="
},
"wizer": {
"url": "https://nightly.link/bytecodealliance/wizer/actions/artifacts/431598906.zip",
"sha256": "0jjmw333nkrcfd0v0kajkfbjyrx4v4j4ypk3g6kz8g16gbysxmpz"
"wasmtime_x86_64_darwin": {
"url": "https://github.com/haskell-wasm/wasm-tools-static/releases/download/250630/wasm-tools-250630-darwin-x86_64.tar.zst",
"hash": "sha512-RCQ60HTMWtMCBaA4hbd6k9U6ILtXH9upiv5AZ0GDsx31Qpze8wijBFgo3QOOKPkW8ybaRFM4bKruHTQ0kIrGbw=="
},
"cabal": {
"url": "https://downloads.haskell.org/cabal/cabal-install-3.8.1.0/cabal-install-3.8.1.0-x86_64-linux-deb10.tar.xz",
"sha256": "0js242sml0ns813gzld2bl79a92wh5h8d5myhsxkblj2zm31l6n7"
"url": "https://downloads.haskell.org/cabal/cabal-install-3.14.2.0/cabal-install-3.14.2.0-x86_64-linux-alpine3_18.tar.xz",
"hash": "sha512-Hq45Oz6To2FJs8N/E3lDZddZo1jCRbJ2/l315i+GuHm3AEC6Msfp2Kh7A4UjZBklU4L8ehhdw19htjr53hxSOA=="
},
"cabal_aarch64_linux": {
"url": "https://downloads.haskell.org/cabal/cabal-install-3.14.2.0/cabal-install-3.14.2.0-aarch64-linux-alpine3_18.tar.xz",
"hash": "sha512-JaDF/3wgzsfhiOyLni25ms6P+R3tMTmQuWLlTGDN+7C2l89vZ1NFf+BebwN7/FbVh650yWmM/QNxQblIcJ5hYQ=="
},
"cabal_aarch64_darwin": {
"url": "https://downloads.haskell.org/cabal/cabal-install-3.14.2.0/cabal-install-3.14.2.0-aarch64-darwin.tar.xz",
"hash": "sha512-sll3WAoA2YGf41WFJNGxTnvfndyqrB8jzFuQH6iLQwcxb21/8//hruEo82a+bp+i79CYmmHDzKZzrhZpEvqrPQ=="
},
"proot": {
"url": "https://gitlab.com/api/v4/projects/9799675/jobs/2370229665/artifacts/dist/proot",
"sha256": "1lkhvm46r1p83xggzvav3m61rqgbzszal1a99wb0l015lbssvwmp"
"cabal_x86_64_darwin": {
"url": "https://downloads.haskell.org/cabal/cabal-install-3.14.2.0/cabal-install-3.14.2.0-x86_64-darwin.tar.xz",
"hash": "sha512-eS1cl/omMcm/ojN2zMoQs8MdEOodhPvwSWFtmYzaVhk5u9mwFKOm42Yvv97NWLbgolb/1bIydjCR5jG4Pkn4Vw=="
}
}
\ No newline at end of file
#!/bin/sh
set -eu
cd "$(mktemp -d)"
curl -f -L --retry 5 https://gitlab.haskell.org/haskell-wasm/ghc-wasm-meta/-/archive/master/ghc-wasm-meta-master.tar.gz | tar xz --strip-components=1
exec ./setup.sh
......@@ -5,21 +5,28 @@ repository hackage.haskell.org
root-keys:
fe331502606802feac15e514d9b9ea83fee8b6ffef71335479a2e68d84adc6b0
1ea9ba32c526d1cc91ab5e5bd364ec5e9e8cb67179a471872f6e26f0ae773d42
2c6c3627bd6c982990239487f1abd02e08a02e6cf16edb105a8012d444d870c3
0a5c7ea47cd1b15f01f5f51a33adda7e655bc0f0b0615baa8e271f4c3351e21d
51f0161b906011b52c6613376b1ae937670da69322113a246a09f807c62f6921
d26e46f3b631aae1433b89379a6c68bd417eb5d1c408f0643dcc07757fece522
be75553f3c7ba1dbe298da81f1d1b05c9d39dd8ed2616c9bddf1525ca8c03e48
repository head.hackage.ghc.haskell.org
url: https://ghc.gitlab.haskell.org/head.hackage/
secure: True
key-threshold: 3
root-keys:
f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89
26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329
url: https://ghc.gitlab.haskell.org/head.hackage/
secure: True
key-threshold: 3
root-keys:
7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d
26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329
f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89
active-repositories: hackage.haskell.org, head.hackage.ghc.haskell.org:override
executable-stripping: False
jobs: $ncpus
library-stripping: False
minimize-conflict-set: True
optimization: True
semaphore: True
shared: True
library-for-ghci: False
repository hackage.haskell.org
url: https://hackage.haskell.org/
secure: True
key-threshold: 3
root-keys:
fe331502606802feac15e514d9b9ea83fee8b6ffef71335479a2e68d84adc6b0
1ea9ba32c526d1cc91ab5e5bd364ec5e9e8cb67179a471872f6e26f0ae773d42
0a5c7ea47cd1b15f01f5f51a33adda7e655bc0f0b0615baa8e271f4c3351e21d
51f0161b906011b52c6613376b1ae937670da69322113a246a09f807c62f6921
d26e46f3b631aae1433b89379a6c68bd417eb5d1c408f0643dcc07757fece522
be75553f3c7ba1dbe298da81f1d1b05c9d39dd8ed2616c9bddf1525ca8c03e48
executable-stripping: False
jobs: $ncpus
library-stripping: False
minimize-conflict-set: True
optimization: True
semaphore: True
shared: False
library-for-ghci: False
allow-newer:
all:Cabal,
all:Cabal-syntax,
all:array,
all:base,
all:binary,
all:bytestring,
all:containers,
all:deepseq,
all:directory,
all:exceptions,
all:filepath,
all:ghc,
all:ghc-bignum,
all:ghc-boot,
all:ghc-boot-th,
all:ghc-compact,
all:ghc-experimental,
all:ghc-heap,
all:ghc-internal,
all:ghc-platform,
all:ghc-prim,
all:ghc-toolchain,
all:ghci,
all:haskeline,
all:hpc,
all:integer-gmp,
all:mtl,
all:os-string,
all:parsec,
all:pretty,
all:process,
all:rts,
all:semaphore-compat,
all:stm,
all:system-cxx-std-lib,
all:template-haskell,
all:text,
all:time,
all:transformers,
all:unix,
all:xhtml
constraints:
Cabal installed,
Cabal-syntax installed,
array installed,
base installed,
binary installed,
bytestring installed,
containers installed,
deepseq installed,
directory installed,
exceptions installed,
filepath installed,
ghc installed,
ghc-bignum installed,
ghc-boot installed,
ghc-boot-th installed,
ghc-compact installed,
ghc-experimental installed,
ghc-heap installed,
ghc-internal installed,
ghc-platform installed,
ghc-prim installed,
ghc-toolchain installed,
ghci installed,
haskeline installed,
hpc installed,
integer-gmp installed,
mtl installed,
os-string installed,
parsec installed,
pretty installed,
process installed,
rts installed,
semaphore-compat installed,
stm installed,
system-cxx-std-lib installed,
template-haskell installed,
text installed,
time installed,
transformers installed,
unix installed,
xhtml installed
repository hackage.haskell.org
url: https://hackage.haskell.org/
secure: True
key-threshold: 3
root-keys:
fe331502606802feac15e514d9b9ea83fee8b6ffef71335479a2e68d84adc6b0
1ea9ba32c526d1cc91ab5e5bd364ec5e9e8cb67179a471872f6e26f0ae773d42
0a5c7ea47cd1b15f01f5f51a33adda7e655bc0f0b0615baa8e271f4c3351e21d
51f0161b906011b52c6613376b1ae937670da69322113a246a09f807c62f6921
d26e46f3b631aae1433b89379a6c68bd417eb5d1c408f0643dcc07757fece522
be75553f3c7ba1dbe298da81f1d1b05c9d39dd8ed2616c9bddf1525ca8c03e48
executable-stripping: False
jobs: $ncpus
library-stripping: False
minimize-conflict-set: True
optimization: True
semaphore: True
shared: True
library-for-ghci: False
{
"nodes": {
"HTTP": {
"flake": false,
"locked": {
"lastModified": 1451647621,
"narHash": "sha256-oHIyw3x0iKBexEo49YeUDV1k74ZtyYKGR2gNJXXRxts=",
"owner": "phadej",
"repo": "HTTP",
"rev": "9bc0996d412fef1787449d841277ef663ad9a915",
"type": "github"
},
"original": {
"owner": "phadej",
"repo": "HTTP",
"type": "github"
}
},
"blank": {
"locked": {
"lastModified": 1625557891,
"narHash": "sha256-O8/MWsPBGhhyPoPLHZAuoZiiHo9q6FLlEeIDEXuj6T4=",
"owner": "divnix",
"repo": "blank",
"rev": "5a5d2684073d9f563072ed07c871d577a6c614a8",
"type": "github"
},
"original": {
"owner": "divnix",
"repo": "blank",
"type": "github"
}
},
"cabal-32": {
"flake": false,
"locked": {
"lastModified": 1603716527,
"narHash": "sha256-X0TFfdD4KZpwl0Zr6x+PLxUt/VyKQfX7ylXHdmZIL+w=",
"owner": "haskell",
"repo": "cabal",
"rev": "48bf10787e27364730dd37a42b603cee8d6af7ee",
"type": "github"
},
"original": {
"owner": "haskell",
"ref": "3.2",
"repo": "cabal",
"type": "github"
}
},
"cabal-34": {
"flake": false,
"locked": {
"lastModified": 1640353650,
"narHash": "sha256-N1t6M3/wqj90AEdRkeC8i923gQYUpzSr8b40qVOZ1Rk=",
"owner": "haskell",
"repo": "cabal",
"rev": "942639c18c0cd8ec53e0a6f8d120091af35312cd",
"type": "github"
},
"original": {
"owner": "haskell",
"ref": "3.4",
"repo": "cabal",
"type": "github"
}
},
"cabal-36": {
"flake": false,
"locked": {
"lastModified": 1641652457,
"narHash": "sha256-BlFPKP4C4HRUJeAbdembX1Rms1LD380q9s0qVDeoAak=",
"owner": "haskell",
"repo": "cabal",
"rev": "f27667f8ec360c475027dcaee0138c937477b070",
"type": "github"
},
"original": {
"owner": "haskell",
"ref": "3.6",
"repo": "cabal",
"type": "github"
}
},
"cardano-shell": {
"flake": false,
"locked": {
"lastModified": 1608537748,
"narHash": "sha256-PulY1GfiMgKVnBci3ex4ptk2UNYMXqGjJOxcPy2KYT4=",
"owner": "input-output-hk",
"repo": "cardano-shell",
"rev": "9392c75087cb9a3d453998f4230930dea3a95725",
"type": "github"
},
"original": {
"owner": "input-output-hk",
"repo": "cardano-shell",
"type": "github"
}
},
"devshell": {
"inputs": {
"flake-utils": [
"haskell-nix",
"tullia",
"std",
"flake-utils"
],
"nixpkgs": [
"haskell-nix",
"tullia",
"std",
"nixpkgs"
]
},
"locked": {
"lastModified": 1663445644,
"narHash": "sha256-+xVlcK60x7VY1vRJbNUEAHi17ZuoQxAIH4S4iUFUGBA=",
"owner": "numtide",
"repo": "devshell",
"rev": "e3dc3e21594fe07bdb24bdf1c8657acaa4cb8f66",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "devshell",
"type": "github"
}
},
"dmerge": {
"inputs": {
"nixlib": [
"haskell-nix",
"tullia",
"std",
"nixpkgs"
],
"yants": [
"haskell-nix",
"tullia",
"std",
"yants"
]
},
"locked": {
"lastModified": 1659548052,
"narHash": "sha256-fzI2gp1skGA8mQo/FBFrUAtY0GQkAIAaV/V127TJPyY=",
"owner": "divnix",
"repo": "data-merge",
"rev": "d160d18ce7b1a45b88344aa3f13ed1163954b497",
"type": "github"
},
"original": {
"owner": "divnix",
"repo": "data-merge",
"type": "github"
}
},
"flake-compat": {
"flake": false,
"locked": {
"lastModified": 1635892615,
"narHash": "sha256-harGbMZr4hzat2BWBU+Y5OYXlu+fVz7E4WeQzHi5o8A=",
"owner": "input-output-hk",
"repo": "flake-compat",
"rev": "eca47d3377946315596da653862d341ee5341318",
"type": "github"
},
"original": {
"owner": "input-output-hk",
"repo": "flake-compat",
"type": "github"
}
},
"flake-compat_2": {
"flake": false,
"locked": {
"lastModified": 1650374568,
"narHash": "sha256-Z+s0J8/r907g149rllvwhb4pKi8Wam5ij0st8PwAh+E=",
"owner": "edolstra",
"repo": "flake-compat",
"rev": "b4a34015c698c7793d592d66adbab377907a2be8",
"type": "github"
},
"original": {
"owner": "edolstra",
"repo": "flake-compat",
"type": "github"
}
},
"flake-utils": {
"locked": {
"lastModified": 1644229661,
"narHash": "sha256-1YdnJAsNy69bpcjuoKdOYQX0YxZBiCYZo4Twxerqv7k=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "3cecb5b042f7f209c56ffd8371b2711a290ec797",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"flake-utils_2": {
"locked": {
"lastModified": 1653893745,
"narHash": "sha256-0jntwV3Z8//YwuOjzhV2sgJJPt+HY6KhU7VZUL0fKZQ=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "1ed9fb1935d260de5fe1c2f7ee0ebaae17ed2fa1",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"flake-utils_3": {
"locked": {
"lastModified": 1659877975,
"narHash": "sha256-zllb8aq3YO3h8B/U0/J1WBgAL8EX5yWf5pMj3G0NAmc=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "c0e246b9b83f637f4681389ecabcb2681b4f3af0",
"type": "github"
"inputs": {
"systems": "systems"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"flake-utils_4": {
"locked": {
"lastModified": 1653893745,
"narHash": "sha256-0jntwV3Z8//YwuOjzhV2sgJJPt+HY6KhU7VZUL0fKZQ=",
"lastModified": 1731533236,
"narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "1ed9fb1935d260de5fe1c2f7ee0ebaae17ed2fa1",
"rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
"type": "github"
},
"original": {
......@@ -248,420 +18,13 @@
"type": "github"
}
},
"ghc-8.6.5-iohk": {
"flake": false,
"locked": {
"lastModified": 1600920045,
"narHash": "sha256-DO6kxJz248djebZLpSzTGD6s8WRpNI9BTwUeOf5RwY8=",
"owner": "input-output-hk",
"repo": "ghc",
"rev": "95713a6ecce4551240da7c96b6176f980af75cae",
"type": "github"
},
"original": {
"owner": "input-output-hk",
"ref": "release/8.6.5-iohk",
"repo": "ghc",
"type": "github"
}
},
"gomod2nix": {
"inputs": {
"nixpkgs": "nixpkgs_2",
"utils": "utils"
},
"locked": {
"lastModified": 1655245309,
"narHash": "sha256-d/YPoQ/vFn1+GTmSdvbSBSTOai61FONxB4+Lt6w/IVI=",
"owner": "tweag",
"repo": "gomod2nix",
"rev": "40d32f82fc60d66402eb0972e6e368aeab3faf58",
"type": "github"
},
"original": {
"owner": "tweag",
"repo": "gomod2nix",
"type": "github"
}
},
"hackage": {
"flake": false,
"locked": {
"lastModified": 1668215453,
"narHash": "sha256-TSaa+7jbBQZnYKQTCUoeg53xGV+gdWTasn7t4HWUxkI=",
"owner": "input-output-hk",
"repo": "hackage.nix",
"rev": "f312f9c91789abbbd6c9ce6380644a8de7c843fb",
"type": "github"
},
"original": {
"owner": "input-output-hk",
"repo": "hackage.nix",
"type": "github"
}
},
"haskell-nix": {
"inputs": {
"HTTP": "HTTP",
"cabal-32": "cabal-32",
"cabal-34": "cabal-34",
"cabal-36": "cabal-36",
"cardano-shell": "cardano-shell",
"flake-compat": "flake-compat",
"flake-utils": "flake-utils",
"ghc-8.6.5-iohk": "ghc-8.6.5-iohk",
"hackage": "hackage",
"hpc-coveralls": "hpc-coveralls",
"hydra": "hydra",
"nixpkgs": [
"haskell-nix",
"nixpkgs-unstable"
],
"nixpkgs-2003": "nixpkgs-2003",
"nixpkgs-2105": "nixpkgs-2105",
"nixpkgs-2111": "nixpkgs-2111",
"nixpkgs-2205": "nixpkgs-2205",
"nixpkgs-unstable": "nixpkgs-unstable",
"old-ghc-nix": "old-ghc-nix",
"stackage": "stackage",
"tullia": "tullia"
},
"locked": {
"lastModified": 1668215626,
"narHash": "sha256-zZCuXg9IOsGlgHm/7r0P515CAbB6FtIT0XO872vTz9E=",
"owner": "input-output-hk",
"repo": "haskell.nix",
"rev": "3b759d41b8920c0989554959afd93fa299682abf",
"type": "github"
},
"original": {
"owner": "input-output-hk",
"repo": "haskell.nix",
"type": "github"
}
},
"hpc-coveralls": {
"flake": false,
"locked": {
"lastModified": 1607498076,
"narHash": "sha256-8uqsEtivphgZWYeUo5RDUhp6bO9j2vaaProQxHBltQk=",
"owner": "sevanspowell",
"repo": "hpc-coveralls",
"rev": "14df0f7d229f4cd2e79f8eabb1a740097fdfa430",
"type": "github"
},
"original": {
"owner": "sevanspowell",
"repo": "hpc-coveralls",
"type": "github"
}
},
"hydra": {
"inputs": {
"nix": "nix",
"nixpkgs": [
"haskell-nix",
"hydra",
"nix",
"nixpkgs"
]
},
"locked": {
"lastModified": 1646878427,
"narHash": "sha256-KtbrofMtN8GlM7D+n90kixr7QpSlVmdN+vK5CA/aRzc=",
"owner": "NixOS",
"repo": "hydra",
"rev": "28b682b85b7efc5cf7974065792a1f22203a5927",
"type": "github"
},
"original": {
"id": "hydra",
"type": "indirect"
}
},
"lowdown-src": {
"flake": false,
"locked": {
"lastModified": 1633514407,
"narHash": "sha256-Dw32tiMjdK9t3ETl5fzGrutQTzh2rufgZV4A/BbxuD4=",
"owner": "kristapsdz",
"repo": "lowdown",
"rev": "d2c2b44ff6c27b936ec27358a2653caaef8f73b8",
"type": "github"
},
"original": {
"owner": "kristapsdz",
"repo": "lowdown",
"type": "github"
}
},
"mdbook-kroki-preprocessor": {
"flake": false,
"locked": {
"lastModified": 1661755005,
"narHash": "sha256-1TJuUzfyMycWlOQH67LR63/ll2GDZz25I3JfScy/Jnw=",
"owner": "JoelCourtney",
"repo": "mdbook-kroki-preprocessor",
"rev": "93adb5716d035829efed27f65f2f0833a7d3e76f",
"type": "github"
},
"original": {
"owner": "JoelCourtney",
"repo": "mdbook-kroki-preprocessor",
"type": "github"
}
},
"n2c": {
"inputs": {
"flake-utils": "flake-utils_4",
"nixpkgs": [
"haskell-nix",
"tullia",
"std",
"nixpkgs"
]
},
"locked": {
"lastModified": 1665039323,
"narHash": "sha256-SAh3ZjFGsaCI8FRzXQyp56qcGdAqgKEfJWPCQ0Sr7tQ=",
"owner": "nlewo",
"repo": "nix2container",
"rev": "b008fe329ffb59b67bf9e7b08ede6ee792f2741a",
"type": "github"
},
"original": {
"owner": "nlewo",
"repo": "nix2container",
"type": "github"
}
},
"nix": {
"inputs": {
"lowdown-src": "lowdown-src",
"nixpkgs": "nixpkgs",
"nixpkgs-regression": "nixpkgs-regression"
},
"locked": {
"lastModified": 1643066034,
"narHash": "sha256-xEPeMcNJVOeZtoN+d+aRwolpW8mFSEQx76HTRdlhPhg=",
"owner": "NixOS",
"repo": "nix",
"rev": "a1cd7e58606a41fcf62bf8637804cf8306f17f62",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "2.6.0",
"repo": "nix",
"type": "github"
}
},
"nix-nomad": {
"inputs": {
"flake-compat": "flake-compat_2",
"flake-utils": [
"haskell-nix",
"tullia",
"nix2container",
"flake-utils"
],
"gomod2nix": "gomod2nix",
"nixpkgs": [
"haskell-nix",
"tullia",
"nixpkgs"
],
"nixpkgs-lib": [
"haskell-nix",
"tullia",
"nixpkgs"
]
},
"locked": {
"lastModified": 1658277770,
"narHash": "sha256-T/PgG3wUn8Z2rnzfxf2VqlR1CBjInPE0l1yVzXxPnt0=",
"owner": "tristanpemble",
"repo": "nix-nomad",
"rev": "054adcbdd0a836ae1c20951b67ed549131fd2d70",
"type": "github"
},
"original": {
"owner": "tristanpemble",
"repo": "nix-nomad",
"type": "github"
}
},
"nix2container": {
"inputs": {
"flake-utils": "flake-utils_2",
"nixpkgs": "nixpkgs_3"
},
"locked": {
"lastModified": 1658567952,
"narHash": "sha256-XZ4ETYAMU7XcpEeAFP3NOl9yDXNuZAen/aIJ84G+VgA=",
"owner": "nlewo",
"repo": "nix2container",
"rev": "60bb43d405991c1378baf15a40b5811a53e32ffa",
"type": "github"
},
"original": {
"owner": "nlewo",
"repo": "nix2container",
"type": "github"
}
},
"nixago": {
"inputs": {
"flake-utils": [
"haskell-nix",
"tullia",
"std",
"flake-utils"
],
"nixago-exts": [
"haskell-nix",
"tullia",
"std",
"blank"
],
"nixpkgs": [
"haskell-nix",
"tullia",
"std",
"nixpkgs"
]
},
"locked": {
"lastModified": 1661824785,
"narHash": "sha256-/PnwdWoO/JugJZHtDUioQp3uRiWeXHUdgvoyNbXesz8=",
"owner": "nix-community",
"repo": "nixago",
"rev": "8c1f9e5f1578d4b2ea989f618588d62a335083c3",
"type": "github"
},
"original": {
"owner": "nix-community",
"repo": "nixago",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1632864508,
"narHash": "sha256-d127FIvGR41XbVRDPVvozUPQ/uRHbHwvfyKHwEt5xFM=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "82891b5e2c2359d7e58d08849e4c89511ab94234",
"type": "github"
},
"original": {
"id": "nixpkgs",
"ref": "nixos-21.05-small",
"type": "indirect"
}
},
"nixpkgs-2003": {
"locked": {
"lastModified": 1620055814,
"narHash": "sha256-8LEHoYSJiL901bTMVatq+rf8y7QtWuZhwwpKE2fyaRY=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "1db42b7fe3878f3f5f7a4f2dc210772fd080e205",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-20.03-darwin",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs-2105": {
"locked": {
"lastModified": 1659914493,
"narHash": "sha256-lkA5X3VNMKirvA+SUzvEhfA7XquWLci+CGi505YFAIs=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "022caabb5f2265ad4006c1fa5b1ebe69fb0c3faf",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-21.05-darwin",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs-2111": {
"locked": {
"lastModified": 1659446231,
"narHash": "sha256-hekabNdTdgR/iLsgce5TGWmfIDZ86qjPhxDg/8TlzhE=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "eabc38219184cc3e04a974fe31857d8e0eac098d",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-21.11-darwin",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs-2205": {
"locked": {
"lastModified": 1663981975,
"narHash": "sha256-TKaxWAVJR+a5JJauKZqibmaM5e/Pi5tBDx9s8fl/kSE=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "309faedb8338d3ae8ad8f1043b3ccf48c9cc2970",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-22.05-darwin",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs-regression": {
"locked": {
"lastModified": 1643052045,
"narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
"type": "github"
},
"original": {
"id": "nixpkgs",
"rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
"type": "indirect"
}
},
"nixpkgs-unstable": {
"locked": {
"lastModified": 1663905476,
"narHash": "sha256-0CSwRKaYravh9v6qSlBpM0gNg0UhKT2lL7Yn6Zbx7UM=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "e14f9fb57315f0d4abde222364f19f88c77d2b79",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs_2": {
"locked": {
"lastModified": 1653581809,
"narHash": "sha256-Uvka0V5MTGbeOfWte25+tfRL3moECDh1VwokWSZUdoY=",
"lastModified": 1750731501,
"narHash": "sha256-Ah4qq+SbwMaGkuXCibyg+Fwn00el4KmI3XFX6htfDuk=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "83658b28fe638a170a19b8933aa008b30640fbd1",
"rev": "69dfebb3d175bde602f612915c5576a41b18486b",
"type": "github"
},
"original": {
......@@ -671,172 +34,24 @@
"type": "github"
}
},
"nixpkgs_3": {
"locked": {
"lastModified": 1654807842,
"narHash": "sha256-ADymZpr6LuTEBXcy6RtFHcUZdjKTBRTMYwu19WOx17E=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "fc909087cc3386955f21b4665731dbdaceefb1d8",
"type": "github"
},
"original": {
"owner": "NixOS",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs_4": {
"locked": {
"lastModified": 1665087388,
"narHash": "sha256-FZFPuW9NWHJteATOf79rZfwfRn5fE0wi9kRzvGfDHPA=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "95fda953f6db2e9496d2682c4fc7b82f959878f7",
"type": "github"
},
"original": {
"owner": "nixos",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"old-ghc-nix": {
"flake": false,
"locked": {
"lastModified": 1631092763,
"narHash": "sha256-sIKgO+z7tj4lw3u6oBZxqIhDrzSkvpHtv0Kki+lh9Fg=",
"owner": "angerman",
"repo": "old-ghc-nix",
"rev": "af48a7a7353e418119b6dfe3cd1463a657f342b8",
"type": "github"
},
"original": {
"owner": "angerman",
"ref": "master",
"repo": "old-ghc-nix",
"type": "github"
}
},
"root": {
"inputs": {
"haskell-nix": "haskell-nix"
}
},
"stackage": {
"flake": false,
"locked": {
"lastModified": 1668215559,
"narHash": "sha256-zFrY0groarE9R87O/N7uD0RK8vLkvreNRhrw3o5Bl9I=",
"owner": "input-output-hk",
"repo": "stackage.nix",
"rev": "82cdafd6b9053ebca799f20db4438e0563521a17",
"type": "github"
},
"original": {
"owner": "input-output-hk",
"repo": "stackage.nix",
"type": "github"
}
},
"std": {
"inputs": {
"blank": "blank",
"devshell": "devshell",
"dmerge": "dmerge",
"flake-utils": "flake-utils_3",
"makes": [
"haskell-nix",
"tullia",
"std",
"blank"
],
"mdbook-kroki-preprocessor": "mdbook-kroki-preprocessor",
"microvm": [
"haskell-nix",
"tullia",
"std",
"blank"
],
"n2c": "n2c",
"nixago": "nixago",
"nixpkgs": "nixpkgs_4",
"yants": "yants"
},
"locked": {
"lastModified": 1665513321,
"narHash": "sha256-D6Pacw9yf/HMs84KYuCxHXnNDL7v43gtcka5URagFqE=",
"owner": "divnix",
"repo": "std",
"rev": "94a90eedb9cfc115b12ae8f6622d9904788559e4",
"type": "github"
},
"original": {
"owner": "divnix",
"repo": "std",
"type": "github"
}
},
"tullia": {
"inputs": {
"nix-nomad": "nix-nomad",
"nix2container": "nix2container",
"nixpkgs": [
"haskell-nix",
"nixpkgs"
],
"std": "std"
},
"locked": {
"lastModified": 1666200256,
"narHash": "sha256-cJPS8zBu30SMhxMe7I8DWutwqMuhPsEez87y9gxMKc4=",
"owner": "input-output-hk",
"repo": "tullia",
"rev": "575362c2244498e8d2c97f72861510fa72e75d44",
"type": "github"
},
"original": {
"owner": "input-output-hk",
"repo": "tullia",
"type": "github"
}
},
"utils": {
"locked": {
"lastModified": 1653893745,
"narHash": "sha256-0jntwV3Z8//YwuOjzhV2sgJJPt+HY6KhU7VZUL0fKZQ=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "1ed9fb1935d260de5fe1c2f7ee0ebaae17ed2fa1",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
"flake-utils": "flake-utils",
"nixpkgs": "nixpkgs"
}
},
"yants": {
"inputs": {
"nixpkgs": [
"haskell-nix",
"tullia",
"std",
"nixpkgs"
]
},
"systems": {
"locked": {
"lastModified": 1660507851,
"narHash": "sha256-BKjq7JnVuUR/xDtcv6Vm9GYGKAblisXrAgybor9hT/s=",
"owner": "divnix",
"repo": "yants",
"rev": "0b895ca02a8fa72bad50b454cb3e7d8a66407c96",
"lastModified": 1681028828,
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
"owner": "nix-systems",
"repo": "default",
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
"type": "github"
},
"original": {
"owner": "divnix",
"repo": "yants",
"owner": "nix-systems",
"repo": "default",
"type": "github"
}
}
......
{
inputs = {
haskell-nix = {
type = "github";
owner = "input-output-hk";
repo = "haskell.nix";
};
};
inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
inputs.flake-utils.url = "github:numtide/flake-utils";
outputs = { self, haskell-nix, }:
haskell-nix.inputs.flake-utils.lib.eachSystem [ "x86_64-linux" ] (system:
let
pkgs = import haskell-nix.inputs.nixpkgs-unstable {
inherit system;
config = haskell-nix.config;
overlays = [ haskell-nix.overlay ];
};
default = pkgs.symlinkJoin {
name = "ghc-wasm";
paths = [
wasm32-wasi-ghc-gmp
wasi-sdk
deno
binaryen
wabt
wasmtime
wasmedge
wasmer
wizer
cabal
wasm32-wasi-cabal
proot
wasm-run
];
};
wasm32-wasi-ghc-gmp = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix {
bignumBackend = "gmp";
};
wasm32-wasi-ghc-native = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix {
bignumBackend = "native";
};
wasi-sdk = pkgs.callPackage ./pkgs/wasi-sdk.nix { };
deno = pkgs.callPackage ./pkgs/deno.nix { };
binaryen = pkgs.callPackage ./pkgs/binaryen.nix { };
wabt = pkgs.callPackage ./pkgs/wabt.nix { };
wasmtime = pkgs.callPackage ./pkgs/wasmtime.nix { };
wasmedge = pkgs.callPackage ./pkgs/wasmedge.nix { };
wasmer = pkgs.callPackage ./pkgs/wasmer.nix { };
wizer = pkgs.callPackage ./pkgs/wizer.nix { };
cabal = pkgs.callPackage ./pkgs/cabal.nix { };
wasm32-wasi-cabal = pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix {
bignumBackend = "gmp";
};
proot = pkgs.callPackage ./pkgs/proot.nix { };
wasm-run = pkgs.callPackage ./pkgs/wasm-run.nix { };
in
{
packages = {
inherit default wasm32-wasi-ghc-gmp wasm32-wasi-ghc-native wasi-sdk
deno binaryen wabt wasmtime wasmedge wasmer wizer cabal
wasm32-wasi-cabal proot wasm-run;
};
});
outputs =
{
self,
nixpkgs,
flake-utils,
}:
flake-utils.lib.eachSystem
[
"x86_64-linux"
"aarch64-darwin"
"aarch64-linux"
"x86_64-darwin"
]
(
system:
let
pkgs = import nixpkgs {
inherit system;
config = {
permittedInsecurePackages = [ "openssl-1.1.1w" ];
};
};
all =
flavour:
pkgs.symlinkJoin {
name = "ghc-wasm";
paths =
[
pkgs.haskellPackages.alex
pkgs.haskellPackages.happy
(pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix { inherit flavour; })
wasi-sdk
pkgs.cacert
nodejs
binaryen
wasmtime
cabal
(pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix { inherit flavour; })
];
};
wasm32-wasi-ghc-gmp = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix { flavour = "gmp"; };
wasm32-wasi-ghc-native = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix { flavour = "native"; };
wasm32-wasi-ghc-unreg = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix { flavour = "unreg"; };
wasm32-wasi-ghc-9_6 = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix { flavour = "9.6"; };
wasm32-wasi-ghc-9_8 = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix { flavour = "9.8"; };
wasm32-wasi-ghc-9_10 = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix { flavour = "9.10"; };
wasm32-wasi-ghc-9_12 = pkgs.callPackage ./pkgs/wasm32-wasi-ghc.nix { flavour = "9.12"; };
wasm32-wasi-cabal-gmp = pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix { flavour = "gmp"; };
wasm32-wasi-cabal-native = pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix { flavour = "native"; };
wasm32-wasi-cabal-unreg = pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix { flavour = "unreg"; };
wasm32-wasi-cabal-9_6 = pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix { flavour = "9.6"; };
wasm32-wasi-cabal-9_8 = pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix { flavour = "9.8"; };
wasm32-wasi-cabal-9_10 = pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix { flavour = "9.10"; };
wasm32-wasi-cabal-9_12 = pkgs.callPackage ./pkgs/wasm32-wasi-cabal.nix { flavour = "9.12"; };
wasi-sdk = pkgs.callPackage ./pkgs/wasi-sdk.nix { };
nodejs = pkgs.nodejs_latest;
binaryen = pkgs.callPackage ./pkgs/binaryen.nix { };
wasmtime = pkgs.callPackage ./pkgs/wasmtime.nix { };
cabal = pkgs.callPackage ./pkgs/cabal.nix { };
in
{
packages = {
inherit
all
wasm32-wasi-ghc-gmp
wasm32-wasi-ghc-native
wasm32-wasi-ghc-unreg
wasm32-wasi-ghc-9_6
wasm32-wasi-ghc-9_8
wasm32-wasi-ghc-9_10
wasm32-wasi-ghc-9_12
wasm32-wasi-cabal-gmp
wasm32-wasi-cabal-native
wasm32-wasi-cabal-unreg
wasm32-wasi-cabal-9_6
wasm32-wasi-cabal-9_8
wasm32-wasi-cabal-9_10
wasm32-wasi-cabal-9_12
wasi-sdk
nodejs
binaryen
wasmtime
cabal
;
default = all "9.12";
all_gmp = all "gmp";
all_native = all "native";
all_unreg = all "unreg";
all_9_6 = all "9.6";
all_9_8 = all "9.8";
all_9_10 = all "9.10";
all_9_12 = all "9.12";
};
}
);
}
toolRequirements: {}
ghcupDownloads:
GHC:
wasm32-wasi-9.13.20250412:
viTags: []
viArch:
A_64:
Linux_UnknownLinux: &ref_0
unknown_versioning:
dlHash: 403acefd10ac51643e0ce08af1e672c6c1882c7fa2a479e48cc2cf1afd91e1c9
dlSubdir: ghc-9.13.20250412-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250413T202158/wasm32-wasi-ghc-gmp.tar.xz'
dlOutput: 403acefd10ac51643e0ce08af1e672c6c1882c7fa2a479e48cc2cf1afd91e1c9.tar.xz
Linux_Alpine: *ref_0
wasm32-wasi-9.12.2.20250327:
viTags: []
viArch:
A_64:
Linux_UnknownLinux: &ref_1
unknown_versioning:
dlHash: 410cf532da919b6277c814f82c5631722d5ff85bf1b1019dcd2572a0c4ceb193
dlSubdir: ghc-9.12.2.20250327-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-9.12.tar.xz'
dlOutput: 410cf532da919b6277c814f82c5631722d5ff85bf1b1019dcd2572a0c4ceb193.tar.xz
Linux_Alpine: *ref_1
A_ARM64:
Darwin:
unknown_versioning:
dlHash: 369e9e841d00fc4341b014b5df05806f82097e5b37fdef0b19fc407c0af0e2ee
dlSubdir: ghc-9.12.2.20250327-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp-aarch64-darwin-9.12.tar.xz'
dlOutput: 369e9e841d00fc4341b014b5df05806f82097e5b37fdef0b19fc407c0af0e2ee.tar.xz
Linux_UnknownLinux: &ref_2
unknown_versioning:
dlHash: adbab74774e589a124ec56032bcf270c30b60c0aa3c5994f1aa3726015bf5ecf
dlSubdir: ghc-9.12.2.20250327-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp-aarch64-linux-9.12.tar.xz'
dlOutput: adbab74774e589a124ec56032bcf270c30b60c0aa3c5994f1aa3726015bf5ecf.tar.xz
Linux_Alpine: *ref_2
wasm32-wasi-9.10.1.20250327:
viTags: []
viArch:
A_64:
Linux_UnknownLinux: &ref_3
unknown_versioning:
dlHash: 20aec21dd9d6dac7923ef006eaa4a2f4108e09a30ad3146dc7c0a1fbbec8c291
dlSubdir: ghc-9.10.1.20250327-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-9.10.tar.xz'
dlOutput: 20aec21dd9d6dac7923ef006eaa4a2f4108e09a30ad3146dc7c0a1fbbec8c291.tar.xz
Linux_Alpine: *ref_3
A_ARM64:
Darwin:
unknown_versioning:
dlHash: e37fadbd7ef8e8806d63749e8259f7cfa71cfe0e8bc5b5fba31197e20479d39e
dlSubdir: ghc-9.10.1.20250327-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp-aarch64-darwin-9.10.tar.xz'
dlOutput: e37fadbd7ef8e8806d63749e8259f7cfa71cfe0e8bc5b5fba31197e20479d39e.tar.xz
Linux_UnknownLinux: &ref_4
unknown_versioning:
dlHash: d6100705576f24a90979868eaad0d40eab4c8ee1edbb74200adbb7968a3527e2
dlSubdir: ghc-9.10.1.20250327-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250327T193751/wasm32-wasi-ghc-gmp-aarch64-linux-9.10.tar.xz'
dlOutput: d6100705576f24a90979868eaad0d40eab4c8ee1edbb74200adbb7968a3527e2.tar.xz
Linux_Alpine: *ref_4
wasm32-wasi-9.8.4.20250206:
viTags: []
viArch:
A_64:
Linux_UnknownLinux: &ref_5
unknown_versioning:
dlHash: 93a6700d6db21b789c6501730518a6077d6b816f3a4be8a3badbcf44b6f42f36
dlSubdir: ghc-9.8.4.20250206-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250207T172205/wasm32-wasi-ghc-9.8.tar.xz'
dlOutput: 93a6700d6db21b789c6501730518a6077d6b816f3a4be8a3badbcf44b6f42f36.tar.xz
Linux_Alpine: *ref_5
wasm32-wasi-9.6.7.20250206:
viTags: []
viArch:
A_64:
Linux_UnknownLinux: &ref_6
unknown_versioning:
dlHash: 6c3f664aa8cdc380848f622e45ede8afb407fe08dde03def28db7110a3f9a719
dlSubdir: ghc-9.6.7.20250206-wasm32-wasi
dlUri: 'https://github.com/haskell-wasm/ghc-wasm-bindists/releases/download/20250207T172205/wasm32-wasi-ghc-9.6.tar.xz'
dlOutput: 6c3f664aa8cdc380848f622e45ede8afb407fe08dde03def28db7110a3f9a719.tar.xz
Linux_Alpine: *ref_6
#!/usr/bin/env -S deno run --allow-net --allow-read --allow-run --allow-write
import * as encoding from "jsr:@std/encoding";
import * as yaml from "jsr:@std/yaml";
async function fetchJSON(url) {
const r = await fetch(url);
if (!r.ok) throw new Error(await r.text());
return r.json();
}
const meta_json = await fetchJSON(
"https://raw.githubusercontent.com/haskell-wasm/ghc-wasm-bindists/main/meta.json"
);
function sri2hex(sri) {
const [_algo, b64] = sri.split("-");
return encoding.encodeHex(encoding.decodeBase64(b64));
}
function meta2ghcup(obj) {
return {
dlHash: sri2hex(obj.sriHash),
dlSubdir: obj.ghcSubdir,
dlUri: obj.mirrorUrl,
dlOutput: `${sri2hex(obj.sriHash)}.tar.xz`,
};
}
const ghcup_metadata = {
toolRequirements: {},
ghcupDownloads: { GHC: {} },
};
for (const flavour of ["gmp", "9.12", "9.10", "9.8", "9.6"]) {
const ver = meta_json[`wasm32-wasi-ghc-${flavour}`].ghcSubdir
.replaceAll("ghc-", "")
.replaceAll("-wasm32-wasi", "");
const x86_64_linux = {
unknown_versioning: meta2ghcup(meta_json[`wasm32-wasi-ghc-${flavour}`]),
};
ghcup_metadata.ghcupDownloads.GHC[`wasm32-wasi-${ver}`] = {
viTags: [],
viArch: {
A_64: {
Linux_UnknownLinux: x86_64_linux,
Linux_Alpine: x86_64_linux,
},
},
};
if (meta_json[`wasm32-wasi-ghc-gmp-aarch64-darwin-${flavour}`]) {
ghcup_metadata.ghcupDownloads.GHC[`wasm32-wasi-${ver}`].viArch.A_ARM64 = {
Darwin: {
unknown_versioning: meta2ghcup(
meta_json[`wasm32-wasi-ghc-gmp-aarch64-darwin-${flavour}`]
),
},
};
}
if (meta_json[`wasm32-wasi-ghc-gmp-aarch64-linux-${flavour}`]) {
const aarch64_linux = {
unknown_versioning: meta2ghcup(
meta_json[`wasm32-wasi-ghc-gmp-aarch64-linux-${flavour}`]
),
};
ghcup_metadata.ghcupDownloads.GHC[
`wasm32-wasi-${ver}`
].viArch.A_ARM64.Linux_UnknownLinux = aarch64_linux;
ghcup_metadata.ghcupDownloads.GHC[
`wasm32-wasi-${ver}`
].viArch.A_ARM64.Linux_Alpine = aarch64_linux;
}
}
await Deno.writeTextFile(
"ghcup-wasm-0.0.9.yaml",
yaml.stringify(ghcup_metadata, { lineWidth: 1024 })
);
#!/bin/sh
exec podman run -it --rm \
--env CI_PROJECT_DIR=/workspace \
--env CPUS=48 \
--env FLAVOUR="$1" \
--env PLAYWRIGHT=1 \
--user root \
--init \
--privileged \
--tmpfs /tmp:exec \
--volume "$PWD":/workspace \
--workdir /workspace \
registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-ubuntu24_04:6e9f8f17086e56e83adae4a8a9d63e2fec3cb6c7 \
bash -c \
"apt update && apt full-upgrade -y && apt install -y bash-completion nano zstd && cp /etc/skel/{.bash_logout,.bashrc,.profile} /root && PREFIX=/tmp/.ghc-wasm ./setup.sh && . /tmp/.ghc-wasm/env && exec bash -i"
{
"name": "ghc-wasm-meta",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"dependencies": {
"puppeteer-core": "^24.11.1",
"ws": "^8.18.3"
}
},
"node_modules/@puppeteer/browsers": {
"version": "2.10.5",
"resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.10.5.tgz",
"integrity": "sha512-eifa0o+i8dERnngJwKrfp3dEq7ia5XFyoqB17S4gK8GhsQE4/P8nxOfQSE0zQHxzzLo/cmF+7+ywEQ7wK7Fb+w==",
"license": "Apache-2.0",
"dependencies": {
"debug": "^4.4.1",
"extract-zip": "^2.0.1",
"progress": "^2.0.3",
"proxy-agent": "^6.5.0",
"semver": "^7.7.2",
"tar-fs": "^3.0.8",
"yargs": "^17.7.2"
},
"bin": {
"browsers": "lib/cjs/main-cli.js"
},
"engines": {
"node": ">=18"
}
},
"node_modules/@tootallnate/quickjs-emscripten": {
"version": "0.23.0",
"resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
"integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
"license": "MIT"
},
"node_modules/@types/node": {
"version": "24.0.7",
"resolved": "https://registry.npmjs.org/@types/node/-/node-24.0.7.tgz",
"integrity": "sha512-YIEUUr4yf8q8oQoXPpSlnvKNVKDQlPMWrmOcgzoduo7kvA2UF0/BwJ/eMKFTiTtkNL17I0M6Xe2tvwFU7be6iw==",
"license": "MIT",
"optional": true,
"dependencies": {
"undici-types": "~7.8.0"
}
},
"node_modules/@types/yauzl": {
"version": "2.10.3",
"resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
"integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
"license": "MIT",
"optional": true,
"dependencies": {
"@types/node": "*"
}
},
"node_modules/agent-base": {
"version": "7.1.3",
"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
"integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
"license": "MIT",
"engines": {
"node": ">= 14"
}
},
"node_modules/ansi-regex": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/ansi-styles": {
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
"license": "MIT",
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/ast-types": {
"version": "0.13.4",
"resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
"integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
"license": "MIT",
"dependencies": {
"tslib": "^2.0.1"
},
"engines": {
"node": ">=4"
}
},
"node_modules/b4a": {
"version": "1.6.7",
"resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz",
"integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==",
"license": "Apache-2.0"
},
"node_modules/bare-events": {
"version": "2.5.4",
"resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.5.4.tgz",
"integrity": "sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==",
"license": "Apache-2.0",
"optional": true
},
"node_modules/bare-fs": {
"version": "4.1.5",
"resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.1.5.tgz",
"integrity": "sha512-1zccWBMypln0jEE05LzZt+V/8y8AQsQQqxtklqaIyg5nu6OAYFhZxPXinJTSG+kU5qyNmeLgcn9AW7eHiCHVLA==",
"license": "Apache-2.0",
"optional": true,
"dependencies": {
"bare-events": "^2.5.4",
"bare-path": "^3.0.0",
"bare-stream": "^2.6.4"
},
"engines": {
"bare": ">=1.16.0"
},
"peerDependencies": {
"bare-buffer": "*"
},
"peerDependenciesMeta": {
"bare-buffer": {
"optional": true
}
}
},
"node_modules/bare-os": {
"version": "3.6.1",
"resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.1.tgz",
"integrity": "sha512-uaIjxokhFidJP+bmmvKSgiMzj2sV5GPHaZVAIktcxcpCyBFFWO+YlikVAdhmUo2vYFvFhOXIAlldqV29L8126g==",
"license": "Apache-2.0",
"optional": true,
"engines": {
"bare": ">=1.14.0"
}
},
"node_modules/bare-path": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
"integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
"license": "Apache-2.0",
"optional": true,
"dependencies": {
"bare-os": "^3.0.1"
}
},
"node_modules/bare-stream": {
"version": "2.6.5",
"resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.6.5.tgz",
"integrity": "sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==",
"license": "Apache-2.0",
"optional": true,
"dependencies": {
"streamx": "^2.21.0"
},
"peerDependencies": {
"bare-buffer": "*",
"bare-events": "*"
},
"peerDependenciesMeta": {
"bare-buffer": {
"optional": true
},
"bare-events": {
"optional": true
}
}
},
"node_modules/basic-ftp": {
"version": "5.0.5",
"resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.0.5.tgz",
"integrity": "sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==",
"license": "MIT",
"engines": {
"node": ">=10.0.0"
}
},
"node_modules/buffer-crc32": {
"version": "0.2.13",
"resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
"integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
"license": "MIT",
"engines": {
"node": "*"
}
},
"node_modules/chromium-bidi": {
"version": "5.1.0",
"resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-5.1.0.tgz",
"integrity": "sha512-9MSRhWRVoRPDG0TgzkHrshFSJJNZzfY5UFqUMuksg7zL1yoZIZ3jLB0YAgHclbiAxPI86pBnwDX1tbzoiV8aFw==",
"license": "Apache-2.0",
"dependencies": {
"mitt": "^3.0.1",
"zod": "^3.24.1"
},
"peerDependencies": {
"devtools-protocol": "*"
}
},
"node_modules/cliui": {
"version": "8.0.1",
"resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
"integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
"license": "ISC",
"dependencies": {
"string-width": "^4.2.0",
"strip-ansi": "^6.0.1",
"wrap-ansi": "^7.0.0"
},
"engines": {
"node": ">=12"
}
},
"node_modules/color-convert": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
"license": "MIT",
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/color-name": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
"license": "MIT"
},
"node_modules/data-uri-to-buffer": {
"version": "6.0.2",
"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
"integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
"license": "MIT",
"engines": {
"node": ">= 14"
}
},
"node_modules/debug": {
"version": "4.4.1",
"resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
"integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
"license": "MIT",
"dependencies": {
"ms": "^2.1.3"
},
"engines": {
"node": ">=6.0"
},
"peerDependenciesMeta": {
"supports-color": {
"optional": true
}
}
},
"node_modules/degenerator": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
"integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
"license": "MIT",
"dependencies": {
"ast-types": "^0.13.4",
"escodegen": "^2.1.0",
"esprima": "^4.0.1"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/devtools-protocol": {
"version": "0.0.1464554",
"resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1464554.tgz",
"integrity": "sha512-CAoP3lYfwAGQTaAXYvA6JZR0fjGUb7qec1qf4mToyoH2TZgUFeIqYcjh6f9jNuhHfuZiEdH+PONHYrLhRQX6aw==",
"license": "BSD-3-Clause"
},
"node_modules/emoji-regex": {
"version": "8.0.0",
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
"license": "MIT"
},
"node_modules/end-of-stream": {
"version": "1.4.5",
"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
"integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
"license": "MIT",
"dependencies": {
"once": "^1.4.0"
}
},
"node_modules/escalade": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
"integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
"license": "MIT",
"engines": {
"node": ">=6"
}
},
"node_modules/escodegen": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
"integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
"license": "BSD-2-Clause",
"dependencies": {
"esprima": "^4.0.1",
"estraverse": "^5.2.0",
"esutils": "^2.0.2"
},
"bin": {
"escodegen": "bin/escodegen.js",
"esgenerate": "bin/esgenerate.js"
},
"engines": {
"node": ">=6.0"
},
"optionalDependencies": {
"source-map": "~0.6.1"
}
},
"node_modules/esprima": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
"license": "BSD-2-Clause",
"bin": {
"esparse": "bin/esparse.js",
"esvalidate": "bin/esvalidate.js"
},
"engines": {
"node": ">=4"
}
},
"node_modules/estraverse": {
"version": "5.3.0",
"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
"integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
"license": "BSD-2-Clause",
"engines": {
"node": ">=4.0"
}
},
"node_modules/esutils": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
"integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
"license": "BSD-2-Clause",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/extract-zip": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
"integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
"license": "BSD-2-Clause",
"dependencies": {
"debug": "^4.1.1",
"get-stream": "^5.1.0",
"yauzl": "^2.10.0"
},
"bin": {
"extract-zip": "cli.js"
},
"engines": {
"node": ">= 10.17.0"
},
"optionalDependencies": {
"@types/yauzl": "^2.9.1"
}
},
"node_modules/fast-fifo": {
"version": "1.3.2",
"resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
"integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
"license": "MIT"
},
"node_modules/fd-slicer": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
"integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
"license": "MIT",
"dependencies": {
"pend": "~1.2.0"
}
},
"node_modules/get-caller-file": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
"integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
"license": "ISC",
"engines": {
"node": "6.* || 8.* || >= 10.*"
}
},
"node_modules/get-stream": {
"version": "5.2.0",
"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
"integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
"license": "MIT",
"dependencies": {
"pump": "^3.0.0"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/get-uri": {
"version": "6.0.4",
"resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.4.tgz",
"integrity": "sha512-E1b1lFFLvLgak2whF2xDBcOy6NLVGZBqqjJjsIhvopKfWWEi64pLVTWWehV8KlLerZkfNTA95sTe2OdJKm1OzQ==",
"license": "MIT",
"dependencies": {
"basic-ftp": "^5.0.2",
"data-uri-to-buffer": "^6.0.2",
"debug": "^4.3.4"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/http-proxy-agent": {
"version": "7.0.2",
"resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
"integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
"license": "MIT",
"dependencies": {
"agent-base": "^7.1.0",
"debug": "^4.3.4"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/https-proxy-agent": {
"version": "7.0.6",
"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
"integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
"license": "MIT",
"dependencies": {
"agent-base": "^7.1.2",
"debug": "4"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/ip-address": {
"version": "9.0.5",
"resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz",
"integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==",
"license": "MIT",
"dependencies": {
"jsbn": "1.1.0",
"sprintf-js": "^1.1.3"
},
"engines": {
"node": ">= 12"
}
},
"node_modules/is-fullwidth-code-point": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/jsbn": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz",
"integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==",
"license": "MIT"
},
"node_modules/lru-cache": {
"version": "7.18.3",
"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
"integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
"license": "ISC",
"engines": {
"node": ">=12"
}
},
"node_modules/mitt": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
"integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
"license": "MIT"
},
"node_modules/ms": {
"version": "2.1.3",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
"license": "MIT"
},
"node_modules/netmask": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz",
"integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==",
"license": "MIT",
"engines": {
"node": ">= 0.4.0"
}
},
"node_modules/once": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
"license": "ISC",
"dependencies": {
"wrappy": "1"
}
},
"node_modules/pac-proxy-agent": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
"integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
"license": "MIT",
"dependencies": {
"@tootallnate/quickjs-emscripten": "^0.23.0",
"agent-base": "^7.1.2",
"debug": "^4.3.4",
"get-uri": "^6.0.1",
"http-proxy-agent": "^7.0.0",
"https-proxy-agent": "^7.0.6",
"pac-resolver": "^7.0.1",
"socks-proxy-agent": "^8.0.5"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/pac-resolver": {
"version": "7.0.1",
"resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
"integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
"license": "MIT",
"dependencies": {
"degenerator": "^5.0.0",
"netmask": "^2.0.2"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/pend": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
"integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
"license": "MIT"
},
"node_modules/progress": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
"integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
"license": "MIT",
"engines": {
"node": ">=0.4.0"
}
},
"node_modules/proxy-agent": {
"version": "6.5.0",
"resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
"integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
"license": "MIT",
"dependencies": {
"agent-base": "^7.1.2",
"debug": "^4.3.4",
"http-proxy-agent": "^7.0.1",
"https-proxy-agent": "^7.0.6",
"lru-cache": "^7.14.1",
"pac-proxy-agent": "^7.1.0",
"proxy-from-env": "^1.1.0",
"socks-proxy-agent": "^8.0.5"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/proxy-from-env": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
"integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
"license": "MIT"
},
"node_modules/pump": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
"integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
"license": "MIT",
"dependencies": {
"end-of-stream": "^1.1.0",
"once": "^1.3.1"
}
},
"node_modules/puppeteer-core": {
"version": "24.11.1",
"resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.11.1.tgz",
"integrity": "sha512-I0Gv3jWBRY9E3NTBElp7br7Gaid5RbFTxCRRMHym1kCf0ompO0Pel4REGsGDwMWkg3uwFzIH7t7qXs3T4DKRWA==",
"license": "Apache-2.0",
"dependencies": {
"@puppeteer/browsers": "2.10.5",
"chromium-bidi": "5.1.0",
"debug": "^4.4.1",
"devtools-protocol": "0.0.1464554",
"typed-query-selector": "^2.12.0",
"ws": "^8.18.2"
},
"engines": {
"node": ">=18"
}
},
"node_modules/require-directory": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
"integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
"license": "MIT",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/semver": {
"version": "7.7.2",
"resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
"integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
"license": "ISC",
"bin": {
"semver": "bin/semver.js"
},
"engines": {
"node": ">=10"
}
},
"node_modules/smart-buffer": {
"version": "4.2.0",
"resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
"integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
"license": "MIT",
"engines": {
"node": ">= 6.0.0",
"npm": ">= 3.0.0"
}
},
"node_modules/socks": {
"version": "2.8.5",
"resolved": "https://registry.npmjs.org/socks/-/socks-2.8.5.tgz",
"integrity": "sha512-iF+tNDQla22geJdTyJB1wM/qrX9DMRwWrciEPwWLPRWAUEM8sQiyxgckLxWT1f7+9VabJS0jTGGr4QgBuvi6Ww==",
"license": "MIT",
"dependencies": {
"ip-address": "^9.0.5",
"smart-buffer": "^4.2.0"
},
"engines": {
"node": ">= 10.0.0",
"npm": ">= 3.0.0"
}
},
"node_modules/socks-proxy-agent": {
"version": "8.0.5",
"resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
"integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
"license": "MIT",
"dependencies": {
"agent-base": "^7.1.2",
"debug": "^4.3.4",
"socks": "^2.8.3"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/source-map": {
"version": "0.6.1",
"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
"integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
"license": "BSD-3-Clause",
"optional": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/sprintf-js": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
"integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
"license": "BSD-3-Clause"
},
"node_modules/streamx": {
"version": "2.22.1",
"resolved": "https://registry.npmjs.org/streamx/-/streamx-2.22.1.tgz",
"integrity": "sha512-znKXEBxfatz2GBNK02kRnCXjV+AA4kjZIUxeWSr3UGirZMJfTE9uiwKHobnbgxWyL/JWro8tTq+vOqAK1/qbSA==",
"license": "MIT",
"dependencies": {
"fast-fifo": "^1.3.2",
"text-decoder": "^1.1.0"
},
"optionalDependencies": {
"bare-events": "^2.2.0"
}
},
"node_modules/string-width": {
"version": "4.2.3",
"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
"license": "MIT",
"dependencies": {
"emoji-regex": "^8.0.0",
"is-fullwidth-code-point": "^3.0.0",
"strip-ansi": "^6.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/strip-ansi": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
"license": "MIT",
"dependencies": {
"ansi-regex": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tar-fs": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.0.tgz",
"integrity": "sha512-5Mty5y/sOF1YWj1J6GiBodjlDc05CUR8PKXrsnFAiSG0xA+GHeWLovaZPYUDXkH/1iKRf2+M5+OrRgzC7O9b7w==",
"license": "MIT",
"dependencies": {
"pump": "^3.0.0",
"tar-stream": "^3.1.5"
},
"optionalDependencies": {
"bare-fs": "^4.0.1",
"bare-path": "^3.0.0"
}
},
"node_modules/tar-stream": {
"version": "3.1.7",
"resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
"integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
"license": "MIT",
"dependencies": {
"b4a": "^1.6.4",
"fast-fifo": "^1.2.0",
"streamx": "^2.15.0"
}
},
"node_modules/text-decoder": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
"integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
"license": "Apache-2.0",
"dependencies": {
"b4a": "^1.6.4"
}
},
"node_modules/tslib": {
"version": "2.8.1",
"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
"license": "0BSD"
},
"node_modules/typed-query-selector": {
"version": "2.12.0",
"resolved": "https://registry.npmjs.org/typed-query-selector/-/typed-query-selector-2.12.0.tgz",
"integrity": "sha512-SbklCd1F0EiZOyPiW192rrHZzZ5sBijB6xM+cpmrwDqObvdtunOHHIk9fCGsoK5JVIYXoyEp4iEdE3upFH3PAg==",
"license": "MIT"
},
"node_modules/undici-types": {
"version": "7.8.0",
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz",
"integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==",
"license": "MIT",
"optional": true
},
"node_modules/wrap-ansi": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
"integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
"license": "MIT",
"dependencies": {
"ansi-styles": "^4.0.0",
"string-width": "^4.1.0",
"strip-ansi": "^6.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/chalk/wrap-ansi?sponsor=1"
}
},
"node_modules/wrappy": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
"license": "ISC"
},
"node_modules/ws": {
"version": "8.18.3",
"resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
"integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
"license": "MIT",
"engines": {
"node": ">=10.0.0"
},
"peerDependencies": {
"bufferutil": "^4.0.1",
"utf-8-validate": ">=5.0.2"
},
"peerDependenciesMeta": {
"bufferutil": {
"optional": true
},
"utf-8-validate": {
"optional": true
}
}
},
"node_modules/y18n": {
"version": "5.0.8",
"resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
"integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
"license": "ISC",
"engines": {
"node": ">=10"
}
},
"node_modules/yargs": {
"version": "17.7.2",
"resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
"integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
"license": "MIT",
"dependencies": {
"cliui": "^8.0.1",
"escalade": "^3.1.1",
"get-caller-file": "^2.0.5",
"require-directory": "^2.1.1",
"string-width": "^4.2.3",
"y18n": "^5.0.5",
"yargs-parser": "^21.1.1"
},
"engines": {
"node": ">=12"
}
},
"node_modules/yargs-parser": {
"version": "21.1.1",
"resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
"integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
"license": "ISC",
"engines": {
"node": ">=12"
}
},
"node_modules/yauzl": {
"version": "2.10.0",
"resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
"integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
"license": "MIT",
"dependencies": {
"buffer-crc32": "~0.2.3",
"fd-slicer": "~1.1.0"
}
},
"node_modules/zod": {
"version": "3.25.67",
"resolved": "https://registry.npmjs.org/zod/-/zod-3.25.67.tgz",
"integrity": "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw==",
"license": "MIT",
"funding": {
"url": "https://github.com/sponsors/colinhacks"
}
}
}
}
{
"dependencies": {
"puppeteer-core": "^24.11.1",
"ws": "^8.18.3"
}
}
{ autoPatchelfHook, stdenvNoCC, }:
{
fetchurl,
fixDarwinDylibNames,
hostPlatform,
lib,
stdenv,
}:
let
src = builtins.fetchTarball
((builtins.fromJSON (builtins.readFile ../autogen.json)).binaryen);
src = fetchurl ((builtins.fromJSON (builtins.readFile ../autogen.json))."${key}");
key =
{
x86_64-linux = "binaryen";
aarch64-linux = "binaryen_aarch64_linux";
aarch64-darwin = "binaryen_aarch64_darwin";
x86_64-darwin = "binaryen_x86_64_darwin";
}
."${hostPlatform.system}";
in
stdenvNoCC.mkDerivation {
stdenv.mkDerivation {
name = "binaryen";
dontUnpack = true;
nativeBuildInputs = [ autoPatchelfHook ];
inherit src;
nativeBuildInputs =
lib.optionals hostPlatform.isDarwin [ fixDarwinDylibNames ];
installPhase = ''
mkdir -p $out/bin
install -Dm755 ${src}/bin/* $out/bin
runHook preInstall
cp -R ./ $out
runHook postInstall
'';
doInstallCheck = true;
installCheckPhase = ''
$out/bin/wasm-opt --version
MIMALLOC_VERBOSE=1 $out/bin/wasm-opt --version
'';
strictDeps = true;
}
{ autoPatchelfHook, gmp, stdenvNoCC, zlib, }:
{ fetchurl
, fixDarwinDylibNames
, gmp
, hostPlatform
, lib
, stdenvNoCC
,
}:
let
src = builtins.fetchurl
((builtins.fromJSON (builtins.readFile ../autogen.json)).cabal);
src = fetchurl ((builtins.fromJSON (builtins.readFile ../autogen.json))."${key}");
key =
{
x86_64-linux = "cabal";
aarch64-linux = "cabal_aarch64_linux";
aarch64-darwin = "cabal_aarch64_darwin";
x86_64-darwin = "cabal_x86_64_darwin";
}."${hostPlatform.system}";
in
stdenvNoCC.mkDerivation {
name = "cabal";
dontUnpack = true;
buildInputs = [ gmp zlib ];
nativeBuildInputs = [ autoPatchelfHook ];
nativeBuildInputs =
lib.optionals hostPlatform.isDarwin [ fixDarwinDylibNames ];
buildInputs = [ gmp ];
installPhase = ''
runHook preInstall
mkdir -p $out/bin
tar xJf ${src} -C $out/bin 'cabal'
tar xJf ${src} -C $out/bin cabal
runHook postInstall
'';
doInstallCheck = true;
installCheckPhase = ''
......
{ autoPatchelfHook, stdenvNoCC, }:
let
src = builtins.fetchTarball
((builtins.fromJSON (builtins.readFile ../autogen.json)).deno);
in
stdenvNoCC.mkDerivation {
name = "deno";
dontUnpack = true;
nativeBuildInputs = [ autoPatchelfHook ];
installPhase = ''
mkdir -p $out/bin
install -Dm755 ${src} $out/bin/deno
'';
doInstallCheck = true;
installCheckPhase = ''
$out/bin/deno --version
'';
strictDeps = true;
}
{ buildNpmPackage
, lib
, nodejs
,
}:
buildNpmPackage {
name = "ghc-wasm-npm-deps";
inherit nodejs;
src = lib.sourceFilesBySuffices ../. [
"package.json"
"package-lock.json"
];
npmDepsHash = "sha512-Te3X3qz5PXLYbXVjT+Z1mUY0STHLJSYTCSsFjR3KcMDG8zBMzB151njqsm/na9449rrGTSpYtdoy/DCfiTHqIw==";
dontNpmBuild = true;
dontNpmInstall = true;
installPhase = ''
runHook preInstall
cp -R node_modules $out
runHook postInstall
'';
strictDeps = true;
}