merge nvim-rewrite into deck

.direnv/bin/nix-direnv-reload

···
+#!/usr/bin/env bash
+dir="$(realpath $(dirname ${BASH_SOURCE[0]})/../..)"
+_nix_direnv_force_reload=1 direnv exec "$dir" true
+direnv reload
+# direnv reload updates the mtime of .envrc. Also update the timestamp of the
+# profile_rc file to keep track that we actually are up to date.
+touch $dir/.direnv/{nix,flake}-profile-*.rc
+

.direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa.rc

···
+unset shellHook
+PATH=${PATH:-}
+nix_saved_PATH="$PATH"
+XDG_DATA_DIRS=${XDG_DATA_DIRS:-}
+nix_saved_XDG_DATA_DIRS="$XDG_DATA_DIRS"
+AR='ar'
+export AR
+AS='as'
+export AS
+BASH='/nix/store/7dpxg7ki7g8ynkdwcqf493p2x8divb4i-bash-5.2-p15/bin/bash'
+CC='gcc'
+export CC
+CONFIG_SHELL='/nix/store/7dpxg7ki7g8ynkdwcqf493p2x8divb4i-bash-5.2-p15/bin/bash'
+export CONFIG_SHELL
+CXX='g++'
+export CXX
+HOSTTYPE='x86_64'
+HOST_PATH='/nix/store/m38gwq0w8w7qyjn9s00balyp7cv3m5p9-coreutils-9.3/bin:/nix/store/01znf87kiw5xx1dj0f7djrnrbg84ij28-findutils-4.9.0/bin:/nix/store/vq4vmndw555m7ld2bi6pq8kr348qvb6a-diffutils-3.10/bin:/nix/store/rwa7qyds01qzxvq7zq3kgnkrzzpw4s66-gnused-4.9/bin:/nix/store/n062zcsmfl9gfp6vfkcg0asb8jjwmy5i-gnugrep-3.11/bin:/nix/store/4v7m4yx07b3anmbznfhihjc8xiizyna9-gawk-5.2.2/bin:/nix/store/mi3pm67ps7c7k11aqki9182ygzg8j503-gnutar-1.35/bin:/nix/store/5c0ancqnpi0cf1h49mv13w68a950s9z0-gzip-1.13/bin:/nix/store/q5cv7r1sh3s4niyq7vm6h1j74394naxs-bzip2-1.0.8-bin/bin:/nix/store/bh7sbl99ygfvw9w96936nrhw46jmcmqq-gnumake-4.4.1/bin:/nix/store/7dpxg7ki7g8ynkdwcqf493p2x8divb4i-bash-5.2-p15/bin:/nix/store/mbh9gx43gsc5av019vsdkazbyiic3f0f-patch-2.7.6/bin:/nix/store/3q6fnwcm677l1q60vkhcf9m1gxhv83jm-xz-5.4.4-bin/bin:/nix/store/a5s2dmba16pw8l52f496gw0b7nli7mbn-file-5.45/bin'
+export HOST_PATH
+IFS=' 	
+'
+IN_NIX_SHELL='impure'
+export IN_NIX_SHELL
+LD='ld'
+export LD
+LINENO='76'
+MACHTYPE='x86_64-pc-linux-gnu'
+NIX_BINTOOLS='/nix/store/qcg3rpl1l103zb1xfsw40wm9j5hzrp7y-binutils-wrapper-2.40'
+export NIX_BINTOOLS
+NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu='1'
+export NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu
+NIX_BUILD_CORES='4'
+export NIX_BUILD_CORES
+NIX_CC='/nix/store/vylmp73qymnv4siaqn1kl2hghj07hrj8-gcc-wrapper-12.3.0'
+export NIX_CC
+NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu='1'
+export NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu
+NIX_CFLAGS_COMPILE=' -frandom-seed=q6hnwi6rdy -isystem /nix/store/hsv5438lvzq106llix5xi0f7cdvqk95q-nix-2.18.1-dev/include -isystem /nix/store/gdz3j02p6mfzmxs9zsssszwpppigb70g-boehm-gc-8.2.2-dev/include -isystem /nix/store/d7jspi1ws93ya34zriyrdxz5v5z6lijj-nlohmann_json-3.11.2/include -isystem /nix/store/hsv5438lvzq106llix5xi0f7cdvqk95q-nix-2.18.1-dev/include -isystem /nix/store/gdz3j02p6mfzmxs9zsssszwpppigb70g-boehm-gc-8.2.2-dev/include -isystem /nix/store/d7jspi1ws93ya34zriyrdxz5v5z6lijj-nlohmann_json-3.11.2/include'
+export NIX_CFLAGS_COMPILE
+NIX_CONFIG='experimental-features = nix-command flakes'
+export NIX_CONFIG
+NIX_ENFORCE_NO_NATIVE='1'
+export NIX_ENFORCE_NO_NATIVE
+NIX_HARDENING_ENABLE='fortify fortify3 stackprotector pic strictoverflow format relro bindnow'
+export NIX_HARDENING_ENABLE
+NIX_LDFLAGS='-rpath /home/anish/usr/helm/outputs/out/lib  -L/nix/store/gfmmah5rc4vl8mhli495lh5savq842p0-boehm-gc-8.2.2/lib -L/nix/store/j7nl2pj606d8ld5818hw3z3fbz00sdc5-nix-2.18.1/lib -L/nix/store/gfmmah5rc4vl8mhli495lh5savq842p0-boehm-gc-8.2.2/lib -L/nix/store/j7nl2pj606d8ld5818hw3z3fbz00sdc5-nix-2.18.1/lib'
+export NIX_LDFLAGS
+NIX_NO_SELF_RPATH='1'
+NIX_STORE='/nix/store'
+export NIX_STORE
+NM='nm'
+export NM
+OBJCOPY='objcopy'
+export OBJCOPY
+OBJDUMP='objdump'
+export OBJDUMP
+OLDPWD=''
+export OLDPWD
+OPTERR='1'
+OSTYPE='linux-gnu'
+PATH='/nix/store/j7nl2pj606d8ld5818hw3z3fbz00sdc5-nix-2.18.1/bin:/nix/store/p3s38kgwd16d2dimspckp5f1rri43mnq-home-manager-unstable-2023-12-31/bin:/nix/store/pz4jng8kb4iv9x67r730las2mdkv8s8q-git-2.42.0/bin:/nix/store/p8p72q6anyf0whaf9i75jynzk2z4ml36-agenix-0.13.0/bin:/nix/store/lfx4in7iqbbx5b6b85cndw268ria5512-deploy-rs-unstable-2023-12-20/bin:/nix/store/8nwmr2kmkrl1mnggka7fjibcglk68rc0-dnscontrol-4.6.0/bin:/nix/store/h3ayxf5dk1gdf3s5716fh1ys815qxxag-patchelf-0.15.0/bin:/nix/store/vylmp73qymnv4siaqn1kl2hghj07hrj8-gcc-wrapper-12.3.0/bin:/nix/store/f94yr35af3xdiscbj6cp6kafvmn55gv9-gcc-12.3.0/bin:/nix/store/vksrk76p5cfbjxb0n95vdkxy7fl2cbcm-glibc-2.38-27-bin/bin:/nix/store/m38gwq0w8w7qyjn9s00balyp7cv3m5p9-coreutils-9.3/bin:/nix/store/qcg3rpl1l103zb1xfsw40wm9j5hzrp7y-binutils-wrapper-2.40/bin:/nix/store/idiaraknw071d20nlqp49s18gbvw4wa0-binutils-2.40/bin:/nix/store/m38gwq0w8w7qyjn9s00balyp7cv3m5p9-coreutils-9.3/bin:/nix/store/01znf87kiw5xx1dj0f7djrnrbg84ij28-findutils-4.9.0/bin:/nix/store/vq4vmndw555m7ld2bi6pq8kr348qvb6a-diffutils-3.10/bin:/nix/store/rwa7qyds01qzxvq7zq3kgnkrzzpw4s66-gnused-4.9/bin:/nix/store/n062zcsmfl9gfp6vfkcg0asb8jjwmy5i-gnugrep-3.11/bin:/nix/store/4v7m4yx07b3anmbznfhihjc8xiizyna9-gawk-5.2.2/bin:/nix/store/mi3pm67ps7c7k11aqki9182ygzg8j503-gnutar-1.35/bin:/nix/store/5c0ancqnpi0cf1h49mv13w68a950s9z0-gzip-1.13/bin:/nix/store/q5cv7r1sh3s4niyq7vm6h1j74394naxs-bzip2-1.0.8-bin/bin:/nix/store/bh7sbl99ygfvw9w96936nrhw46jmcmqq-gnumake-4.4.1/bin:/nix/store/7dpxg7ki7g8ynkdwcqf493p2x8divb4i-bash-5.2-p15/bin:/nix/store/mbh9gx43gsc5av019vsdkazbyiic3f0f-patch-2.7.6/bin:/nix/store/3q6fnwcm677l1q60vkhcf9m1gxhv83jm-xz-5.4.4-bin/bin:/nix/store/a5s2dmba16pw8l52f496gw0b7nli7mbn-file-5.45/bin'
+export PATH
+PS4='+ '
+RANLIB='ranlib'
+export RANLIB
+READELF='readelf'
+export READELF
+SIZE='size'
+export SIZE
+SOURCE_DATE_EPOCH='315532800'
+export SOURCE_DATE_EPOCH
+STRINGS='strings'
+export STRINGS
+STRIP='strip'
+export STRIP
+XDG_DATA_DIRS='/nix/store/gfmmah5rc4vl8mhli495lh5savq842p0-boehm-gc-8.2.2/share:/nix/store/d7jspi1ws93ya34zriyrdxz5v5z6lijj-nlohmann_json-3.11.2/share:/nix/store/j7nl2pj606d8ld5818hw3z3fbz00sdc5-nix-2.18.1/share:/nix/store/p3s38kgwd16d2dimspckp5f1rri43mnq-home-manager-unstable-2023-12-31/share:/nix/store/pz4jng8kb4iv9x67r730las2mdkv8s8q-git-2.42.0/share:/nix/store/h3ayxf5dk1gdf3s5716fh1ys815qxxag-patchelf-0.15.0/share'
+export XDG_DATA_DIRS
+__structuredAttrs=''
+export __structuredAttrs
+buildInputs=''
+export buildInputs
+buildPhase='{ echo "------------------------------------------------------------";
+  echo " WARNING: the existence of this path is not guaranteed.";
+  echo " It is an internal implementation detail for pkgs.mkShell.";
+  echo "------------------------------------------------------------";
+  echo;
+  # Record all build inputs as runtime dependencies
+  export;
+} >> "$out"
+'
+export buildPhase
+builder='/nix/store/7dpxg7ki7g8ynkdwcqf493p2x8divb4i-bash-5.2-p15/bin/bash'
+export builder
+cmakeFlags=''
+export cmakeFlags
+configureFlags=''
+export configureFlags
+defaultBuildInputs=''
+defaultNativeBuildInputs='/nix/store/h3ayxf5dk1gdf3s5716fh1ys815qxxag-patchelf-0.15.0 /nix/store/v5qyd49a256y44pz75qnsp9741mg336k-update-autotools-gnu-config-scripts-hook /nix/store/h9lc1dpi14z7is86ffhl3ld569138595-audit-tmpdir.sh /nix/store/m54bmrhj6fqz8nds5zcj97w9s9bckc9v-compress-man-pages.sh /nix/store/wgrbkkaldkrlrni33ccvm3b6vbxzb656-make-symlinks-relative.sh /nix/store/5yzw0vhkyszf2d179m0qfkgxmp5wjjx4-move-docs.sh /nix/store/fyaryjvghbkpfnsyw97hb3lyb37s1pd6-move-lib64.sh /nix/store/kd4xwxjpjxi71jkm6ka0np72if9rm3y0-move-sbin.sh /nix/store/pag6l61paj1dc9sv15l7bm5c17xn5kyk-move-systemd-user-units.sh /nix/store/jivxp510zxakaaic7qkrb7v1dd2rdbw9-multiple-outputs.sh /nix/store/wzdsbnv2ba3nj91aql8jjdddfmkkdh7h-patch-shebangs.sh /nix/store/cickvswrvann041nqxb0rxilc46svw1n-prune-libtool-files.sh /nix/store/xyff06pkhki3qy1ls77w10s0v79c9il0-reproducible-builds.sh /nix/store/ngg1cv31c8c7bcm2n8ww4g06nq7s4zhm-set-source-date-epoch-to-latest.sh /nix/store/wmknncrif06fqxa16hpdldhixk95nds0-strip.sh /nix/store/vylmp73qymnv4siaqn1kl2hghj07hrj8-gcc-wrapper-12.3.0'
+depsBuildBuild=''
+export depsBuildBuild
+depsBuildBuildPropagated=''
+export depsBuildBuildPropagated
+depsBuildTarget=''
+export depsBuildTarget
+depsBuildTargetPropagated=''
+export depsBuildTargetPropagated
+depsHostHost=''
+export depsHostHost
+depsHostHostPropagated=''
+export depsHostHostPropagated
+depsTargetTarget=''
+export depsTargetTarget
+depsTargetTargetPropagated=''
+export depsTargetTargetPropagated
+doCheck=''
+export doCheck
+doInstallCheck=''
+export doInstallCheck
+dontAddDisableDepTrack='1'
+export dontAddDisableDepTrack
+declare -a envBuildBuildHooks=()
+declare -a envBuildHostHooks=()
+declare -a envBuildTargetHooks=()
+declare -a envHostHostHooks=('ccWrapper_addCVars' 'bintoolsWrapper_addLDVars' )
+declare -a envHostTargetHooks=('ccWrapper_addCVars' 'bintoolsWrapper_addLDVars' )
+declare -a envTargetTargetHooks=()
+declare -a fixupOutputHooks=('if [ -z "${dontPatchELF-}" ]; then patchELF "$prefix"; fi' 'if [[ -z "${noAuditTmpdir-}" && -e "$prefix" ]]; then auditTmpdir "$prefix"; fi' 'if [ -z "${dontGzipMan-}" ]; then compressManPages "$prefix"; fi' '_moveLib64' '_moveSbin' '_moveSystemdUserUnits' 'patchShebangsAuto' '_pruneLibtoolFiles' '_doStrip' )
+guess='4'
+initialPath='/nix/store/m38gwq0w8w7qyjn9s00balyp7cv3m5p9-coreutils-9.3 /nix/store/01znf87kiw5xx1dj0f7djrnrbg84ij28-findutils-4.9.0 /nix/store/vq4vmndw555m7ld2bi6pq8kr348qvb6a-diffutils-3.10 /nix/store/rwa7qyds01qzxvq7zq3kgnkrzzpw4s66-gnused-4.9 /nix/store/n062zcsmfl9gfp6vfkcg0asb8jjwmy5i-gnugrep-3.11 /nix/store/4v7m4yx07b3anmbznfhihjc8xiizyna9-gawk-5.2.2 /nix/store/mi3pm67ps7c7k11aqki9182ygzg8j503-gnutar-1.35 /nix/store/5c0ancqnpi0cf1h49mv13w68a950s9z0-gzip-1.13 /nix/store/q5cv7r1sh3s4niyq7vm6h1j74394naxs-bzip2-1.0.8-bin /nix/store/bh7sbl99ygfvw9w96936nrhw46jmcmqq-gnumake-4.4.1 /nix/store/7dpxg7ki7g8ynkdwcqf493p2x8divb4i-bash-5.2-p15 /nix/store/mbh9gx43gsc5av019vsdkazbyiic3f0f-patch-2.7.6 /nix/store/3q6fnwcm677l1q60vkhcf9m1gxhv83jm-xz-5.4.4-bin /nix/store/a5s2dmba16pw8l52f496gw0b7nli7mbn-file-5.45'
+mesonFlags=''
+export mesonFlags
+name='nix-shell-env'
+export name
+nativeBuildInputs='/nix/store/hsv5438lvzq106llix5xi0f7cdvqk95q-nix-2.18.1-dev /nix/store/p3s38kgwd16d2dimspckp5f1rri43mnq-home-manager-unstable-2023-12-31 /nix/store/pz4jng8kb4iv9x67r730las2mdkv8s8q-git-2.42.0 /nix/store/p8p72q6anyf0whaf9i75jynzk2z4ml36-agenix-0.13.0 /nix/store/lfx4in7iqbbx5b6b85cndw268ria5512-deploy-rs-unstable-2023-12-20 /nix/store/8nwmr2kmkrl1mnggka7fjibcglk68rc0-dnscontrol-4.6.0'
+export nativeBuildInputs
+out='/home/anish/usr/helm/outputs/out'
+export out
+outputBin='out'
+outputDev='out'
+outputDevdoc='REMOVE'
+outputDevman='out'
+outputDoc='out'
+outputInclude='out'
+outputInfo='out'
+outputLib='out'
+outputMan='out'
+outputs='out'
+export outputs
+patches=''
+export patches
+phases='buildPhase'
+export phases
+pkg='/nix/store/vylmp73qymnv4siaqn1kl2hghj07hrj8-gcc-wrapper-12.3.0'
+declare -a pkgsBuildBuild=()
+declare -a pkgsBuildHost=('/nix/store/hsv5438lvzq106llix5xi0f7cdvqk95q-nix-2.18.1-dev' '/nix/store/gdz3j02p6mfzmxs9zsssszwpppigb70g-boehm-gc-8.2.2-dev' '/nix/store/gfmmah5rc4vl8mhli495lh5savq842p0-boehm-gc-8.2.2' '/nix/store/d7jspi1ws93ya34zriyrdxz5v5z6lijj-nlohmann_json-3.11.2' '/nix/store/j7nl2pj606d8ld5818hw3z3fbz00sdc5-nix-2.18.1' '/nix/store/p3s38kgwd16d2dimspckp5f1rri43mnq-home-manager-unstable-2023-12-31' '/nix/store/pz4jng8kb4iv9x67r730las2mdkv8s8q-git-2.42.0' '/nix/store/p8p72q6anyf0whaf9i75jynzk2z4ml36-agenix-0.13.0' '/nix/store/lfx4in7iqbbx5b6b85cndw268ria5512-deploy-rs-unstable-2023-12-20' '/nix/store/8nwmr2kmkrl1mnggka7fjibcglk68rc0-dnscontrol-4.6.0' '/nix/store/h3ayxf5dk1gdf3s5716fh1ys815qxxag-patchelf-0.15.0' '/nix/store/v5qyd49a256y44pz75qnsp9741mg336k-update-autotools-gnu-config-scripts-hook' '/nix/store/h9lc1dpi14z7is86ffhl3ld569138595-audit-tmpdir.sh' '/nix/store/m54bmrhj6fqz8nds5zcj97w9s9bckc9v-compress-man-pages.sh' '/nix/store/wgrbkkaldkrlrni33ccvm3b6vbxzb656-make-symlinks-relative.sh' '/nix/store/5yzw0vhkyszf2d179m0qfkgxmp5wjjx4-move-docs.sh' '/nix/store/fyaryjvghbkpfnsyw97hb3lyb37s1pd6-move-lib64.sh' '/nix/store/kd4xwxjpjxi71jkm6ka0np72if9rm3y0-move-sbin.sh' '/nix/store/pag6l61paj1dc9sv15l7bm5c17xn5kyk-move-systemd-user-units.sh' '/nix/store/jivxp510zxakaaic7qkrb7v1dd2rdbw9-multiple-outputs.sh' '/nix/store/wzdsbnv2ba3nj91aql8jjdddfmkkdh7h-patch-shebangs.sh' '/nix/store/cickvswrvann041nqxb0rxilc46svw1n-prune-libtool-files.sh' '/nix/store/xyff06pkhki3qy1ls77w10s0v79c9il0-reproducible-builds.sh' '/nix/store/ngg1cv31c8c7bcm2n8ww4g06nq7s4zhm-set-source-date-epoch-to-latest.sh' '/nix/store/wmknncrif06fqxa16hpdldhixk95nds0-strip.sh' '/nix/store/vylmp73qymnv4siaqn1kl2hghj07hrj8-gcc-wrapper-12.3.0' '/nix/store/qcg3rpl1l103zb1xfsw40wm9j5hzrp7y-binutils-wrapper-2.40' )
+declare -a pkgsBuildTarget=()
+declare -a pkgsHostHost=()
+declare -a pkgsHostTarget=()
+declare -a pkgsTargetTarget=()
+declare -a postFixupHooks=('_makeSymlinksRelativeInAllOutputs' '_multioutPropagateDev' )
+declare -a postUnpackHooks=('_updateSourceDateEpochFromSourceRoot' )
+declare -a preConfigureHooks=('_multioutConfig' )
+preConfigurePhases=' updateAutotoolsGnuConfigScriptsPhase'
+declare -a preFixupHooks=('_moveToShare' '_multioutDocs' '_multioutDevs' )
+preferLocalBuild='1'
+export preferLocalBuild
+prefix='/home/anish/usr/helm/outputs/out'
+declare -a propagatedBuildDepFiles=('propagated-build-build-deps' 'propagated-native-build-inputs' 'propagated-build-target-deps' )
+propagatedBuildInputs=''
+export propagatedBuildInputs
+declare -a propagatedHostDepFiles=('propagated-host-host-deps' 'propagated-build-inputs' )
+propagatedNativeBuildInputs=''
+export propagatedNativeBuildInputs
+declare -a propagatedTargetDepFiles=('propagated-target-target-deps' )
+shell='/nix/store/7dpxg7ki7g8ynkdwcqf493p2x8divb4i-bash-5.2-p15/bin/bash'
+export shell
+shellHook=''
+export shellHook
+stdenv='/nix/store/kv5wkk7xgc8paw9azshzlmxraffqcg0i-stdenv-linux'
+export stdenv
+strictDeps=''
+export strictDeps
+system='x86_64-linux'
+export system
+declare -a unpackCmdHooks=('_defaultUnpack' )
+_accumFlagsArray ()
+{
+ 
+    local name;
+    if [ -n "$__structuredAttrs" ]; then
+        for name in "$@";
+        do
+            local -n nameref="$name";
+            flagsArray+=(${nameref+"${nameref[@]}"});
+        done;
+    else
+        for name in "$@";
+        do
+            local -n nameref="$name";
+            case "$name" in 
+                *Array)
+                    flagsArray+=(${nameref+"${nameref[@]}"})
+                ;;
+                *)
+                    flagsArray+=(${nameref-})
+                ;;
+            esac;
+        done;
+    fi
+}
+_activatePkgs ()
+{
+ 
+    local hostOffset targetOffset;
+    local pkg;
+    for hostOffset in "${allPlatOffsets[@]}";
+    do
+        local pkgsVar="${pkgAccumVarVars[hostOffset + 1]}";
+        for targetOffset in "${allPlatOffsets[@]}";
+        do
+            (( hostOffset <= targetOffset )) || continue;
+            local pkgsRef="${pkgsVar}[$targetOffset - $hostOffset]";
+            local pkgsSlice="${!pkgsRef}[@]";
+            for pkg in ${!pkgsSlice+"${!pkgsSlice}"};
+            do
+                activatePackage "$pkg" "$hostOffset" "$targetOffset";
+            done;
+        done;
+    done
+}
+_addRpathPrefix ()
+{
+ 
+    if [ "${NIX_NO_SELF_RPATH:-0}" != 1 ]; then
+        export NIX_LDFLAGS="-rpath $1/lib ${NIX_LDFLAGS-}";
+    fi
+}
+_addToEnv ()
+{
+ 
+    local depHostOffset depTargetOffset;
+    local pkg;
+    for depHostOffset in "${allPlatOffsets[@]}";
+    do
+        local hookVar="${pkgHookVarVars[depHostOffset + 1]}";
+        local pkgsVar="${pkgAccumVarVars[depHostOffset + 1]}";
+        for depTargetOffset in "${allPlatOffsets[@]}";
+        do
+            (( depHostOffset <= depTargetOffset )) || continue;
+            local hookRef="${hookVar}[$depTargetOffset - $depHostOffset]";
+            if [[ -z "${strictDeps-}" ]]; then
+                local visitedPkgs="";
+                for pkg in "${pkgsBuildBuild[@]}" "${pkgsBuildHost[@]}" "${pkgsBuildTarget[@]}" "${pkgsHostHost[@]}" "${pkgsHostTarget[@]}" "${pkgsTargetTarget[@]}";
+                do
+                    if [[ "$visitedPkgs" = *"$pkg"* ]]; then
+                        continue;
+                    fi;
+                    runHook "${!hookRef}" "$pkg";
+                    visitedPkgs+=" $pkg";
+                done;
+            else
+                local pkgsRef="${pkgsVar}[$depTargetOffset - $depHostOffset]";
+                local pkgsSlice="${!pkgsRef}[@]";
+                for pkg in ${!pkgsSlice+"${!pkgsSlice}"};
+                do
+                    runHook "${!hookRef}" "$pkg";
+                done;
+            fi;
+        done;
+    done
+}
+_allFlags ()
+{
+ 
+    export system pname name version;
+    for varName in $(awk 'BEGIN { for (v in ENVIRON) if (v ~ /^[a-z][a-zA-Z0-9_]*$/) print v }');
+    do
+        if (( "${NIX_DEBUG:-0}" >= 1 )); then
+            printf "@%s@ -> %q\n" "${varName}" "${!varName}" 1>&2;
+        fi;
+        args+=("--subst-var" "$varName");
+    done
+}
+_assignFirst ()
+{
+ 
+    local varName="$1";
+    local _var;
+    local REMOVE=REMOVE;
+    shift;
+    for _var in "$@";
+    do
+        if [ -n "${!_var-}" ]; then
+            eval "${varName}"="${_var}";
+            return;
+        fi;
+    done;
+    echo;
+    echo "error: _assignFirst: could not find a non-empty variable whose name to assign to ${varName}.";
+    echo "       The following variables were all unset or empty:";
+    echo "           $*";
+    if [ -z "${out:-}" ]; then
+        echo '       If you do not want an "out" output in your derivation, make sure to define';
+        echo '       the other specific required outputs. This can be achieved by picking one';
+        echo "       of the above as an output.";
+        echo '       You do not have to remove "out" if you want to have a different default';
+        echo '       output, because the first output is taken as a default.';
+        echo;
+    fi;
+    return 1
+}
+_callImplicitHook ()
+{
+ 
+    local def="$1";
+    local hookName="$2";
+    if declare -F "$hookName" > /dev/null; then
+        "$hookName";
+    else
+        if type -p "$hookName" > /dev/null; then
+            source "$hookName";
+        else
+            if [ -n "${!hookName:-}" ]; then
+                eval "${!hookName}";
+            else
+                return "$def";
+            fi;
+        fi;
+    fi
+}
+_defaultUnpack ()
+{
+ 
+    local fn="$1";
+    local destination;
+    if [ -d "$fn" ]; then
+        destination="$(stripHash "$fn")";
+        if [ -e "$destination" ]; then
+            echo "Cannot copy $fn to $destination: destination already exists!";
+            echo "Did you specify two \"srcs\" with the same \"name\"?";
+            return 1;
+        fi;
+        cp -pr --reflink=auto -- "$fn" "$destination";
+    else
+        case "$fn" in 
+            *.tar.xz | *.tar.lzma | *.txz)
+                xz -d < "$fn" | tar xf - --warning=no-timestamp
+            ;;
+            *.tar | *.tar.* | *.tgz | *.tbz2 | *.tbz)
+                tar xf "$fn" --warning=no-timestamp
+            ;;
+            *)
+                return 1
+            ;;
+        esac;
+    fi
+}
+_doStrip ()
+{
+ 
+    local -ra flags=(dontStripHost dontStripTarget);
+    local -ra debugDirs=(stripDebugList stripDebugListTarget);
+    local -ra allDirs=(stripAllList stripAllListTarget);
+    local -ra stripCmds=(STRIP STRIP_FOR_TARGET);
+    local -ra ranlibCmds=(RANLIB RANLIB_FOR_TARGET);
+    stripDebugList=${stripDebugList[*]:-lib lib32 lib64 libexec bin sbin};
+    stripDebugListTarget=${stripDebugListTarget[*]:-};
+    stripAllList=${stripAllList[*]:-};
+    stripAllListTarget=${stripAllListTarget[*]:-};
+    local i;
+    for i in ${!stripCmds[@]};
+    do
+        local -n flag="${flags[$i]}";
+        local -n debugDirList="${debugDirs[$i]}";
+        local -n allDirList="${allDirs[$i]}";
+        local -n stripCmd="${stripCmds[$i]}";
+        local -n ranlibCmd="${ranlibCmds[$i]}";
+        if [[ -n "${dontStrip-}" || -n "${flag-}" ]] || ! type -f "${stripCmd-}" 2> /dev/null 1>&2; then
+            continue;
+        fi;
+        stripDirs "$stripCmd" "$ranlibCmd" "$debugDirList" "${stripDebugFlags[*]:--S -p}";
+        stripDirs "$stripCmd" "$ranlibCmd" "$allDirList" "${stripAllFlags[*]:--s -p}";
+    done
+}
+_eval ()
+{
+ 
+    if declare -F "$1" > /dev/null 2>&1; then
+        "$@";
+    else
+        eval "$1";
+    fi
+}
+_makeSymlinksRelative ()
+{
+ 
+    local symlinkTarget;
+    if [ "${dontRewriteSymlinks-}" ] || [ ! -e "$prefix" ]; then
+        return;
+    fi;
+    while IFS= read -r -d '' f; do
+        symlinkTarget=$(readlink "$f");
+        if [[ "$symlinkTarget"/ != "$prefix"/* ]]; then
+            continue;
+        fi;
+        if [ ! -e "$symlinkTarget" ]; then
+            echo "the symlink $f is broken, it points to $symlinkTarget (which is missing)";
+        fi;
+        echo "rewriting symlink $f to be relative to $prefix";
+        ln -snrf "$symlinkTarget" "$f";
+    done < <(find $prefix -type l -print0)
+}
+_makeSymlinksRelativeInAllOutputs ()
+{
+ 
+    local output;
+    for output in $(getAllOutputNames);
+    do
+        prefix="${!output}" _makeSymlinksRelative;
+    done
+}
+_moveLib64 ()
+{
+ 
+    if [ "${dontMoveLib64-}" = 1 ]; then
+        return;
+    fi;
+    if [ ! -e "$prefix/lib64" -o -L "$prefix/lib64" ]; then
+        return;
+    fi;
+    echo "moving $prefix/lib64/* to $prefix/lib";
+    mkdir -p $prefix/lib;
+    shopt -s dotglob;
+    for i in $prefix/lib64/*;
+    do
+        mv --no-clobber "$i" $prefix/lib;
+    done;
+    shopt -u dotglob;
+    rmdir $prefix/lib64;
+    ln -s lib $prefix/lib64
+}
+_moveSbin ()
+{
+ 
+    if [ "${dontMoveSbin-}" = 1 ]; then
+        return;
+    fi;
+    if [ ! -e "$prefix/sbin" -o -L "$prefix/sbin" ]; then
+        return;
+    fi;
+    echo "moving $prefix/sbin/* to $prefix/bin";
+    mkdir -p $prefix/bin;
+    shopt -s dotglob;
+    for i in $prefix/sbin/*;
+    do
+        mv "$i" $prefix/bin;
+    done;
+    shopt -u dotglob;
+    rmdir $prefix/sbin;
+    ln -s bin $prefix/sbin
+}
+_moveSystemdUserUnits ()
+{
+ 
+    if [ "${dontMoveSystemdUserUnits:-0}" = 1 ]; then
+        return;
+    fi;
+    if [ ! -e "${prefix:?}/lib/systemd/user" ]; then
+        return;
+    fi;
+    local source="$prefix/lib/systemd/user";
+    local target="$prefix/share/systemd/user";
+    echo "moving $source/* to $target";
+    mkdir -p "$target";
+    ( shopt -s dotglob;
+    for i in "$source"/*;
+    do
+        mv "$i" "$target";
+    done );
+    rmdir "$source";
+    ln -s "$target" "$source"
+}
+_moveToShare ()
+{
+ 
+    if [ -n "$__structuredAttrs" ]; then
+        if [ -z "${forceShare-}" ]; then
+            forceShare=(man doc info);
+        fi;
+    else
+        forceShare=(${forceShare:-man doc info});
+    fi;
+    if [[ -z "$out" ]]; then
+        return;
+    fi;
+    for d in "${forceShare[@]}";
+    do
+        if [ -d "$out/$d" ]; then
+            if [ -d "$out/share/$d" ]; then
+                echo "both $d/ and share/$d/ exist!";
+            else
+                echo "moving $out/$d to $out/share/$d";
+                mkdir -p $out/share;
+                mv $out/$d $out/share/;
+            fi;
+        fi;
+    done
+}
+_multioutConfig ()
+{
+ 
+    if [ "$(getAllOutputNames)" = "out" ] || [ -z "${setOutputFlags-1}" ]; then
+        return;
+    fi;
+    if [ -z "${shareDocName:-}" ]; then
+        local confScript="${configureScript:-}";
+        if [ -z "$confScript" ] && [ -x ./configure ]; then
+            confScript=./configure;
+        fi;
+        if [ -f "$confScript" ]; then
+            local shareDocName="$(sed -n "s/^PACKAGE_TARNAME='\(.*\)'$/\1/p" < "$confScript")";
+        fi;
+        if [ -z "$shareDocName" ] || echo "$shareDocName" | grep -q '[^a-zA-Z0-9_-]'; then
+            shareDocName="$(echo "$name" | sed 's/-[^a-zA-Z].*//')";
+        fi;
+    fi;
+    prependToVar configureFlags --bindir="${!outputBin}"/bin --sbindir="${!outputBin}"/sbin --includedir="${!outputInclude}"/include --oldincludedir="${!outputInclude}"/include --mandir="${!outputMan}"/share/man --infodir="${!outputInfo}"/share/info --docdir="${!outputDoc}"/share/doc/"${shareDocName}" --libdir="${!outputLib}"/lib --libexecdir="${!outputLib}"/libexec --localedir="${!outputLib}"/share/locale;
+    prependToVar installFlags pkgconfigdir="${!outputDev}"/lib/pkgconfig m4datadir="${!outputDev}"/share/aclocal aclocaldir="${!outputDev}"/share/aclocal
+}
+_multioutDevs ()
+{
+ 
+    if [ "$(getAllOutputNames)" = "out" ] || [ -z "${moveToDev-1}" ]; then
+        return;
+    fi;
+    moveToOutput include "${!outputInclude}";
+    moveToOutput lib/pkgconfig "${!outputDev}";
+    moveToOutput share/pkgconfig "${!outputDev}";
+    moveToOutput lib/cmake "${!outputDev}";
+    moveToOutput share/aclocal "${!outputDev}";
+    for f in "${!outputDev}"/{lib,share}/pkgconfig/*.pc;
+    do
+        echo "Patching '$f' includedir to output ${!outputInclude}";
+        sed -i "/^includedir=/s,=\${prefix},=${!outputInclude}," "$f";
+    done
+}
+_multioutDocs ()
+{
+ 
+    local REMOVE=REMOVE;
+    moveToOutput share/info "${!outputInfo}";
+    moveToOutput share/doc "${!outputDoc}";
+    moveToOutput share/gtk-doc "${!outputDevdoc}";
+    moveToOutput share/devhelp/books "${!outputDevdoc}";
+    moveToOutput share/man "${!outputMan}";
+    moveToOutput share/man/man3 "${!outputDevman}"
+}
+_multioutPropagateDev ()
+{
+ 
+    if [ "$(getAllOutputNames)" = "out" ]; then
+        return;
+    fi;
+    local outputFirst;
+    for outputFirst in $(getAllOutputNames);
+    do
+        break;
+    done;
+    local propagaterOutput="$outputDev";
+    if [ -z "$propagaterOutput" ]; then
+        propagaterOutput="$outputFirst";
+    fi;
+    if [ -z "${propagatedBuildOutputs+1}" ]; then
+        local po_dirty="$outputBin $outputInclude $outputLib";
+        set +o pipefail;
+        propagatedBuildOutputs=`echo "$po_dirty"             | tr -s ' ' '\n' | grep -v -F "$propagaterOutput"             | sort -u | tr '\n' ' ' `;
+        set -o pipefail;
+    fi;
+    if [ -z "$propagatedBuildOutputs" ]; then
+        return;
+    fi;
+    mkdir -p "${!propagaterOutput}"/nix-support;
+    for output in $propagatedBuildOutputs;
+    do
+        echo -n " ${!output}" >> "${!propagaterOutput}"/nix-support/propagated-build-inputs;
+    done
+}
+_overrideFirst ()
+{
+ 
+    if [ -z "${!1-}" ]; then
+        _assignFirst "$@";
+    fi
+}
+_pruneLibtoolFiles ()
+{
+ 
+    if [ "${dontPruneLibtoolFiles-}" ] || [ ! -e "$prefix" ]; then
+        return;
+    fi;
+    find "$prefix" -type f -name '*.la' -exec grep -q '^# Generated by .*libtool' {} \; -exec grep -q "^old_library=''" {} \; -exec sed -i {} -e "/^dependency_libs='[^']/ c dependency_libs='' #pruned" \;
+}
+_updateSourceDateEpochFromSourceRoot ()
+{
+ 
+    if [ -n "$sourceRoot" ]; then
+        updateSourceDateEpoch "$sourceRoot";
+    fi
+}
+activatePackage ()
+{
+ 
+    local pkg="$1";
+    local -r hostOffset="$2";
+    local -r targetOffset="$3";
+    (( hostOffset <= targetOffset )) || exit 1;
+    if [ -f "$pkg" ]; then
+        source "$pkg";
+    fi;
+    if [[ -z "${strictDeps-}" || "$hostOffset" -le -1 ]]; then
+        addToSearchPath _PATH "$pkg/bin";
+    fi;
+    if (( hostOffset <= -1 )); then
+        addToSearchPath _XDG_DATA_DIRS "$pkg/share";
+    fi;
+    if [[ "$hostOffset" -eq 0 && -d "$pkg/bin" ]]; then
+        addToSearchPath _HOST_PATH "$pkg/bin";
+    fi;
+    if [[ -f "$pkg/nix-support/setup-hook" ]]; then
+        source "$pkg/nix-support/setup-hook";
+    fi
+}
+addEnvHooks ()
+{
+ 
+    local depHostOffset="$1";
+    shift;
+    local pkgHookVarsSlice="${pkgHookVarVars[$depHostOffset + 1]}[@]";
+    local pkgHookVar;
+    for pkgHookVar in "${!pkgHookVarsSlice}";
+    do
+        eval "${pkgHookVar}s"'+=("$@")';
+    done
+}
+addToSearchPath ()
+{
+ 
+    addToSearchPathWithCustomDelimiter ":" "$@"
+}
+addToSearchPathWithCustomDelimiter ()
+{
+ 
+    local delimiter="$1";
+    local varName="$2";
+    local dir="$3";
+    if [[ -d "$dir" && "${!varName:+${delimiter}${!varName}${delimiter}}" != *"${delimiter}${dir}${delimiter}"* ]]; then
+        export "${varName}=${!varName:+${!varName}${delimiter}}${dir}";
+    fi
+}
+appendToVar ()
+{
+ 
+    local -n nameref="$1";
+    local useArray type;
+    if [ -n "$__structuredAttrs" ]; then
+        useArray=true;
+    else
+        useArray=false;
+    fi;
+    if declare -p "$1" 2> /dev/null | grep -q '^'; then
+        type="$(declare -p "$1")";
+        if [[ "$type" =~ "declare -A" ]]; then
+            echo "appendToVar(): ERROR: trying to use appendToVar on an associative array, use variable+=([\"X\"]=\"Y\") instead." 1>&2;
+            return 1;
+        else
+            if [[ "$type" =~ "declare -a" ]]; then
+                useArray=true;
+            else
+                useArray=false;
+            fi;
+        fi;
+    fi;
+    shift;
+    if $useArray; then
+        nameref=(${nameref+"${nameref[@]}"} "$@");
+    else
+        nameref="${nameref-} $*";
+    fi
+}
+auditTmpdir ()
+{
+ 
+    local dir="$1";
+    [ -e "$dir" ] || return 0;
+    echo "checking for references to $TMPDIR/ in $dir...";
+    local i;
+    find "$dir" -type f -print0 | while IFS= read -r -d '' i; do
+        if [[ "$i" =~ .build-id ]]; then
+            continue;
+        fi;
+        if isELF "$i"; then
+            if { 
+                printf :;
+                patchelf --print-rpath "$i"
+            } | grep -q -F ":$TMPDIR/"; then
+                echo "RPATH of binary $i contains a forbidden reference to $TMPDIR/";
+                exit 1;
+            fi;
+        fi;
+        if isScript "$i"; then
+            if [ -e "$(dirname "$i")/.$(basename "$i")-wrapped" ]; then
+                if grep -q -F "$TMPDIR/" "$i"; then
+                    echo "wrapper script $i contains a forbidden reference to $TMPDIR/";
+                    exit 1;
+                fi;
+            fi;
+        fi;
+    done
+}
+bintoolsWrapper_addLDVars ()
+{
+ 
+    local role_post;
+    getHostRoleEnvHook;
+    if [[ -d "$1/lib64" && ! -L "$1/lib64" ]]; then
+        export NIX_LDFLAGS${role_post}+=" -L$1/lib64";
+    fi;
+    if [[ -d "$1/lib" ]]; then
+        local -a glob=($1/lib/lib*);
+        if [ "${#glob[*]}" -gt 0 ]; then
+            export NIX_LDFLAGS${role_post}+=" -L$1/lib";
+        fi;
+    fi
+}
+buildPhase ()
+{
+ 
+    runHook preBuild;
+    if [[ -z "${makeFlags-}" && -z "${makefile:-}" && ! ( -e Makefile || -e makefile || -e GNUmakefile ) ]]; then
+        echo "no Makefile or custom buildPhase, doing nothing";
+    else
+        foundMakefile=1;
+        local flagsArray=(${enableParallelBuilding:+-j${NIX_BUILD_CORES}} SHELL=$SHELL);
+        _accumFlagsArray makeFlags makeFlagsArray buildFlags buildFlagsArray;
+        echoCmd 'build flags' "${flagsArray[@]}";
+        make ${makefile:+-f $makefile} "${flagsArray[@]}";
+        unset flagsArray;
+    fi;
+    runHook postBuild
+}
+ccWrapper_addCVars ()
+{
+ 
+    local role_post;
+    getHostRoleEnvHook;
+    if [ -d "$1/include" ]; then
+        export NIX_CFLAGS_COMPILE${role_post}+=" -isystem $1/include";
+    fi;
+    if [ -d "$1/Library/Frameworks" ]; then
+        export NIX_CFLAGS_COMPILE${role_post}+=" -iframework $1/Library/Frameworks";
+    fi
+}
+checkPhase ()
+{
+ 
+    runHook preCheck;
+    if [[ -z "${foundMakefile:-}" ]]; then
+        echo "no Makefile or custom checkPhase, doing nothing";
+        runHook postCheck;
+        return;
+    fi;
+    if [[ -z "${checkTarget:-}" ]]; then
+        if make -n ${makefile:+-f $makefile} check > /dev/null 2>&1; then
+            checkTarget=check;
+        else
+            if make -n ${makefile:+-f $makefile} test > /dev/null 2>&1; then
+                checkTarget=test;
+            fi;
+        fi;
+    fi;
+    if [[ -z "${checkTarget:-}" ]]; then
+        echo "no check/test target in ${makefile:-Makefile}, doing nothing";
+    else
+        local flagsArray=(${enableParallelChecking:+-j${NIX_BUILD_CORES}} SHELL=$SHELL);
+        _accumFlagsArray makeFlags makeFlagsArray;
+        if [ -n "$__structuredAttrs" ]; then
+            flagsArray+=("${checkFlags[@]:-VERBOSE=y}");
+        else
+            flagsArray+=(${checkFlags:-VERBOSE=y});
+        fi;
+        _accumFlagsArray checkFlagsArray;
+        flagsArray+=(${checkTarget});
+        echoCmd 'check flags' "${flagsArray[@]}";
+        make ${makefile:+-f $makefile} "${flagsArray[@]}";
+        unset flagsArray;
+    fi;
+    runHook postCheck
+}
+compressManPages ()
+{
+ 
+    local dir="$1";
+    if [ -L "$dir"/share ] || [ -L "$dir"/share/man ] || [ ! -d "$dir/share/man" ]; then
+        return;
+    fi;
+    echo "gzipping man pages under $dir/share/man/";
+    find "$dir"/share/man/ -type f -a '!' -regex '.*\.\(bz2\|gz\|xz\)$' -print0 | while IFS= read -r -d '' f; do
+        if gzip -c -n "$f" > "$f".gz; then
+            rm "$f";
+        else
+            rm "$f".gz;
+        fi;
+    done;
+    find "$dir"/share/man/ -type l -a '!' -regex '.*\.\(bz2\|gz\|xz\)$' -print0 | sort -z | while IFS= read -r -d '' f; do
+        local target;
+        target="$(readlink -f "$f")";
+        if [ -f "$target".gz ]; then
+            ln -sf "$target".gz "$f".gz && rm "$f";
+        fi;
+    done
+}
+configurePhase ()
+{
+ 
+    runHook preConfigure;
+    : "${configureScript=}";
+    if [[ -z "$configureScript" && -x ./configure ]]; then
+        configureScript=./configure;
+    fi;
+    if [ -z "${dontFixLibtool:-}" ]; then
+        export lt_cv_deplibs_check_method="${lt_cv_deplibs_check_method-pass_all}";
+        local i;
+        find . -iname "ltmain.sh" -print0 | while IFS='' read -r -d '' i; do
+            echo "fixing libtool script $i";
+            fixLibtool "$i";
+        done;
+        CONFIGURE_MTIME_REFERENCE=$(mktemp configure.mtime.reference.XXXXXX);
+        find . -executable -type f -name configure -exec grep -l 'GNU Libtool is free software; you can redistribute it and/or modify' {} \; -exec touch -r {} "$CONFIGURE_MTIME_REFERENCE" \; -exec sed -i s_/usr/bin/file_file_g {} \; -exec touch -r "$CONFIGURE_MTIME_REFERENCE" {} \;;
+        rm -f "$CONFIGURE_MTIME_REFERENCE";
+    fi;
+    if [[ -z "${dontAddPrefix:-}" && -n "$prefix" ]]; then
+        prependToVar configureFlags "${prefixKey:---prefix=}$prefix";
+    fi;
+    if [[ -f "$configureScript" ]]; then
+        if [ -z "${dontAddDisableDepTrack:-}" ]; then
+            if grep -q dependency-tracking "$configureScript"; then
+                prependToVar configureFlags --disable-dependency-tracking;
+            fi;
+        fi;
+        if [ -z "${dontDisableStatic:-}" ]; then
+            if grep -q enable-static "$configureScript"; then
+                prependToVar configureFlags --disable-static;
+            fi;
+        fi;
+    fi;
+    if [ -n "$configureScript" ]; then
+        local -a flagsArray;
+        _accumFlagsArray configureFlags configureFlagsArray;
+        echoCmd 'configure flags' "${flagsArray[@]}";
+        $configureScript "${flagsArray[@]}";
+        unset flagsArray;
+    else
+        echo "no configure script, doing nothing";
+    fi;
+    runHook postConfigure
+}
+consumeEntire ()
+{
+ 
+    if IFS='' read -r -d '' "$1"; then
+        echo "consumeEntire(): ERROR: Input null bytes, won't process" 1>&2;
+        return 1;
+    fi
+}
+distPhase ()
+{
+ 
+    runHook preDist;
+    local flagsArray=();
+    _accumFlagsArray distFlags distFlagsArray;
+    flagsArray+=(${distTarget:-dist});
+    echo 'dist flags: %q' "${flagsArray[@]}";
+    make ${makefile:+-f $makefile} "${flagsArray[@]}";
+    if [ "${dontCopyDist:-0}" != 1 ]; then
+        mkdir -p "$out/tarballs";
+        cp -pvd ${tarballs[*]:-*.tar.gz} "$out/tarballs";
+    fi;
+    runHook postDist
+}
+dumpVars ()
+{
+ 
+    if [ "${noDumpEnvVars:-0}" != 1 ]; then
+        export 2> /dev/null >| "$NIX_BUILD_TOP/env-vars" || true;
+    fi
+}
+echoCmd ()
+{
+ 
+    printf "%s:" "$1";
+    shift;
+    printf ' %q' "$@";
+    echo
+}
+exitHandler ()
+{
+ 
+    exitCode="$?";
+    set +e;
+    if [ -n "${showBuildStats:-}" ]; then
+        read -r -d '' -a buildTimes < <(times);
+        echo "build times:";
+        echo "user time for the shell             ${buildTimes[0]}";
+        echo "system time for the shell           ${buildTimes[1]}";
+        echo "user time for all child processes   ${buildTimes[2]}";
+        echo "system time for all child processes ${buildTimes[3]}";
+    fi;
+    if (( "$exitCode" != 0 )); then
+        runHook failureHook;
+        if [ -n "${succeedOnFailure:-}" ]; then
+            echo "build failed with exit code $exitCode (ignored)";
+            mkdir -p "$out/nix-support";
+            printf "%s" "$exitCode" > "$out/nix-support/failed";
+            exit 0;
+        fi;
+    else
+        runHook exitHook;
+    fi;
+    return "$exitCode"
+}
+findInputs ()
+{
+ 
+    local -r pkg="$1";
+    local -r hostOffset="$2";
+    local -r targetOffset="$3";
+    (( hostOffset <= targetOffset )) || exit 1;
+    local varVar="${pkgAccumVarVars[hostOffset + 1]}";
+    local varRef="$varVar[$((targetOffset - hostOffset))]";
+    local var="${!varRef}";
+    unset -v varVar varRef;
+    local varSlice="$var[*]";
+    case "${!varSlice-}" in 
+        *" $pkg "*)
+            return 0
+        ;;
+    esac;
+    unset -v varSlice;
+    eval "$var"'+=("$pkg")';
+    if ! [ -e "$pkg" ]; then
+        echo "build input $pkg does not exist" 1>&2;
+        exit 1;
+    fi;
+    function mapOffset () 
+    { 
+        local -r inputOffset="$1";
+        local -n outputOffset="$2";
+        if (( inputOffset <= 0 )); then
+            outputOffset=$((inputOffset + hostOffset));
+        else
+            outputOffset=$((inputOffset - 1 + targetOffset));
+        fi
+    };
+    local relHostOffset;
+    for relHostOffset in "${allPlatOffsets[@]}";
+    do
+        local files="${propagatedDepFilesVars[relHostOffset + 1]}";
+        local hostOffsetNext;
+        mapOffset "$relHostOffset" hostOffsetNext;
+        (( -1 <= hostOffsetNext && hostOffsetNext <= 1 )) || continue;
+        local relTargetOffset;
+        for relTargetOffset in "${allPlatOffsets[@]}";
+        do
+            (( "$relHostOffset" <= "$relTargetOffset" )) || continue;
+            local fileRef="${files}[$relTargetOffset - $relHostOffset]";
+            local file="${!fileRef}";
+            unset -v fileRef;
+            local targetOffsetNext;
+            mapOffset "$relTargetOffset" targetOffsetNext;
+            (( -1 <= hostOffsetNext && hostOffsetNext <= 1 )) || continue;
+            [[ -f "$pkg/nix-support/$file" ]] || continue;
+            local pkgNext;
+            read -r -d '' pkgNext < "$pkg/nix-support/$file" || true;
+            for pkgNext in $pkgNext;
+            do
+                findInputs "$pkgNext" "$hostOffsetNext" "$targetOffsetNext";
+            done;
+        done;
+    done
+}
+fixLibtool ()
+{
+ 
+    local search_path;
+    for flag in $NIX_LDFLAGS;
+    do
+        case $flag in 
+            -L*)
+                search_path+=" ${flag#-L}"
+            ;;
+        esac;
+    done;
+    sed -i "$1" -e "s^eval \(sys_lib_search_path=\).*^\1'${search_path:-}'^" -e 's^eval sys_lib_.+search_path=.*^^'
+}
+fixupPhase ()
+{
+ 
+    local output;
+    for output in $(getAllOutputNames);
+    do
+        if [ -e "${!output}" ]; then
+            chmod -R u+w "${!output}";
+        fi;
+    done;
+    runHook preFixup;
+    local output;
+    for output in $(getAllOutputNames);
+    do
+        prefix="${!output}" runHook fixupOutput;
+    done;
+    recordPropagatedDependencies;
+    if [ -n "${setupHook:-}" ]; then
+        mkdir -p "${!outputDev}/nix-support";
+        substituteAll "$setupHook" "${!outputDev}/nix-support/setup-hook";
+    fi;
+    if [ -n "${setupHooks:-}" ]; then
+        mkdir -p "${!outputDev}/nix-support";
+        local hook;
+        for hook in ${setupHooks[@]};
+        do
+            local content;
+            consumeEntire content < "$hook";
+            substituteAllStream content "file '$hook'" >> "${!outputDev}/nix-support/setup-hook";
+            unset -v content;
+        done;
+        unset -v hook;
+    fi;
+    if [ -n "${propagatedUserEnvPkgs:-}" ]; then
+        mkdir -p "${!outputBin}/nix-support";
+        printWords $propagatedUserEnvPkgs > "${!outputBin}/nix-support/propagated-user-env-packages";
+    fi;
+    runHook postFixup
+}
+genericBuild ()
+{
+ 
+    export GZIP_NO_TIMESTAMPS=1;
+    if [ -f "${buildCommandPath:-}" ]; then
+        source "$buildCommandPath";
+        return;
+    fi;
+    if [ -n "${buildCommand:-}" ]; then
+        eval "$buildCommand";
+        return;
+    fi;
+    if [ -z "${phases[*]:-}" ]; then
+        phases="${prePhases[*]:-} unpackPhase patchPhase ${preConfigurePhases[*]:-}             configurePhase ${preBuildPhases[*]:-} buildPhase checkPhase             ${preInstallPhases[*]:-} installPhase ${preFixupPhases[*]:-} fixupPhase installCheckPhase             ${preDistPhases[*]:-} distPhase ${postPhases[*]:-}";
+    fi;
+    for curPhase in ${phases[*]};
+    do
+        runPhase "$curPhase";
+    done
+}
+getAllOutputNames ()
+{
+ 
+    if [ -n "$__structuredAttrs" ]; then
+        echo "${!outputs[*]}";
+    else
+        echo "$outputs";
+    fi
+}
+getHostRole ()
+{
+ 
+    getRole "$hostOffset"
+}
+getHostRoleEnvHook ()
+{
+ 
+    getRole "$depHostOffset"
+}
+getRole ()
+{
+ 
+    case $1 in 
+        -1)
+            role_post='_FOR_BUILD'
+        ;;
+        0)
+            role_post=''
+        ;;
+        1)
+            role_post='_FOR_TARGET'
+        ;;
+        *)
+            echo "binutils-wrapper-2.40: used as improper sort of dependency" 1>&2;
+            return 1
+        ;;
+    esac
+}
+getTargetRole ()
+{
+ 
+    getRole "$targetOffset"
+}
+getTargetRoleEnvHook ()
+{
+ 
+    getRole "$depTargetOffset"
+}
+getTargetRoleWrapper ()
+{
+ 
+    case $targetOffset in 
+        -1)
+            export NIX_BINTOOLS_WRAPPER_TARGET_BUILD_x86_64_unknown_linux_gnu=1
+        ;;
+        0)
+            export NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu=1
+        ;;
+        1)
+            export NIX_BINTOOLS_WRAPPER_TARGET_TARGET_x86_64_unknown_linux_gnu=1
+        ;;
+        *)
+            echo "binutils-wrapper-2.40: used as improper sort of dependency" 1>&2;
+            return 1
+        ;;
+    esac
+}
+installCheckPhase ()
+{
+ 
+    runHook preInstallCheck;
+    if [[ -z "${foundMakefile:-}" ]]; then
+        echo "no Makefile or custom installCheckPhase, doing nothing";
+    else
+        if [[ -z "${installCheckTarget:-}" ]] && ! make -n ${makefile:+-f $makefile} "${installCheckTarget:-installcheck}" > /dev/null 2>&1; then
+            echo "no installcheck target in ${makefile:-Makefile}, doing nothing";
+        else
+            local flagsArray=(${enableParallelChecking:+-j${NIX_BUILD_CORES}} SHELL=$SHELL);
+            _accumFlagsArray makeFlags makeFlagsArray installCheckFlags installCheckFlagsArray;
+            flagsArray+=(${installCheckTarget:-installcheck});
+            echoCmd 'installcheck flags' "${flagsArray[@]}";
+            make ${makefile:+-f $makefile} "${flagsArray[@]}";
+            unset flagsArray;
+        fi;
+    fi;
+    runHook postInstallCheck
+}
+installPhase ()
+{
+ 
+    runHook preInstall;
+    if [[ -z "${makeFlags-}" && -z "${makefile:-}" && ! ( -e Makefile || -e makefile || -e GNUmakefile ) ]]; then
+        echo "no Makefile or custom installPhase, doing nothing";
+        runHook postInstall;
+        return;
+    else
+        foundMakefile=1;
+    fi;
+    if [ -n "$prefix" ]; then
+        mkdir -p "$prefix";
+    fi;
+    local flagsArray=(${enableParallelInstalling:+-j${NIX_BUILD_CORES}} SHELL=$SHELL);
+    _accumFlagsArray makeFlags makeFlagsArray installFlags installFlagsArray;
+    if [ -n "$__structuredAttrs" ]; then
+        flagsArray+=("${installTargets[@]:-install}");
+    else
+        flagsArray+=(${installTargets:-install});
+    fi;
+    echoCmd 'install flags' "${flagsArray[@]}";
+    make ${makefile:+-f $makefile} "${flagsArray[@]}";
+    unset flagsArray;
+    runHook postInstall
+}
+isELF ()
+{
+ 
+    local fn="$1";
+    local fd;
+    local magic;
+    exec {fd}< "$fn";
+    read -r -n 4 -u "$fd" magic;
+    exec {fd}>&-;
+    if [ "$magic" = 'ELF' ]; then
+        return 0;
+    else
+        return 1;
+    fi
+}
+isMachO ()
+{
+ 
+    local fn="$1";
+    local fd;
+    local magic;
+    exec {fd}< "$fn";
+    read -r -n 4 -u "$fd" magic;
+    exec {fd}>&-;
+    if [[ "$magic" = $(echo -ne "\xfe\xed\xfa\xcf") || "$magic" = $(echo -ne "\xcf\xfa\xed\xfe") ]]; then
+        return 0;
+    else
+        if [[ "$magic" = $(echo -ne "\xfe\xed\xfa\xce") || "$magic" = $(echo -ne "\xce\xfa\xed\xfe") ]]; then
+            return 0;
+        else
+            if [[ "$magic" = $(echo -ne "\xca\xfe\xba\xbe") || "$magic" = $(echo -ne "\xbe\xba\xfe\xca") ]]; then
+                return 0;
+            else
+                return 1;
+            fi;
+        fi;
+    fi
+}
+isScript ()
+{
+ 
+    local fn="$1";
+    local fd;
+    local magic;
+    exec {fd}< "$fn";
+    read -r -n 2 -u "$fd" magic;
+    exec {fd}>&-;
+    if [[ "$magic" =~ \#! ]]; then
+        return 0;
+    else
+        return 1;
+    fi
+}
+mapOffset ()
+{
+ 
+    local -r inputOffset="$1";
+    local -n outputOffset="$2";
+    if (( inputOffset <= 0 )); then
+        outputOffset=$((inputOffset + hostOffset));
+    else
+        outputOffset=$((inputOffset - 1 + targetOffset));
+    fi
+}
+moveToOutput ()
+{
+ 
+    local patt="$1";
+    local dstOut="$2";
+    local output;
+    for output in $(getAllOutputNames);
+    do
+        if [ "${!output}" = "$dstOut" ]; then
+            continue;
+        fi;
+        local srcPath;
+        for srcPath in "${!output}"/$patt;
+        do
+            if [ ! -e "$srcPath" ] && [ ! -L "$srcPath" ]; then
+                continue;
+            fi;
+            if [ "$dstOut" = REMOVE ]; then
+                echo "Removing $srcPath";
+                rm -r "$srcPath";
+            else
+                local dstPath="$dstOut${srcPath#${!output}}";
+                echo "Moving $srcPath to $dstPath";
+                if [ -d "$dstPath" ] && [ -d "$srcPath" ]; then
+                    rmdir "$srcPath" --ignore-fail-on-non-empty;
+                    if [ -d "$srcPath" ]; then
+                        mv -t "$dstPath" "$srcPath"/*;
+                        rmdir "$srcPath";
+                    fi;
+                else
+                    mkdir -p "$(readlink -m "$dstPath/..")";
+                    mv "$srcPath" "$dstPath";
+                fi;
+            fi;
+            local srcParent="$(readlink -m "$srcPath/..")";
+            if [ -n "$(find "$srcParent" -maxdepth 0 -type d -empty 2> /dev/null)" ]; then
+                echo "Removing empty $srcParent/ and (possibly) its parents";
+                rmdir -p --ignore-fail-on-non-empty "$srcParent" 2> /dev/null || true;
+            fi;
+        done;
+    done
+}
+patchELF ()
+{
+ 
+    local dir="$1";
+    [ -e "$dir" ] || return 0;
+    echo "shrinking RPATHs of ELF executables and libraries in $dir";
+    local i;
+    while IFS= read -r -d '' i; do
+        if [[ "$i" =~ .build-id ]]; then
+            continue;
+        fi;
+        if ! isELF "$i"; then
+            continue;
+        fi;
+        echo "shrinking $i";
+        patchelf --shrink-rpath "$i" || true;
+    done < <(find "$dir" -type f -print0)
+}
+patchPhase ()
+{
+ 
+    runHook prePatch;
+    local -a patchesArray;
+    if [ -n "$__structuredAttrs" ]; then
+        patchesArray=(${patches:+"${patches[@]}"});
+    else
+        patchesArray=(${patches:-});
+    fi;
+    for i in "${patchesArray[@]}";
+    do
+        echo "applying patch $i";
+        local uncompress=cat;
+        case "$i" in 
+            *.gz)
+                uncompress="gzip -d"
+            ;;
+            *.bz2)
+                uncompress="bzip2 -d"
+            ;;
+            *.xz)
+                uncompress="xz -d"
+            ;;
+            *.lzma)
+                uncompress="lzma -d"
+            ;;
+        esac;
+        local -a flagsArray;
+        if [ -n "$__structuredAttrs" ]; then
+            flagsArray=("${patchFlags[@]:--p1}");
+        else
+            flagsArray=(${patchFlags:--p1});
+        fi;
+        $uncompress < "$i" 2>&1 | patch "${flagsArray[@]}";
+    done;
+    runHook postPatch
+}
+patchShebangs ()
+{
+ 
+    local pathName;
+    local update;
+    while [[ $# -gt 0 ]]; do
+        case "$1" in 
+            --host)
+                pathName=HOST_PATH;
+                shift
+            ;;
+            --build)
+                pathName=PATH;
+                shift
+            ;;
+            --update)
+                update=true;
+                shift
+            ;;
+            --)
+                shift;
+                break
+            ;;
+            -* | --*)
+                echo "Unknown option $1 supplied to patchShebangs" 1>&2;
+                return 1
+            ;;
+            *)
+                break
+            ;;
+        esac;
+    done;
+    echo "patching script interpreter paths in $@";
+    local f;
+    local oldPath;
+    local newPath;
+    local arg0;
+    local args;
+    local oldInterpreterLine;
+    local newInterpreterLine;
+    if [[ $# -eq 0 ]]; then
+        echo "No arguments supplied to patchShebangs" 1>&2;
+        return 0;
+    fi;
+    local f;
+    while IFS= read -r -d '' f; do
+        isScript "$f" || continue;
+        read -r oldInterpreterLine < "$f";
+        read -r oldPath arg0 args <<< "${oldInterpreterLine:2}";
+        if [[ -z "${pathName:-}" ]]; then
+            if [[ -n $strictDeps && $f == "$NIX_STORE"* ]]; then
+                pathName=HOST_PATH;
+            else
+                pathName=PATH;
+            fi;
+        fi;
+        if [[ "$oldPath" == *"/bin/env" ]]; then
+            if [[ $arg0 == "-S" ]]; then
+                arg0=${args%% *};
+                args=${args#* };
+                newPath="$(PATH="${!pathName}" command -v "env" || true)";
+                args="-S $(PATH="${!pathName}" command -v "$arg0" || true) $args";
+            else
+                if [[ $arg0 == "-"* || $arg0 == *"="* ]]; then
+                    echo "$f: unsupported interpreter directive \"$oldInterpreterLine\" (set dontPatchShebangs=1 and handle shebang patching yourself)" 1>&2;
+                    exit 1;
+                else
+                    newPath="$(PATH="${!pathName}" command -v "$arg0" || true)";
+                fi;
+            fi;
+        else
+            if [[ -z $oldPath ]]; then
+                oldPath="/bin/sh";
+            fi;
+            newPath="$(PATH="${!pathName}" command -v "$(basename "$oldPath")" || true)";
+            args="$arg0 $args";
+        fi;
+        newInterpreterLine="$newPath $args";
+        newInterpreterLine=${newInterpreterLine%${newInterpreterLine##*[![:space:]]}};
+        if [[ -n "$oldPath" && ( "$update" == true || "${oldPath:0:${#NIX_STORE}}" != "$NIX_STORE" ) ]]; then
+            if [[ -n "$newPath" && "$newPath" != "$oldPath" ]]; then
+                echo "$f: interpreter directive changed from \"$oldInterpreterLine\" to \"$newInterpreterLine\"";
+                escapedInterpreterLine=${newInterpreterLine//\\/\\\\};
+                timestamp=$(stat --printf "%y" "$f");
+                sed -i -e "1 s|.*|#\!$escapedInterpreterLine|" "$f";
+                touch --date "$timestamp" "$f";
+            fi;
+        fi;
+    done < <(find "$@" -type f -perm -0100 -print0)
+}
+patchShebangsAuto ()
+{
+ 
+    if [[ -z "${dontPatchShebangs-}" && -e "$prefix" ]]; then
+        if [[ "$output" != out && "$output" = "$outputDev" ]]; then
+            patchShebangs --build "$prefix";
+        else
+            patchShebangs --host "$prefix";
+        fi;
+    fi
+}
+prependToVar ()
+{
+ 
+    local -n nameref="$1";
+    local useArray type;
+    if [ -n "$__structuredAttrs" ]; then
+        useArray=true;
+    else
+        useArray=false;
+    fi;
+    if declare -p "$1" 2> /dev/null | grep -q '^'; then
+        type="$(declare -p "$1")";
+        if [[ "$type" =~ "declare -A" ]]; then
+            echo "prependToVar(): ERROR: trying to use prependToVar on an associative array." 1>&2;
+            return 1;
+        else
+            if [[ "$type" =~ "declare -a" ]]; then
+                useArray=true;
+            else
+                useArray=false;
+            fi;
+        fi;
+    fi;
+    shift;
+    if $useArray; then
+        nameref=("$@" ${nameref+"${nameref[@]}"});
+    else
+        nameref="$* ${nameref-}";
+    fi
+}
+printLines ()
+{
+ 
+    (( "$#" > 0 )) || return 0;
+    printf '%s\n' "$@"
+}
+printWords ()
+{
+ 
+    (( "$#" > 0 )) || return 0;
+    printf '%s ' "$@"
+}
+recordPropagatedDependencies ()
+{
+ 
+    declare -ra flatVars=(depsBuildBuildPropagated propagatedNativeBuildInputs depsBuildTargetPropagated depsHostHostPropagated propagatedBuildInputs depsTargetTargetPropagated);
+    declare -ra flatFiles=("${propagatedBuildDepFiles[@]}" "${propagatedHostDepFiles[@]}" "${propagatedTargetDepFiles[@]}");
+    local propagatedInputsIndex;
+    for propagatedInputsIndex in "${!flatVars[@]}";
+    do
+        local propagatedInputsSlice="${flatVars[$propagatedInputsIndex]}[@]";
+        local propagatedInputsFile="${flatFiles[$propagatedInputsIndex]}";
+        [[ -n "${!propagatedInputsSlice}" ]] || continue;
+        mkdir -p "${!outputDev}/nix-support";
+        printWords ${!propagatedInputsSlice} > "${!outputDev}/nix-support/$propagatedInputsFile";
+    done
+}
+runHook ()
+{
+ 
+    local hookName="$1";
+    shift;
+    local hooksSlice="${hookName%Hook}Hooks[@]";
+    local hook;
+    for hook in "_callImplicitHook 0 $hookName" ${!hooksSlice+"${!hooksSlice}"};
+    do
+        _eval "$hook" "$@";
+    done;
+    return 0
+}
+runOneHook ()
+{
+ 
+    local hookName="$1";
+    shift;
+    local hooksSlice="${hookName%Hook}Hooks[@]";
+    local hook ret=1;
+    for hook in "_callImplicitHook 1 $hookName" ${!hooksSlice+"${!hooksSlice}"};
+    do
+        if _eval "$hook" "$@"; then
+            ret=0;
+            break;
+        fi;
+    done;
+    return "$ret"
+}
+runPhase ()
+{
+ 
+    local curPhase="$*";
+    if [[ "$curPhase" = unpackPhase && -n "${dontUnpack:-}" ]]; then
+        return;
+    fi;
+    if [[ "$curPhase" = patchPhase && -n "${dontPatch:-}" ]]; then
+        return;
+    fi;
+    if [[ "$curPhase" = configurePhase && -n "${dontConfigure:-}" ]]; then
+        return;
+    fi;
+    if [[ "$curPhase" = buildPhase && -n "${dontBuild:-}" ]]; then
+        return;
+    fi;
+    if [[ "$curPhase" = checkPhase && -z "${doCheck:-}" ]]; then
+        return;
+    fi;
+    if [[ "$curPhase" = installPhase && -n "${dontInstall:-}" ]]; then
+        return;
+    fi;
+    if [[ "$curPhase" = fixupPhase && -n "${dontFixup:-}" ]]; then
+        return;
+    fi;
+    if [[ "$curPhase" = installCheckPhase && -z "${doInstallCheck:-}" ]]; then
+        return;
+    fi;
+    if [[ "$curPhase" = distPhase && -z "${doDist:-}" ]]; then
+        return;
+    fi;
+    if [[ -n $NIX_LOG_FD ]]; then
+        echo "@nix { \"action\": \"setPhase\", \"phase\": \"$curPhase\" }" >&"$NIX_LOG_FD";
+    fi;
+    showPhaseHeader "$curPhase";
+    dumpVars;
+    local startTime=$(date +"%s");
+    eval "${!curPhase:-$curPhase}";
+    local endTime=$(date +"%s");
+    showPhaseFooter "$curPhase" "$startTime" "$endTime";
+    if [ "$curPhase" = unpackPhase ]; then
+        [ -n "${sourceRoot:-}" ] && chmod +x "${sourceRoot}";
+        cd "${sourceRoot:-.}";
+    fi
+}
+showPhaseFooter ()
+{
+ 
+    local phase="$1";
+    local startTime="$2";
+    local endTime="$3";
+    local delta=$(( endTime - startTime ));
+    (( delta < 30 )) && return;
+    local H=$((delta/3600));
+    local M=$((delta%3600/60));
+    local S=$((delta%60));
+    echo -n "$phase completed in ";
+    (( H > 0 )) && echo -n "$H hours ";
+    (( M > 0 )) && echo -n "$M minutes ";
+    echo "$S seconds"
+}
+showPhaseHeader ()
+{
+ 
+    local phase="$1";
+    echo "Running phase: $phase"
+}
+stripDirs ()
+{
+ 
+    local cmd="$1";
+    local ranlibCmd="$2";
+    local paths="$3";
+    local stripFlags="$4";
+    local excludeFlags=();
+    local pathsNew=;
+    [ -z "$cmd" ] && echo "stripDirs: Strip command is empty" 1>&2 && exit 1;
+    [ -z "$ranlibCmd" ] && echo "stripDirs: Ranlib command is empty" 1>&2 && exit 1;
+    local pattern;
+    if [ -n "${stripExclude:-}" ]; then
+        for pattern in "${stripExclude[@]}";
+        do
+            excludeFlags+=(-a '!' '(' -name "$pattern" -o -wholename "$prefix/$pattern" ')');
+        done;
+    fi;
+    local p;
+    for p in ${paths};
+    do
+        if [ -e "$prefix/$p" ]; then
+            pathsNew="${pathsNew} $prefix/$p";
+        fi;
+    done;
+    paths=${pathsNew};
+    if [ -n "${paths}" ]; then
+        echo "stripping (with command $cmd and flags $stripFlags) in $paths";
+        local striperr;
+        striperr="$(mktemp --tmpdir="$TMPDIR" 'striperr.XXXXXX')";
+        find $paths -type f "${excludeFlags[@]}" -a '!' -path "$prefix/lib/debug/*" -print0 | xargs -r -0 -n1 -- realpath -z | sort -u -z | xargs -r -0 -n1 -P "$NIX_BUILD_CORES" -- $cmd $stripFlags 2> "$striperr" || exit_code=$?;
+        [[ "$exit_code" = 123 || -z "$exit_code" ]] || ( cat "$striperr" 1>&2 && exit 1 );
+        rm "$striperr";
+        find $paths -name '*.a' -type f -exec $ranlibCmd '{}' \; 2> /dev/null;
+    fi
+}
+stripHash ()
+{
+ 
+    local strippedName casematchOpt=0;
+    strippedName="$(basename -- "$1")";
+    shopt -q nocasematch && casematchOpt=1;
+    shopt -u nocasematch;
+    if [[ "$strippedName" =~ ^[a-z0-9]{32}- ]]; then
+        echo "${strippedName:33}";
+    else
+        echo "$strippedName";
+    fi;
+    if (( casematchOpt )); then
+        shopt -s nocasematch;
+    fi
+}
+substitute ()
+{
+ 
+    local input="$1";
+    local output="$2";
+    shift 2;
+    if [ ! -f "$input" ]; then
+        echo "substitute(): ERROR: file '$input' does not exist" 1>&2;
+        return 1;
+    fi;
+    local content;
+    consumeEntire content < "$input";
+    if [ -e "$output" ]; then
+        chmod +w "$output";
+    fi;
+    substituteStream content "file '$input'" "$@" > "$output"
+}
+substituteAll ()
+{
+ 
+    local input="$1";
+    local output="$2";
+    local -a args=();
+    _allFlags;
+    substitute "$input" "$output" "${args[@]}"
+}
+substituteAllInPlace ()
+{
+ 
+    local fileName="$1";
+    shift;
+    substituteAll "$fileName" "$fileName" "$@"
+}
+substituteAllStream ()
+{
+ 
+    local -a args=();
+    _allFlags;
+    substituteStream "$1" "$2" "${args[@]}"
+}
+substituteInPlace ()
+{
+ 
+    local -a fileNames=();
+    for arg in "$@";
+    do
+        if [[ "$arg" = "--"* ]]; then
+            break;
+        fi;
+        fileNames+=("$arg");
+        shift;
+    done;
+    for file in "${fileNames[@]}";
+    do
+        substitute "$file" "$file" "$@";
+    done
+}
+substituteStream ()
+{
+ 
+    local var=$1;
+    local description=$2;
+    shift 2;
+    while (( "$#" )); do
+        case "$1" in 
+            --replace)
+                pattern="$2";
+                replacement="$3";
+                shift 3;
+                local savedvar;
+                savedvar="${!var}";
+                eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}';
+                if [ "$pattern" != "$replacement" ]; then
+                    if [ "${!var}" == "$savedvar" ]; then
+                        echo "substituteStream(): WARNING: pattern '$pattern' doesn't match anything in $description" 1>&2;
+                    fi;
+                fi
+            ;;
+            --subst-var)
+                local varName="$2";
+                shift 2;
+                if ! [[ "$varName" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then
+                    echo "substituteStream(): ERROR: substitution variables must be valid Bash names, \"$varName\" isn't." 1>&2;
+                    return 1;
+                fi;
+                if [ -z ${!varName+x} ]; then
+                    echo "substituteStream(): ERROR: variable \$$varName is unset" 1>&2;
+                    return 1;
+                fi;
+                pattern="@$varName@";
+                replacement="${!varName}";
+                eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}'
+            ;;
+            --subst-var-by)
+                pattern="@$2@";
+                replacement="$3";
+                eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}';
+                shift 3
+            ;;
+            *)
+                echo "substituteStream(): ERROR: Invalid command line argument: $1" 1>&2;
+                return 1
+            ;;
+        esac;
+    done;
+    printf "%s" "${!var}"
+}
+unpackFile ()
+{
+ 
+    curSrc="$1";
+    echo "unpacking source archive $curSrc";
+    if ! runOneHook unpackCmd "$curSrc"; then
+        echo "do not know how to unpack source archive $curSrc";
+        exit 1;
+    fi
+}
+unpackPhase ()
+{
+ 
+    runHook preUnpack;
+    if [ -z "${srcs:-}" ]; then
+        if [ -z "${src:-}" ]; then
+            echo 'variable $src or $srcs should point to the source';
+            exit 1;
+        fi;
+        srcs="$src";
+    fi;
+    local -a srcsArray;
+    if [ -n "$__structuredAttrs" ]; then
+        srcsArray=("${srcs[@]}");
+    else
+        srcsArray=($srcs);
+    fi;
+    local dirsBefore="";
+    for i in *;
+    do
+        if [ -d "$i" ]; then
+            dirsBefore="$dirsBefore $i ";
+        fi;
+    done;
+    for i in "${srcsArray[@]}";
+    do
+        unpackFile "$i";
+    done;
+    : "${sourceRoot=}";
+    if [ -n "${setSourceRoot:-}" ]; then
+        runOneHook setSourceRoot;
+    else
+        if [ -z "$sourceRoot" ]; then
+            for i in *;
+            do
+                if [ -d "$i" ]; then
+                    case $dirsBefore in 
+                        *\ $i\ *)
+
+                        ;;
+                        *)
+                            if [ -n "$sourceRoot" ]; then
+                                echo "unpacker produced multiple directories";
+                                exit 1;
+                            fi;
+                            sourceRoot="$i"
+                        ;;
+                    esac;
+                fi;
+            done;
+        fi;
+    fi;
+    if [ -z "$sourceRoot" ]; then
+        echo "unpacker appears to have produced no directories";
+        exit 1;
+    fi;
+    echo "source root is $sourceRoot";
+    if [ "${dontMakeSourcesWritable:-0}" != 1 ]; then
+        chmod -R u+w -- "$sourceRoot";
+    fi;
+    runHook postUnpack
+}
+updateAutotoolsGnuConfigScriptsPhase ()
+{
+ 
+    if [ -n "${dontUpdateAutotoolsGnuConfigScripts-}" ]; then
+        return;
+    fi;
+    for script in config.sub config.guess;
+    do
+        for f in $(find . -type f -name "$script");
+        do
+            echo "Updating Autotools / GNU config script to a newer upstream version: $f";
+            cp -f "/nix/store/7lk76vdawbx478qq9lvi3mgf73rvcyhd-gnu-config-2023-09-19/$script" "$f";
+        done;
+    done
+}
+updateSourceDateEpoch ()
+{
+ 
+    local path="$1";
+    local -a res=($(find "$path" -type f -not -newer "$NIX_BUILD_TOP/.." -printf '%T@ %p\0' | sort -n --zero-terminated | tail -n1 --zero-terminated | head -c -1));
+    local time="${res[0]//\.[0-9]*/}";
+    local newestFile="${res[1]}";
+    if [ "${time:-0}" -gt "$SOURCE_DATE_EPOCH" ]; then
+        echo "setting SOURCE_DATE_EPOCH to timestamp $time of file $newestFile";
+        export SOURCE_DATE_EPOCH="$time";
+        local now="$(date +%s)";
+        if [ "$time" -gt $((now - 60)) ]; then
+            echo "warning: file $newestFile may be generated; SOURCE_DATE_EPOCH may be non-deterministic";
+        fi;
+    fi
+}
+PATH="$PATH${nix_saved_PATH:+:$nix_saved_PATH}"
+XDG_DATA_DIRS="$XDG_DATA_DIRS${nix_saved_XDG_DATA_DIRS:+:$nix_saved_XDG_DATA_DIRS}"
+export NIX_BUILD_TOP="$(mktemp -d -t nix-shell.XXXXXX)"
+export TMP="$NIX_BUILD_TOP"
+export TMPDIR="$NIX_BUILD_TOP"
+export TEMP="$NIX_BUILD_TOP"
+export TEMPDIR="$NIX_BUILD_TOP"
+eval "$shellHook"

.envrc

···
+export HE_PASSWORD=SuperDuper
+use flake

.gitignore

···
 .worktrees/*
+.direnv/

dns/dnsconfig.js

···
 
 D("lakhwara.com", REG_NONE,
 	DnsProvider(DNS_HEDNS),
-	DefaultTTL(86400),
+	DefaultTTL(300),
 	//SOA('@', 'ns1.he.net.', 'hostmaster.he.net.', 2022041702, 86400, 7200, 3600000, 86400, TTL(172800)),
-	A('anish', '103.16.130.98'),
-	A('coaching', '103.16.130.98'),
+	A('anish', '69.61.2.203'),
+	A('@', '69.61.2.203'),
+	//A('coaching', '103.16.130.98'),
 	TXT('anish', 'datkey=dat://1a240a14fab2bae9c85ebad29bddc04505aaba24e5fb809c2ccb4cdf71e3a7d5'),
 	CNAME('fm1._domainkey', 'fm1.lakhwara.com.dkim.fmhosted.com.'),
 	CNAME('fm2._domainkey', 'fm2.lakhwara.com.dkim.fmhosted.com.'),
 	CNAME('fm3._domainkey', 'fm3.lakhwara.com.dkim.fmhosted.com.'),
-	A('@', '103.16.130.98'),
 	MX('@', 10, 'in1-smtp.messagingengine.com.'),
 	MX('@', 20, 'in2-smtp.messagingengine.com.'),
 	//NAMESERVER('ns1.he.net.'),
···
 	A('git', '69.61.2.203', TTL(300)),
 	A('bin', '69.61.2.203', TTL(300)),
 	A('ci', '69.61.2.203', TTL(300)),
+	A('write', '69.61.2.203', TTL(300)),
 	// vultr -> nulled: lituus
 	A('@', '45.77.48.108', TTL(300)),
 	A('jitsi', '45.77.48.108', TTL(300)),

flake.lock

···
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1747514353,
-        "narHash": "sha256-E1WjB+zvDw4x058mg3MIdK5j2huvnNpTEEt2brhg2H8=",
+        "lastModified": 1747575206,
+        "narHash": "sha256-NwmAFuDUO/PFcgaGGr4j3ozG9Pe5hZ/ogitWhY+D81k=",
         "owner": "ryantm",
         "repo": "agenix",
-        "rev": "6697e8babbd8f323dfd5e28f160a0128582c128b",
+        "rev": "4835b1dc898959d8547a871ef484930675cb47f1",
         "type": "github"
       },
       "original": {
···
         "ref": "main",
         "type": "git",
         "url": "ssh://[e-mail]/aynish/basant"
+      }
+    },
+    "breezy": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "flake-utils": "flake-utils_2",
+        "nixpkgs": [
+          "unstable"
+        ]
+      },
+      "locked": {
+        "lastModified": 1746128594,
+        "narHash": "sha256-yynk80vxbBk3zhcGj/FT8lz2DBrjxb/1OoRy8JEbqtQ=",
+        "owner": "shymega",
+        "repo": "breezy-desktop",
+        "rev": "77b9d4ef8dbf6a26427be6f3edae49d3c36fd5bc",
+        "type": "github"
+      },
+      "original": {
+        "owner": "shymega",
+        "ref": "shymega/add-nix-flake-support",
+        "repo": "breezy-desktop",
+        "type": "github"
       }
     },
     "brew-src": {
···
         ]
       },
       "locked": {
-        "lastModified": 1747521943,
-        "narHash": "sha256-GMAJcB8oB9cC+TbYTE7QDfw9fwHZyloxUWnUpHnQRko=",
+        "lastModified": 1748065210,
+        "narHash": "sha256-dFqlLNW6UW19m0vg5FHWLH2G2LGkqYyPs/4YqfoZMoM=",
         "owner": "LnL7",
         "repo": "nix-darwin",
-        "rev": "b9b927dd1f24094b271e8ec5277a672dc4fc860d",
+        "rev": "acd6aa5a9065c6695212be313e06f08f7184cb25",
         "type": "github"
       },
       "original": {
···
     },
     "deploy-rs": {
       "inputs": {
-        "flake-compat": "flake-compat",
+        "flake-compat": "flake-compat_2",
         "nixpkgs": [
           "nixpkgs"
         ],
···
         ]
       },
       "locked": {
-        "lastModified": 1747274630,
-        "narHash": "sha256-87RJwXbfOHyzTB9LYagAQ6vOZhszCvd8Gvudu+gf3qo=",
+        "lastModified": 1747742835,
+        "narHash": "sha256-kYL4GCwwznsypvsnA20oyvW8zB/Dvn6K5G/tgMjVMT4=",
         "owner": "nix-community",
         "repo": "disko",
-        "rev": "ec7c109a4f794fce09aad87239eab7f66540b888",
+        "rev": "df522e787fdffc4f32ed3e1fca9ed0968a384d62",
         "type": "github"
       },
       "original": {
···
     "flake-compat_2": {
       "flake": false,
       "locked": {
+        "lastModified": 1696426674,
+        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-compat_3": {
+      "flake": false,
+      "locked": {
         "lastModified": 1641205782,
         "narHash": "sha256-4jY7RCWUoZ9cKD8co0/4tFARpWB+57+r1bLLvXNJliY=",
         "owner": "edolstra",
···
         "type": "github"
       }
     },
-    "flake-compat_3": {
+    "flake-compat_4": {
       "flake": false,
       "locked": {
         "lastModified": 1696426674,
···
         "type": "github"
       }
     },
+    "flake-compat_5": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1733328505,
+        "narHash": "sha256-NeCCThCEP3eCl2l/+27kNNK7QrwZB1IJCrXfrbv5oqU=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "ff81ac966bb2cae68946d5ed5fc4994f96d0ffec",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
     "flake-parts": {
       "inputs": {
         "nixpkgs-lib": [
···
       }
     },
     "flake-utils_2": {
+      "inputs": {
+        "systems": "systems_2"
+      },
+      "locked": {
+        "lastModified": 1726560853,
+        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_3": {
       "locked": {
         "lastModified": 1667395993,
         "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=",
···
         "type": "github"
       }
     },
+    "flake-utils_4": {
+      "inputs": {
+        "systems": "systems_4"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
     "gitignore": {
       "inputs": {
         "nixpkgs": [
···
     },
     "grasp": {
       "inputs": {
-        "flake-utils": "flake-utils_2",
+        "flake-utils": "flake-utils_3",
         "nixpkgs": [
           "nixpkgs"
         ]
···
     },
     "hardware": {
       "locked": {
-        "lastModified": 1747129300,
-        "narHash": "sha256-L3clA5YGeYCF47ghsI7Tcex+DnaaN/BbQ4dR2wzoiKg=",
+        "lastModified": 1747900541,
+        "narHash": "sha256-dn64Pg9xLETjblwZs9Euu/SsjW80pd6lr5qSiyLY1pg=",
         "owner": "nixos",
         "repo": "nixos-hardware",
-        "rev": "e81fd167b33121269149c57806599045fd33eeed",
+        "rev": "11f2d9ea49c3e964315215d6baa73a8d42672f06",
         "type": "github"
       },
       "original": {
···
     "homebrew-cask": {
       "flake": false,
       "locked": {
-        "lastModified": 1747532349,
-        "narHash": "sha256-MpVDXDQLeUAlKVm57PGv7v/4H43DCS2VDlhUDy1t+Z8=",
+        "lastModified": 1748113418,
+        "narHash": "sha256-lX4WosoMtusSD4GRDRvzwQwzLJUetg5HEWlMcJ4IQmI=",
         "owner": "homebrew",
         "repo": "homebrew-cask",
-        "rev": "39e4baca231c013729863c84e53cfa7c23e9da33",
+        "rev": "ed1a02852e1c4a5fab4aef776082ca89cd70f09a",
         "type": "github"
       },
       "original": {
···
     "homebrew-core": {
       "flake": false,
       "locked": {
-        "lastModified": 1747546566,
-        "narHash": "sha256-Jbhg5Q65/YqZth9CSzTGqKgG2YHf4IbxlyWta97lXWo=",
+        "lastModified": 1748120562,
+        "narHash": "sha256-b4Qd9nAVW8yMqZ5T9B7HfSrDLCrtsw07D98/NWz2xsE=",
         "owner": "homebrew",
         "repo": "homebrew-core",
-        "rev": "fed56bce55ff3905d5803325e9cfdd335f07150c",
+        "rev": "b26cd07a06b15767688137a68461cb34fe985efa",
         "type": "github"
       },
       "original": {
···
         ]
       },
       "locked": {
-        "lastModified": 1747466853,
-        "narHash": "sha256-/evYltwuF8Kz1odgocWnguh/8VQV1i76VB4yMTU9m7k=",
+        "lastModified": 1747990026,
+        "narHash": "sha256-sG5VbID+x5+xUC+jjgHibnzg8IllVcH+K2TLmYHLPME=",
         "owner": "jovian-experiments",
         "repo": "jovian-nixos",
-        "rev": "0ba1a34fa6d995fe433109f0ad66de8d5613d46e",
+        "rev": "e2f4ced874406541a7957f7e2b8f05a0d59a0f00",
         "type": "github"
       },
       "original": {
···
     "nix-matrix-appservices": {
       "inputs": {
         "devshell": "devshell",
-        "flake-compat": "flake-compat_2",
+        "flake-compat": "flake-compat_3",
         "nixlib": "nixlib",
         "nixpkgs": "nixpkgs_3"
       },
···
     },
     "nixos-hardware": {
       "locked": {
-        "lastModified": 1747129300,
-        "narHash": "sha256-L3clA5YGeYCF47ghsI7Tcex+DnaaN/BbQ4dR2wzoiKg=",
+        "lastModified": 1747900541,
+        "narHash": "sha256-dn64Pg9xLETjblwZs9Euu/SsjW80pd6lr5qSiyLY1pg=",
         "owner": "NixOS",
         "repo": "nixos-hardware",
-        "rev": "e81fd167b33121269149c57806599045fd33eeed",
+        "rev": "11f2d9ea49c3e964315215d6baa73a8d42672f06",
         "type": "github"
       },
       "original": {
···
     },
     "nixpkgs_4": {
       "locked": {
-        "lastModified": 1747335874,
-        "narHash": "sha256-IKKIXTSYJMmUtE+Kav5Rob8SgLPnfnq4Qu8LyT4gdqQ=",
+        "lastModified": 1747862697,
+        "narHash": "sha256-U4HaNZ1W26cbOVm0Eb5OdGSnfQVWQKbLSPrSSa78KC0=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "ba8b70ee098bc5654c459d6a95dfc498b91ff858",
+        "rev": "2baa12ff69913392faf0ace833bc54bba297ea95",
         "type": "github"
       },
       "original": {
···
     },
     "nixpkgs_5": {
       "locked": {
-        "lastModified": 1747327360,
-        "narHash": "sha256-LSmTbiq/nqZR9B2t4MRnWG7cb0KVNU70dB7RT4+wYK4=",
+        "lastModified": 1748026106,
+        "narHash": "sha256-6m1Y3/4pVw1RWTsrkAK2VMYSzG4MMIj7sqUy7o8th1o=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "e06158e58f3adee28b139e9c2bcfcc41f8625b46",
+        "rev": "063f43f2dbdef86376cc29ad646c45c46e93234c",
         "type": "github"
       },
       "original": {
···
         "treefmt-nix": "treefmt-nix"
       },
       "locked": {
-        "lastModified": 1747542017,
-        "narHash": "sha256-sFSV0Hfd8KRE5w8Ly11WMRPQKm9S5yCD12pdgAcsppU=",
+        "lastModified": 1748119613,
+        "narHash": "sha256-BvOMqlTgRbz8ldRcaf7OTKIRsGlOw4AssphiZGLd0fo=",
         "owner": "nix-community",
         "repo": "NUR",
-        "rev": "5ce8c2eb9c364ad7154a78878ecc838efbe8832e",
+        "rev": "48380b491e6415284292516fe919d78207969e30",
         "type": "github"
       },
       "original": {
···
         ]
       },
       "locked": {
-        "lastModified": 1724637654,
-        "narHash": "sha256-86TExy5MWkXLd7Oio1QGuwzkSG9lxsYVPo/3IoFkLFM=",
+        "lastModified": 1738465265,
+        "narHash": "sha256-v8nD/2gq8/mILEJqvWgx1q7Fc1purQvV3/WZLQ/t/wc=",
         "ref": "main",
-        "rev": "521e360df123a530fc4c99187e3580bd5d086a9d",
-        "revCount": 1467,
+        "rev": "115f8af750c0d4b6a8c6f97119b12d7e3eb20c6a",
+        "revCount": 1552,
         "type": "git",
         "url": "ssh://[e-mail]/aynish/kitaab"
       },
···
     },
     "pre-commit-nix": {
       "inputs": {
-        "flake-compat": "flake-compat_3",
+        "flake-compat": "flake-compat_4",
         "gitignore": "gitignore",
         "nixpkgs": "nixpkgs_8",
         "nixpkgs-stable": "nixpkgs-stable"
···
       "inputs": {
         "agenix": "agenix",
         "basant": "basant",
+        "breezy": "breezy",
         "darwin": "darwin_2",
         "deploy-rs": "deploy-rs",
         "disko": "disko",
···
         "sourcegraph-src-cli-cask": "sourcegraph-src-cli-cask",
         "tidalcycles": "tidalcycles",
         "unstable": "unstable",
-        "vimwikicli": "vimwikicli"
+        "vimwikicli": "vimwikicli",
+        "xr-linux": "xr-linux"
       }
     },
     "rust-overlay": {
···
         ]
       },
       "locked": {
-        "lastModified": 1747535902,
-        "narHash": "sha256-rKWBtLcqQeu8PpfKIBn1ORXS2udSH/MwnQFwfSpFOLg=",
+        "lastModified": 1748054080,
+        "narHash": "sha256-rwFiLLNCwkj9bqePtH1sMqzs1xmohE0Ojq249piMzF4=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "b7a99615d26b82c39b73ccc9026545c3f3403b71",
+        "rev": "2221d8d53c128beb69346fa3ab36da3f19bb1691",
         "type": "github"
       },
       "original": {
···
     "sourcegraph-src-cli-cask": {
       "flake": false,
       "locked": {
-        "lastModified": 1747406457,
-        "narHash": "sha256-AH3nqf0VIxdEKwAlacFzNn2LYmaKFp7AAjazHLjgktQ=",
+        "lastModified": 1747940755,
+        "narHash": "sha256-rS+LEcZKOoRN3bH+aZIV1Y4AlPR8dWosiRAA8Q1itBs=",
         "owner": "sourcegraph",
         "repo": "homebrew-src-cli",
-        "rev": "ae66248cf103c4c9f72fc969c0503954bcfc0adf",
+        "rev": "34bb40706f3f9641958db65c5c77a1db51140b3d",
         "type": "github"
       },
       "original": {
···
       }
     },
     "systems_2": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_3": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_4": {
       "locked": {
         "lastModified": 1681028828,
         "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
···
     },
     "unstable": {
       "locked": {
-        "lastModified": 1747327360,
-        "narHash": "sha256-LSmTbiq/nqZR9B2t4MRnWG7cb0KVNU70dB7RT4+wYK4=",
+        "lastModified": 1748026106,
+        "narHash": "sha256-6m1Y3/4pVw1RWTsrkAK2VMYSzG4MMIj7sqUy7o8th1o=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "e06158e58f3adee28b139e9c2bcfcc41f8625b46",
+        "rev": "063f43f2dbdef86376cc29ad646c45c46e93234c",
         "type": "github"
       },
       "original": {
···
     },
     "utils": {
       "inputs": {
-        "systems": "systems_2"
+        "systems": "systems_3"
       },
       "locked": {
         "lastModified": 1701680307,
···
       "original": {
         "owner": "supercollider-quarks",
         "repo": "vowel",
+        "type": "github"
+      }
+    },
+    "xr-linux": {
+      "inputs": {
+        "flake-compat": "flake-compat_5",
+        "flake-utils": "flake-utils_4",
+        "nixpkgs": [
+          "unstable"
+        ]
+      },
+      "locked": {
+        "lastModified": 1746033220,
+        "narHash": "sha256-l4pISN7GDSL2o0BddkWtdCX4k4BjAaW0xwo5DbhfO8A=",
+        "owner": "shymega",
+        "repo": "XRLinuxDriver",
+        "rev": "c6cd02d547f87a156538c131e09ee4d41eb79325",
+        "type": "github"
+      },
+      "original": {
+        "owner": "shymega",
+        "ref": "shymega/nix-flake-support",
+        "repo": "XRLinuxDriver",
         "type": "github"
       }
     }

flake.nix

···
 {
-  description = "Your new nix config";
+  description = "Sealight NixOS Config";
 
   inputs = {
     # Nixpkgs
     nixpkgs.url = "github:nixos/nixpkgs/nixos-24.11";
     unstable.url = "github:nixos/nixpkgs/nixos-unstable";
     nixos-hardware.url = "github:NixOS/nixos-hardware/master";
+
+    # ngipkgs.url = "github:Chickensoupwithrice/ngipkgs?ref=aynish/atomic-server-module";
+    # ngipkgs-local.url = "path:/home/anish/usr/ngipkgs";
 
     # Home manager
     home-manager.url = "github:nix-community/home-manager/release-25.05";
···
         # ];
         overlays = [
           agenix.overlays.default
+          self.overlays.additions
+          self.overlays.modifications
           tidalcycles.overlays.default # needed for nvim which comes pre-installed lol
         ];
       });
···
             agenix.nixosModules.age
             self.nixosModules.backup
             self.nixosModules.wireguard
+            self.nixosModules.wallabag
             nixos-hardware.nixosModules.lenovo-thinkpad-x270
             home-manager.nixosModules.home-manager
             {
···
             agenix.nixosModules.age
             self.nixosModules.backup
             self.nixosModules.wireguard
+            basant.nixosModule
             # self.nixosModules.microbin
             disko.nixosModules.disko
+            {
+              nixpkgs.flake.setNixPath = false;
+              nixpkgs.flake.setFlakeRegistry = false;
+            }
           ];
         };
 
···
           ];
         };
 
-        cube = nixpkgs.lib.nixosSystem rec {
-          specialArgs = { inherit inputs self; };
-          system = "x86_64-linux";
-          pkgs = litePkgsFor.${system};
-          modules = [
-            ./hosts/cube
-            agenix.nixosModules.age
-            self.nixosModules.backup
-            self.nixosModules.wireguard
-            basant.nixosModule
-          ];
-        };
-
         box = nixpkgs.lib.nixosSystem rec {
           specialArgs = { inherit inputs self; };
           system = "x86_64-linux";
···
             self.nixosModules.backup
             self.nixosModules.wireguard
             self.nixosModules.gonic
+            self.nixosModules.gpodder2go
             self.nixosModules.wallabag
             self.nixosModules.ulogger-server
             grasp.nixosModule
···
           hostname = "mossnet.lan";
           autoRollback = false;
           magicRollback = false;
+          remoteBuild = true;
           profiles.system = {
             user = "root";
             path = deploy-rs.lib.x86_64-linux.activate.nixos self.nixosConfigurations.box;
···
           profiles.system = {
             user = "root";
             path = deploy-rs.lib.x86_64-linux.activate.nixos self.nixosConfigurations.helix;
-          };
-        };
-        cube = {
-          hostname = "lakhwara.com";
-          profiles.system = {
-            user = "root";
-            path = deploy-rs.lib.x86_64-linux.activate.nixos self.nixosConfigurations.cube;
           };
         };
       };

home/core/default.nix

···
 { self, pkgs, ... }:
 {
   imports = [
-    # ../profiles/nvim
+    ../profiles/nvim
     ../profiles/cli
     ../profiles/direnv
     ../profiles/git
-    ../profiles/task
   ];
   home.stateVersion = "22.05";
 }

home/gui/default.nix

···
 {
   imports = [
     ../core
+    ../profiles/nvim
     ../profiles/firefox
     ../profiles/desktop
     ../profiles/email

home/profiles/cli/default.nix

···
     dosfstools
     # git
     git-machete
+    git-spice
+    jujitsu
     asciinema
     bottom
     gptfdisk
···
     iftop
     wget
     curl
+<<<<<<< HEAD
     eza
     bat
     fd
     # ncdu
+=======
+    eza 
+    bat
+    fd
+    ncdu
+    du-dust 
+    # dia-cli
+>>>>>>> nvim-rewrite
     duf
     trash-cli
     nix-index
···
     autosuggestion.enable = false;
 
     initExtra = ''
-      bindkey -v
       autopair-init
     '';
     sessionVariables = {
···
 
     # modern cli tools 
     ls = "eza --icons";
-    l = "eza -l --icons";
+    l = "esa -l --icons";
     la = "eza -la --icons";
     tree = "ls --tree --icons";
     cat = "bat";
···
     make-secret = "< /dev/urandom \\tr -dc _A-Za-z0-9 | head -c \${1:-32};echo;";
 
     # task warrior
-    # TODO: make blocked a context?
     t = "task -BLOCKED -idea -backlog"; 
+    tw = "t rc.context:work";
+    # TODO find a reasonable way to manage this from a non-nix managed file in ~/.task/context or something
+    # we can do something like task rc.context:$(cat ~/.task/context) to read context
+    # and write a little script make-context = cat $@ > ~/.task/context or something
     tt = "taskwarrior-tui -r list";
     ti = "task +idea";
     tb = "task +backlog list";
     ttb = "taskwarrior-tui -r backlog";
     tr = "task newest limit:page";
-    tw = "task +wait";
+    twait = "task +wait";
     ta = "task add";
     tai = "task add +idea";
     tn = "task-note";

home/profiles/desktop/bspwmrc

···
 # esac
 
 export MONITOR=$(xrandr -q | grep primary | cut -d' ' -f1)
-export MONITORS=( $(xrandr -q | grep ' connected' | cut -d' ' -f1) )
+export MONITORS=($(xrandr -q | grep ' connected' | cut -d' ' -f1))
 MONITOR=${MONITOR:-${MONITORS[0]}}
 
 # Only have workspaces for primary monitor
···
 bspc config focused_border_color "#bd93f9"
 bspc config presel_feedback_color "#bd93f9"
 
-bspc config split_ratio         0.71
+bspc config split_ratio 0.71
 
 # Extra padding for polybar
 bspc config -m primary top_padding 34

home/profiles/desktop/default.nix

···
     ".local/bin/mpv-ify".source = ./bin/mpv-ify;
     ".local/bin/bspswallow".source = ./bin/bspswallow;
     ".config/bspwm/terminals".text = "Kitty";
-    ".config/eww/eww.yuck".source = ./eww/eww.yuck;
-    ".config/eww/eww.scss".source = ./eww/eww.scss;
-    ".config/eww/widgets.yuck".source = ./eww/widgets.yuck;
     # ".local/bin/hotplug-monitor.sh".source = ./bin/hotplug-monitor.sh;
   };
 
···
 
   qt = {
     enable = true;
-    platformTheme = "gtk";
+    platformTheme.name = "gtk";
     style = { name = "qt5ct-style"; };
   };
 

home/profiles/email/default.nix

···
       bind editor ^T complete
 
       # Press A to archive
-      macro index,pager A  "<clear-flag>N<save-message>=/Archive"  "mark message as Archived"
+      macro index,pager A  "<clear-flag><save-message>=/Archive"  "mark message as Archived"
       # Press C to add contact to Khard address book
       macro index,pager C \
       "<pipe-message>khard add-email<return>" \

home/profiles/firefox/default.nix

···
       extensions = with pkgs.nur.repos.rycee.firefox-addons; [
         # Find extensions: https://github.com/nix-community/nur-combined/blob/master/repos/rycee/pkgs/firefox-addons/generated-firefox-addons.nix
         ublock-origin
-        wallabagger
+        # wallabagger
         # tree-style-tab
         tridactyl
         promnesia

home/profiles/nvim/config/after/syntax/vimwiki.vim

···
+" match with %update
+syntax match VimwikiPlaceholder /^\s*%update\ze\%(\s.*\)\?$/ nextgroup=VimwikiPlaceholderParam skipwhite
+" match with %link
+syntax match VimwikiPlaceholder /^\s*%link\ze\%(\s.*\)\?$/ nextgroup=VimwikiPlaceholderParam skipwhite

home/profiles/nvim/config/fnl/conf/formatting.fnl

···
+(import-macros {: do-req } :lib/macros)
+
+(do-req :conform :setup 
+        {:formatters_by_ft {:lua ["stylua"]
+                            :nix ["nixfmt"]
+                            ; :go ["goimports" "gofmt"] ; Go handled in special case
+                            :terraform ["terraform_fmt"]
+                            :sh ["shfmt"]
+                            :bazel ["buildifier"]}
+         :format_on_save {:lsp_format "fallback"
+                          :timeout_ms 500}})

home/profiles/nvim/config/fnl/conf/init.fnl

···
+(local nvim (require :lib/nvim))
+
+(nvim.g :mapleader " ")
+
+; (nvim.opt :runtimepath (.. vim.opt.runtimepath "/home/anish/.config/nvim/,"))
+(nvim.opt :tabstop 2)
+(nvim.opt :showmatch true)
+(nvim.opt :shiftwidth 2)
+(nvim.opt :autoindent true)
+(nvim.opt :undofile true)
+(nvim.opt :signcolumn "auto:4")
+(nvim.opt :title true)
+(nvim.opt :number true)
+; (nvim.opt :nocompatible)
+(nvim.opt :relativenumber true)
+(nvim.opt :showtabline 2)
+(nvim.opt :expandtab true)
+(nvim.opt :autowriteall true)
+(nvim.opt :cmdheight 2)
+(nvim.opt :spelllang "en_gb")
+(nvim.opt :ignorecase true)
+(nvim.opt :smartcase true)
+(nvim.opt :incsearch true)
+(nvim.opt :updatetime 300) ; Diagnostics response time
+(nvim.opt :signcolumn "yes")
+(nvim.opt :cursorline true)
+
+(nvim.opt :lisp true) ; include - in word to move better in snake-case)
+(nvim.g :sexp_filetypes "clojure,scheme,lisp,janet,fennel,yuck") ; include the lisps I use
+
+(nvim.opt :termguicolors)
+(nvim.colorscheme "ayu-mirage")
+
+(require :conf.plugins)
+(require :conf.mappings)
+(require :conf.lsp)
+(require :conf.plugins.cmp)
+(require :conf.formatting)
+; (require :conf.kitaab)
+
+; Spelling
+(vim.api.nvim_create_autocmd ["BufRead" "BufNewFile"] 
+                             {:pattern ["*.wiki" "*.txt" "*.md" "*.tex"]
+                              :command "setlocal spell"})
+(vim.api.nvim_create_autocmd ["FileType"]
+                             {:pattern ["mail"]
+                              :command "setlocal spell"})
+
+; Svelte
+(vim.api.nvim_create_autocmd ["BufNewFile" "BufRead"] {:pattern ["*.svelte"] 
+                                                       :command "setf svelte"})

home/profiles/nvim/config/fnl/conf/lsp.fnl

···
+(import-macros {: do-req } :lib/macros)
+(local lspkind (require :lspkind))
+(local lspconfig (require :lspconfig))
+; (local lspsaga (require :lspsaga))
+(local cmp (require :cmp))
+(local nvim (require :lib/nvim))
+; (local lspfuzzy (require :lspfuzzy)) ; Not available on Nix
+; (local sg (require :sg))
+; (local lsputil (require :lspconfig/util))
+
+;(lspsaga.setup {:border_style "rounded"
+;                :code_action_icon ""
+;                :code_action_num_shortcut false
+;                :ui {:code_action ""}
+;                :show_outline {:enable false}))
+;
+;(nvim.opt :winbar nil)
+
+(local signs {:Error " " 
+              :Warn " " 
+              :Hint " " 
+              :Info " "})
+(each [t icon (pairs signs)]
+  (let [hl (.. "DiagnosticSign" t)]
+    (vim.fn.sign_define hl {:text icon
+                            :texthl hl
+                            :numhl hl})))
+
+(tset vim.lsp.handlers 
+      :textDocument/hover 
+      (vim.lsp.with vim.lsp.handlers.hover 
+                    {:focusable false :border "rounded"}))
+(tset vim.lsp.handlers
+      :textDocument/signatureHelp
+      (vim.lsp.with vim.lsp.handlers.signature_help
+                    {:focusable false :border "rounded"}))
+
+(local capabilities (let [cmp_nvim_lsp (require :cmp_nvim_lsp)]
+                      (cmp_nvim_lsp.default_capabilities)))
+
+(local formatting-augroup (nvim.augroup :LspFormatting))
+
+(fn goimports [wait-ms]
+  (let [params (vim.lsp.util.make_range_params) 
+         result (do
+                 (tset params :context {:only [:source.organizeImports]})
+                 (vim.lsp.buf_request_sync 0 :textDocument/codeAction params wait-ms))]
+       (each [_ res (pairs (or result {}))]
+         (each [_ r (pairs (or res.result {}))]
+           (if r.edit
+               (vim.lsp.util.apply_workspace_edit r.edit "utf-16")
+               (vim.lsp.buf.execute_command r.command))))
+   (vim.lsp.buf.format)))
+
+(fn on-attach [client bufnr]
+              (let [filetype (vim.api.nvim_buf_get_option 0 "filetype")]
+                (if (client.supports_method "textDocument/formatting")
+                    (do (nvim.autocmd "BufWritePre"
+                                      {:group formatting-augroup
+                                       :buffer bufnr
+                                       :callback (fn [_] (if (= filetype "go")
+                                                             (goimports 2000)
+                                                             (vim.lsp.buf.format {:bufnr bufnr})))})))))
+
+(lspconfig.gopls.setup 
+  {:capabilities capabilities
+   :codelens {:generate true :gc_details true}
+   :semanticTokens true
+   :flags {:debounce_text_changes 200}
+   :analyses {:unusedparams true
+              :unusedvariables true
+              :unusedwrite true
+              :nilness true
+              :unusedwrite true
+              :useany true}
+   :completeUnimported true
+   :staticcheck true
+   :experimentalPostfixCompletions true
+   :hints {:constantValues true
+           :functionTypeParameters true   
+           :assignVariablesTypes true
+           :compositeLiteralTypes true
+           :compositeLiteralFields true
+           :parameterNames true
+           :rangeVariableTypes true}
+   :on_attach on-attach})
+
+(local lsps [:nil_ls :terraform_lsp :fennel_ls :tsserver :starbin])
+(each [index lsp (ipairs lsps)]
+  ((. (. lspconfig lsp) :setup) {}))
+
+; null-ls
+(let [null-ls (require :null-ls)]
+  (null-ls.setup {:sources [; TODO fix these
+                            ;null-ls.builtins.diagnostics.shellcheck
+                            null-ls.builtins.diagnostics.commitlint]}))
+                            ;null-ls.builtins.diagnostics.jsonlint]}))
+                            ;(null-ls.builtins.diagnostics.proselint.with {:filetypes ["vimwiki" "mail"]})]}))
+

home/profiles/nvim/config/fnl/conf/mappings.fnl

···
+(local nvim (require :lib/nvim))
+(import-macros {: do-req } :lib/macros)
+
+(local wk (require :which-key))
+
+;; Convenient way to indent stuff in visual mode
+(nvim.keymap [:v] "<" "<gv" {:noremap true})
+(nvim.keymap [:v] ">" ">gv" {:noremap true})
+(nvim.keymap [:n] "<space>" "<NOP>" {:noremap true :silent true})
+;; Convenient way to move stuff in visual mode
+(nvim.keymap [:v] "J" ":m '>+1<CR>gv=gv" {:noremap true})
+(nvim.keymap [:v] "K" ":m '>-2<CR>gv=gv" {:noremap true})
+;; Convientent screen shifting 
+(nvim.keymap [:n] "n" "nzzzv" {:noremap true})
+(nvim.keymap [:n] "N" "Nzzzv" {:noremap true})
+(nvim.keymap [:n] "J" "mzJ'z" {:noremap true})
+; Fix Y
+(nvim.keymap [:n] "Y" "y$")
+; Unmap Q
+(nvim.keymap [] "Q" "<Nop>")
+; TODO
+; ESC clears search
+; (nvim.keymap [:n] "<ESC>" "")
+
+; FTerm
+(vim.api.nvim_create_user_command "FTermToggle" (fn [_] 
+                                                  ((-> (require :FTerm) 
+                                                      (. :toggle)))) 
+                                  {:bang true})
+(nvim.keymap [:t] "<TAB>" "<cmd>:FTermToggle<CR>")
+(nvim.keymap [:n] "<TAB>" "<cmd>:FTermToggle<CR>" {:noremap true})
+
+; Buffer Movement
+(nvim.keymap [:n] "gT" ":BufferPrevious<CR>" {:silent true :noremap true}) 
+(nvim.keymap [:n] "gt" ":BufferNext<CR>" {:silent true :noremap true}) 
+(nvim.keymap [:n] "gj" ":BufferPick<CR>" {:silent true :noremap true}) 
+(nvim.keymap [:n] "gb" ":Telescope buffers<CR>" {:silent true :noremap true}) 
+(nvim.keymap [:n] "gq" ":BufferClose<CR>" {:silent true :noremap true}) 
+
+; Flash
+(vim.api.nvim_create_user_command "Flash" (fn [_] (do-req :flash :jump)) {})
+(vim.api.nvim_create_user_command "FlashTreesitter" (fn [] (do-req :flash :treesitter)) {})
+(nvim.keymap [:n] "f" "<cmd>Flash<CR>") 
+(nvim.keymap [:n] "s" "<cmd>FlashTreesitter<CR>") 
+
+(local
+  normal-map-leader
+  {"t" [":Neotree toggle<CR>"
+        "Toggle neo-tree"]
+   "w" ["<cmd>:w<cr>"
+        "Write file"]
+   "q" ["<cmd>:q<cr>"
+        "Quit"]
+   "r" [":RainbowParenthesesToggleAll<CR>"
+        "Toggle Rainbow Parens"]
+   "u" [":UndotreeToggle<CR>"
+        "Toggle Undo Tree"]
+   ; Telescope 
+   "f" {:name "Files"
+        :f ["<cmd>Telescope find_files<cr>"
+             "Find Files (in Telescope)"]
+        :g ["<cmd>Telescope live_grep<cr>"
+             "Find Grep (in Telescope)"]
+        :b ["<cmd>Telescope buffers<cr>"
+             "Find Buffers"]
+        :h ["<cmd>Telescope help_tags<cr>"
+             "Find Help"]
+        :t ["<cmd>Telescope tags<cr>"
+            "Find Tags"]
+        :r ["<cmd>Telescope oldfiles<CR>"
+            "Recent files"]}
+   ; Git
+   "g" {:name "Git"
+         "s" [":G<CR>"
+              "Git Status"]
+         "f" [":G fetch --all<cr>"
+              "Git Fetch"]
+         "b" [":GBranches<cr>"
+              "Git Branch"]
+         "p" [":Git! push<cr>"
+              "Git Push"]
+         "d" [":GDiff<cr>"
+              "Git Diff"]
+         "h" [""
+              "Commit Hunk under Cursor"]}
+         ; For handling merges
+         ;     nmap <leader>gl :diffget //3<CR>
+         ;     nmap <leader>gh :diffget //2<CR>
+         ;     nnoremap <leader>gc :G commit -v -q %:p<CR>
+   ; Buffers
+   "b" {:name "Buffer"
+        :b ["<cmd>:Telescope buffers<CR>"
+            "Buffer List"]
+        :q ["<cmd>:BufferClose<CR>"
+             "Buffer Quit"]
+        :n ["<cmd>:BufferNext<CR>"
+            "Buffer Next"]
+        :N ["<cmd>:tabp<CR>"
+            "Buffer Previous"]
+        :p ["<cmd>:tabp<CR>"
+            "Buffer Previous"]}
+   ; Search
+   "s" {:name "Search"
+        :b ["<cmd>Telescope current_buffer_fuzzy_find<CR>"
+            "Search in current buffer"]
+        :s ["<cmd>Telescope live_grep<CR>"
+            "Search in project"]
+        :t ["<cmd>TodoTelescope<CR>"
+            "Search TODOs in project"]
+        :c ["<cmd>let @/ = \"\"<CR>:echo 'Search highlight cleared'<CR>"
+            "Clear search"]
+        :g ["<cmd>Telescope live_grep<cr>"
+             "Find Grep (in Telescope)"]}
+   ; Code
+   "c" {:name "Code"
+        :d [":lua vim.lsp.buf.definition()<CR>"
+            "Go to Definition"]
+        :i [":lua require('telescope.builtin').lsp_implementation()<CR>"
+            "Implementation"]
+        :s [":lua vim.lsp.buf.signature_help()<CR>"
+            "Signature Help"]
+        :r [":Lspsaga rename<CR>"
+            "Rename Symbol"]
+        :h [":Lspsaga hover_doc<CR>"
+            "Hover doc"]
+        :o ["<cmd>AerialToggle!<CR>"
+            "Outline"]
+        :t [":LspDiagnostics 0"
+            "Find Errors in Buffer"]}
+   ; Kitaab
+   "z" {:name "Kitaab"
+        :n [":ZettelNew<CR>"
+            "Zettel New"]}
+   "v" {:name "Tabs"
+        :v [":vnew<CR>"
+            "Vertical Split"]
+        :h [":new<CR>"
+            "Horizontal Split"]}})
+
+(wk.register normal-map-leader {:prefix "<leader>"})

home/profiles/nvim/config/fnl/conf/music.fnl

···
+(local nvim (require :lib/nvim))
+
+(nvim.g :tidal_target "terminal")
+(nvim.g :scnvim_snippet_format "luasnip")
+
+; -- supercollider
+; local scnvim = require 'scnvim'
+; local map = scnvim.map
+; local map_expr = scnvim.map_expr
+; scnvim.setup {
+;   keymaps = {
+;     ['<localleader>e'] = map('editor.send_line', {'i', 'n'}),
+;     ['<localleader>s'] = map_expr('CmdPeriod.run', {'i', 'n'}),
+;     ['<localleader>t'] = {
+;       map('editor.send_block', {'i', 'n'}),
+;       map('editor.send_selection', 'x'),
+;     },
+;     ['<CR>'] = map('postwin.toggle'),
+;     ['<M-CR>'] = map('postwin.toggle', 'i'),
+;     ['<M-L>'] = map('postwin.clear', {'n', 'i'}),
+;     ['<C-k>'] = map('signature.show', {'n', 'i'}),
+;     ['<F12>'] = map('sclang.hard_stop', {'n', 'x', 'i'}),
+;     ['<leader>st'] = map('sclang.start'),
+;     ['<leader>sk'] = map('sclang.recompile'),
+;     ['<F1>'] = map_expr('s.boot'),
+;     ['<F2>'] = map_expr('s.meter'),
+;   }
+; } 
+; -- You gotta run :SCNvimGenerateAssets for this first
+; -- require("luasnip").add_snippets("supercollider", require("scnvim/utils").get_snippets())

home/profiles/nvim/config/fnl/conf/plugins.fnl

···
+(local nvim (require :lib/nvim))
+(local navic (require :nvim-navic))
+
+(import-macros {: do-req } :lib/macros)
+
+(let  [lualine (require :lualine)]
+  (lualine.setup {:options {:theme "ayu"}
+                  :sections {; :lualine_c [:filename (fn []
+                             ;                         (let [lspsaga (require :lspsaga.symbol.winbar)]
+                             ;                           (lspsaga.get_bar))
+                             :lualine_y [(fn []
+                                           (var msg "No Active LSP")
+                                           (let [buf_ft (vim.api.nvim_buf_get_option 0 "filetype")
+                                                 clients (vim.lsp.get_active_clients)]
+                                             (each [_ client (ipairs clients)]
+                                               (let [filetypes (. client :config :filetypes)]
+                                                 (if (and filetypes (vim.fn.index filetypes buf_ft)) (set msg client.name))))
+                                             msg))]
+                             :lualine_x [:filetype]}}))
+
+(require :neo-tree)
+(do-req :gitsigns :setup)
+(do-req :marks :setup)
+; (do-req :mini.pairs :setup)
+(do-req :mini.diff :setup)
+(do-req :mini.ai :setup)
+(do-req :mini.surround :setup {:mappings {:add "ys"
+                                          :delete "ds"
+                                          :replace "cs"}})
+(do-req :todo-comments :setup)
+(do-req :ibl :setup {:scope {:exclude {:language ["fennel" "clojure" "janet"]}}})
+
+(do-req :nvim-treesitter.configs :setup {:highlight {:enable true}
+                                         :textobjects {:enable true}
+                                         :indent {:enable true}})
+(do-req :treesitter-context :setup {:max_lines 5})
+
+(do-req :auto-session :setup {:log_level "info"
+                              :auto_session_suppress_dirs ["~/"]})
+(nvim.opt :sessionoptions "blank,buffers,curdir,folds,help,tabpages,winsize,winpos,terminal,localoptions")
+
+(do-req :aerial :setup {}) ;{:on_attach (fn [bufnr] 
+                       ;              (do 
+                       ;                (vim.keymap.set "n" "{" "<cmd>AerialPrev<CR>" { :buffer bufnr})
+                       ;                (vim.keymap.set "n" "}" "<cmd>AerialNext<CR>" { :buffer bufnr}))
+
+(do-req :zk :setup)

home/profiles/nvim/config/fnl/conf/plugins/cmp.fnl

···
+(local cmp (require :cmp))
+
+(fn has-words-before []
+  (let [(line col) (unpack (vim.api.nvim_win_get_cursor 0))
+        cur-line (. (vim.api.nvim_buf_get_lines 0
+                                          (- line 1)
+                                          line
+                                          true
+                      1))]
+    (and (not= col 0)
+         (= (: (: cur-line :sub col col) :match "%s")
+            nil))))
+
+(let [lspkind (require :lspkind)]
+  (cmp.setup {:formatting {:format (lspkind.cmp_format {:mode "symbol_text"
+                                                        :maxwidth 50})
+                           :show_labelDetails true}
+              :snippet {:expand (fn [args] (vim.snippet.expand args.body))}
+              :sources [{:name "buffer"}      {:name "nvim_lsp"} 
+                        {:name "look"}        {:name "path"}
+                        {:name "calc"}        {:name "spell"}
+                        {:name "tags"}]
+              :mapping {"<C-d>" (cmp.mapping.scroll_docs -4)
+                        "<C-u>" (cmp.mapping.scroll_docs 4)
+                        "<C-g>" (cmp.mapping.close)
+                        "<CR>" (cmp.mapping.confirm {:select true})
+                        "<Tab>" (cmp.mapping (fn [fallback]
+                                               (if (cmp.visible) (cmp.select_next_item)
+                                                   (has-words-before) (cmp.complete)
+                                                   (fallback))) 
+                                             [:i :s])
+                        "<S-Tab>" (cmp.mapping (fn [fallback]
+                                                 (if (cmp.visible) (cmp.select_prev_item)
+                                                     (fallback))) 
+                                               [:i :s])}}))

home/profiles/nvim/config/fnl/conf/plugins/kitaab.fnl

···
+; Kitaab is why I'm so tied to vim. 
+; If only I could find a nice notes editor... 
+
+(local nvim (require :lib/nvim))
+
+(import-macros {: do-req } :lib/macros)
+
+(nvim.g :vimwiki_list [{:path "~/kitaab/vimwiki" 
+                        :auto_tags 1 
+                        :auto_diary_index 1 
+                        :auto_generate_links 0 
+                        :nested_syntaxes {:python "python" 
+                                          :c++ "cpp" 
+                                          :nix "nix" 
+                                          :bash "sh"}}])
+(nvim.g :zettel_format "%y%m%d-%H%M")
+
+;  Custom functions
+(fn update_date []
+  (var written false)
+  (let [time (os.date "%Y-%m-%d %H:%M")
+        message (.. "%update " time)
+        lines (vim.api.nvim_buf_get_lines 0 0 4 false)]
+    (each [index line (ipairs lines)]
+      (if (and (= (length line) 0) (not written))
+        (do 
+          (vim.api.nvim_buf_set_lines 0 (- index 1) index false [message ""])
+          (set written true)))
+      (if (and (= index 4) (not written))
+        (vim.api.nvim_buf_set_lines 0 3 index false [message])))))
+
+; Custom function for inserting links through telescope grep_search
+; Visual mode too!
+
+(vim.api.nvim_create_autocmd "BufWritePre" {:pattern ["*.wiki"]
+                                            :callback update_date})
+
+(do-req :hologram :setup {:auto_display false})

home/profiles/nvim/config/fnl/lib/macros.fnl

···
+;; fennel-ls: macro-file
+
+(fn do-req [mod key ...]
+  `(let [name# (require ,mod)
+         fun# (. name# ,key)]
+     (fun# ,...)))
+
+{: do-req}

home/profiles/nvim/config/fnl/lib/nvim.fnl

···
+(fn autocmd [events opts]
+  "Create autocommand"
+  (vim.api.nvim_create_autocmd events opts))
+
+(fn clear-autocmds [opts]
+  "Clear autocommands"
+  (vim.api.nvim_clear_autocmds opts))
+
+(fn augroup [name ?opts]
+  "Create autocommand group"
+  (vim.api.nvim_create_augroup name (or ?opts {})))
+
+(fn keymap [mode lhs rhs ?opts]
+  "Sets a global mapping for the given mode.
+  Ex: `(keymap [:n :i] ...)`"
+  (let [string-mode (table.concat mode)]
+    (vim.api.nvim_set_keymap string-mode lhs rhs (or ?opts {}))))
+
+(fn opt [key value]
+  "Set a vim option"
+  (tset vim.opt key value))
+
+(fn g [key value]
+  "Set a vim global"
+  (tset vim.g key value))
+
+(fn colorscheme [name]
+  "Set the current colorscheme"
+  (vim.cmd (.. "colorscheme " name)))
+
+{: autocmd
+ : clear-autocmds
+ : augroup
+ : keymap
+ : opt
+ : g
+ : colorscheme}

home/profiles/nvim/config/init.lua

···
+if pcall(require, "hotpot") then
+  -- Setup hotpot.nvim
+  require("hotpot").setup({
+    provide_require_fennel = true,
+    -- show fennel compiler results in when editing fennel files
+    enable_hotpot_diagnostics = true,
+    compiler = {
+      -- options passed to fennel.compile for modules, defaults to {}
+      modules = {
+        -- not default but recommended, align lua lines with fnl source
+        -- for more debuggable errors, but less readable lua.
+        correlate = true
+      },
+      macros = {
+        -- allow macros to access vim global, needed for nyoom modules
+        env = "_COMPILER",
+        compilerEnv = _G,
+        allowGlobals = true,
+      },
+    }
+  })
+  -- Import neovim configuration
+  require("conf")
+else
+  print("Unable to require hotpot")
+end

home/profiles/nvim/default.nix

···
 { pkgs, ... }:
+# TODO Need to find a solution to have my own packages?
+# Or at least update to recent versions of the packages I do use in nixpkgs
 {
   home.sessionVariables.EDITOR = "nvim";
   home.shellAliases = {
+    vim = "nvim";
     k = "cd ~/kitaab/vimwiki; vim -c :VimwikiIndex; cd $OLDPWD";
+    # kitaab zettel
+    kz = "cd ~/kitaab/vimwiki; vim -c :VimwikiIndex -c :ZettelNew; cd $OLDPWD";
+    # kitaab get by tagged
+    kt =
+      "cd /home/anish/kitaab/vimwiki; eza *_index.wiki | fzf --preview 'bat --style=numbers --color=always --terminal-width -1 ./{}';cd $OLDPWD";
   };
 
+  home.file.".config/nvim".source = ./config;
+
   programs.neovim = {
     enable = true;
-    package = pkgs.unstable.neovim-unwrapped;
     extraPackages = with pkgs; [
-      # used for Cody
-      nodejs
+      # used to compile tree-sitter grammar
+      # python-with-my-packages
+      # nodejs
+      # clojure-lsp
+      # clojure
+      # clj-kondo
+      terraform-lsp
+      nil
+      gopls
+      gcc
+      shellcheck
+      shfmt
+      proselint
+      nixfmt
+      # statix
+      # nodePackages.typescript
+      # nodePackages.typescript-language-server
+      # luajitPackages.lua-lsp
+      fennel-ls
+      unstable.starpls-bin
     ];
 
-    vimAlias = true;
+    plugins = with pkgs.unstable.vimPlugins;
+      [
+        #hotpot
+        hotpot-nvim
+        nvim-navic
+        # ui
+        lualine-nvim
+        neo-tree-nvim
+        fzf-vim
+        vim-devicons
+        nvim-web-devicons
+        telescope-nvim
+        plenary-nvim
+        FTerm-nvim
+        barbar-nvim
+        neovim-ayu
+        rainbow_parentheses-vim
+        auto-session
+        which-key-nvim
+        aerial-nvim
+        todo-comments-nvim
+        indent-blankline-nvim
+        nvim-parinfer
+
+        # Tree sitter
+        (nvim-treesitter.withPlugins (p: [
+          p.nix
+          p.clojure
+          p.fennel
+          p.lua
+          p.html
+          p.css
+          p.regex
+          p.supercollider
+          p.beancount
+          p.markdown_inline
+          p.markdown
+          p.glsl
+          p.yaml
+          p.toml
+          p.dockerfile
+          p.json
+          p.go
+          p.svelte
+          p.javascript
+          p.janet-simple
+          p.starlark
+        ]))
+        nvim-treesitter-context
+        nvim-treesitter-textobjects
+
+        # TODO
+        undotree
+        marks-nvim
+
+        # language
+        vim-nix
+        emmet-vim
+        csv-vim
+        direnv-vim
+        vim-svelte
+        # conjure
+
+        # kitaab stuff
+        vimwiki
+        vim-zettel
+        hologram-nvim
+        zk-nvim
+
+        # lsp stuff
+        nvim-lspconfig
+        nvim-cmp
+        cmp-nvim-lsp
+        cmp-treesitter
+        # cmp-conjure
+        cmp-buffer
+        cmp-path
+        cmp-spell
+        lspkind-nvim
+        conform-nvim
+        none-ls-nvim
+        mini-nvim
+        # nvim-lspfuzzy
+
+        # git stuff
+        vim-fugitive
+        gitsigns-nvim
+        fzf-checkout-vim
+
+        # Clojure stuff
+        # conjure
+        vim-sexp
+        vim-sexp-mappings-for-regular-people
+        fennel-vim
+
+        # nvim-luapad
+        # scnvim
+        flash-nvim
+        vim-beancount
+      ] # ++ [ pkgs.vimPlugins.vim-tidal ];
+    # withPython3 = true;
+    # extraPython3Packages = pkgs: with pkgs; [ tasklib six ];
+    # vimAlias = true;
   };
 }
 

home/profiles/task/taskrc

···
 report.every.labels=ID,Active,Deps,P,Project,Tag,Recur,S,Due,Until,Description
 report.every.columns=id,start.age,depends,priority,project,tags,recur,scheduled.countdown,due.relative,until.remaining,description
 
+report.poms.filter=(status:pending -idea -backlog -BLOCKED)
+report.poms.labels=UUID,ID,Project,Tag,Description
+report.poms.columns=uuid,id,project,tags,description
+report.poms.sort=start+,urgency+
+
 # Urgency
 urgency.user.project.wait.coefficient=-10.0
 urgency.user.project.craft.coefficient=1.9

hosts/box/configuration.nix

···
   sound.enable = false;
 
   programs.gnupg.agent.enable = true;
-  programs.gnupg.agent.pinentryFlavor = "curses";
+  programs.gnupg.agent.pinentryPackage = pkgs.pinentry-curses;
   programs.gnupg.agent.enableSSHSupport = true;
 
   # This value determines the NixOS release with which your system is to be

hosts/box/default.nix

···
     ../profiles/taskd
     ../profiles/shaarli
     ../profiles/dns
-    ../profiles/monitoring
+    # ../profiles/monitoring
     ../profiles/nfs
     ../profiles/gonic
-    ../profiles/headphones
+    # ../profiles/headphones # TODO broken on 23.11, see: https://github.com/rembo10/headphones/issues/3320
     ../profiles/radicale
-    ../profiles/seafile
+    # ../profiles/seafile # waiting for https://github.com/NixOS/nixpkgs/pull/249523 to be merged
     ../profiles/syncthing
     ../profiles/dhyan
     ../profiles/calibre
···
     ../profiles/grasp
     # ../profiles/archivebox
     # ../profiles/woodpecker-agent
-    ../profiles/jellyfin
+    # ../profiles/jellyfin
     ../profiles/ulogger-server
-    ../profiles/photoprism
+    ../profiles/photoprism # Replace with immich
+    ../profiles/gpodder
+    #../profiles/postgres_upgrade_script
   ];
 
   # Backups

hosts/curve/configuration.nix

···
 
   sound.enable = true;
 
-  services.xserver.libinput.enable = true;
+  services.libinput.enable = true;
 }

hosts/curve/default.nix

···
-{ self, pkgs, ... }:
-{
+{ self, pkgs, ... }: {
   imports = [
     ./configuration.nix
     ../users/anish
···
     # ../profiles/mount-mossnet
   ];
 
+  # temporarily allow ssh access for work, to be able to do deploy new services
+  services.openssh = {
+    enable = true;
+    settings.PasswordAuthentication = false;
+    settings.PermitRootLogin = "no";
+  };
+
   # import profiling tools
   programs.systemtap.enable = true;
 
+  virtualisation.docker.enable = true;
+  virtualisation.docker.storageDriver = "btrfs";
+  environment.systemPackages = with pkgs; [ docker-compose ];
+
   # Speed up boot by removing dependency on network 
   systemd = {
-    targets.network-online.wantedBy = pkgs.lib.mkForce [ ]; # Normally ["multi-user.target"]
-    services.NetworkManager-wait-online.wantedBy = pkgs.lib.mkForce [ ]; # Normally ["network-online.target"]
+    targets.network-online.wantedBy =
+      pkgs.lib.mkForce [ ]; # Normally ["multi-user.target"]
+    services.NetworkManager-wait-online.wantedBy =
+      pkgs.lib.mkForce [ ]; # Normally ["network-online.target"]
   };
 
   programs.gnupg.agent.enable = true;
-  programs.gnupg.agent.pinentryFlavor = "gnome3";
+  programs.gnupg.agent.pinentryPackage = pkgs.pinentry-gnome3;
 
   fileSystems."/mnt/ftp" = {
     device = "192.168.1.240:/home/ftp";
···
 
   # lazy enable of ports necessary for KDE connect which is installed via cli home profile (for some reason?)
   networking.firewall = {
-    allowedTCPPortRanges = [{ from = 1714; to = 1764; }];
-    allowedUDPPortRanges = [{ from = 1714; to = 1764; }];
+    allowedTCPPorts = [ 22 ]; # allow ssh
+    allowedTCPPortRanges = [{
+      from = 1714;
+      to = 1764;
+    }];
+    allowedUDPPortRanges = [{
+      from = 1714;
+      to = 1764;
+    }];
   };
 
   age.secrets.curve-wg.file = "${self}/secrets/curve-wg.age";
···
   mossnet.backup = {
     enable = true;
     name = "curve";
-    paths = [
-      "/home/anish/usr"
-      "/home/anish/.ssh"
-    ];
+    paths = [ "/home/anish/usr" "/home/anish/.ssh" ];
   };
 
   # enable adb 
···
   #virtualisation.docker.enable = true;
   boot.blacklistedKernelModules = [ "qcserial" ];
   # Used for packer Capsul
-  users.users.anish.extraGroups = [ "adbusers" "wheel" "plugdev" "libvertd" ];
+  users.users.anish.extraGroups =
+    [ "adbusers" "wheel" "plugdev" "libvertd" "docker" ];
   virtualisation.libvirtd.enable = true;
   hardware.keyboard.zsa.enable = true;
   services.udev.extraRules = ''

hosts/curve/hardware-configuration.nix

···
 
 {
   imports =
-    [
-      (modulesPath + "/installer/scan/not-detected.nix")
+    [ (modulesPath + "/installer/scan/not-detected.nix")
     ];
 
-  boot.initrd.availableKernelModules = [ "xhci_pci" "ahci" "usb_storage" "usbhid" "sd_mod" "rtsx_pci_sdmmc" ];
+  boot.initrd.availableKernelModules = [ "xhci_pci" "ahci" "usbhid" "usb_storage" "sd_mod" "rtsx_pci_sdmmc" ];
   boot.initrd.kernelModules = [ "dm-snapshot" ];
   boot.kernelModules = [ "kvm-intel" ];
   boot.extraModulePackages = [ ];
 
-  fileSystems."/boot" =
-    {
-      device = "/dev/disk/by-uuid/2C41-3DAA";
-      fsType = "vfat";
-    };
-
   fileSystems."/" =
-    {
-      device = "/dev/disk/by-uuid/a4ae2855-10b9-49f3-adb0-acd82b74eeb9";
+    { device = "/dev/disk/by-uuid/e1268753-4f18-4e6f-8edb-d4724ad8eb4a";
       fsType = "btrfs";
       options = [ "subvol=root" ];
     };
 
   fileSystems."/home" =
-    {
-      device = "/dev/disk/by-uuid/a4ae2855-10b9-49f3-adb0-acd82b74eeb9";
+    { device = "/dev/disk/by-uuid/e1268753-4f18-4e6f-8edb-d4724ad8eb4a";
       fsType = "btrfs";
       options = [ "subvol=home" ];
     };
 
+  fileSystems."/boot" =
+    { device = "/dev/disk/by-uuid/8244-A184";
+      fsType = "vfat";
+    };
+
   swapDevices =
-    [{ device = "/dev/disk/by-uuid/23658926-6ffa-42dc-8915-a6479c385e0b"; }];
+    [ { device = "/dev/disk/by-uuid/e220fea6-cf3b-4687-bfe1-9cf6d3ba57f7"; }
+    ];
 
   # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
   # (the default) this is the recommended approach. When using systemd-networkd it's
···
   # networking.interfaces.wlp3s0.useDHCP = lib.mkDefault true;
 
   nixpkgs.hostPlatform = lib.mkDefault "x86_64-linux";
-  powerManagement.cpuFreqGovernor = lib.mkDefault "powersave";
-  # hardware.cpu.intel.updateMicrocode = lib.mkDefault config.hardware.enableRedistributableFirmware;
+  hardware.cpu.intel.updateMicrocode = lib.mkDefault config.hardware.enableRedistributableFirmware;
 }

hosts/development/mirlo/docker-compose.nix

···
+# Auto-generated using compose2nix v0.1.6.
+{ pkgs, lib, ... }:
+
+{
+  # Runtime
+  virtualisation.podman = {
+    enable = true;
+    autoPrune.enable = true;
+    dockerCompat = true;
+    defaultNetwork.settings = {
+      # Required for container networking to be able to use names.
+      dns_enabled = true;
+    };
+  };
+  virtualisation.oci-containers.backend = "podman";
+
+  # Containers
+  virtualisation.oci-containers.containers."blackbird-api" = {
+    image = "";
+    environment = {
+      API_DOMAIN = "http://localhost:3000";
+      DATABASE_URL = "postgresql://nomads:nomads@pgsql:5432/nomads?schema=public";
+      JWT_SECRET = "test1234";
+      MEDIA_LOCATION = "./data/media/";
+      MEDIA_LOCATION_DOWNLOAD_CACHE = "/data/media/downloadCache";
+      MEDIA_LOCATION_INCOMING = "/data/media/incoming";
+      MINIO_HOST = "minio";
+      MINIO_PORT = "9000";
+      MINIO_ROOT_PASSWORD = "password";
+      MINIO_ROOT_USER = "blackbird";
+      NODE_ENV = "development";
+      PORT = "3000";
+      POSTGRES_LOCAL_MACHINE_PORT = "5434";
+      POSTGRES_PASSWORD = "nomads";
+      POSTGRES_USER = "nomads";
+      REACT_APP_API_DOMAIN = "http://localhost:3000";
+      REDIS_HOST = "redis";
+      REDIS_PASSWORD = "password";
+      REDIS_PORT = "6379";
+      REFRESH_TOKEN_SECRET = "test1234";
+      STATIC_MEDIA_HOST = "http://localhost:3000";
+      STRIPE_KEY = "";
+    };
+    volumes = [
+      "/home/anish/.ssh:/root/.ssh:rw"
+      "/home/anish/usr/mirlo:/var/www/api:rw"
+      "/home/anish/usr/mirlo/data/media/downloadCache:/data/media/downloadCache:rw"
+      "/home/anish/usr/mirlo/data/media/incoming:/data/media/incoming:rw"
+    ];
+    ports = [
+      "3000:3000/tcp"
+    ];
+    cmd = [ "/bin/sh" "-c" "yarn && yarn migrate:deploy && yarn dev:api" ];
+    dependsOn = [
+      "blackbird-minio"
+      "blackbird-pgsql"
+      "blackbird-redis"
+    ];
+    log-driver = "journald";
+    extraOptions = [
+      "--network-alias=api"
+      "--network=mirlo-api-network"
+      "--network=mirlo-redis-network"
+    ];
+  };
+  systemd.services."podman-blackbird-api" = {
+    serviceConfig = {
+      Restart = lib.mkOverride 500 "always";
+    };
+    after = [
+      "podman-network-mirlo-api-network.service"
+      "podman-network-mirlo-redis-network.service"
+    ];
+    requires = [
+      "podman-network-mirlo-api-network.service"
+      "podman-network-mirlo-redis-network.service"
+    ];
+    partOf = [
+      "podman-compose-mirlo-root.target"
+    ];
+    unitConfig.UpheldBy = [
+      "podman-blackbird-minio.service"
+      "podman-blackbird-pgsql.service"
+      "podman-blackbird-redis.service"
+    ];
+    wantedBy = [
+      "podman-compose-mirlo-root.target"
+    ];
+  };
+  virtualisation.oci-containers.containers."blackbird-background" = {
+    image = "";
+    environment = {
+      API_DOMAIN = "http://localhost:3000";
+      DATABASE_URL = "postgresql://nomads:nomads@pgsql:5432/nomads?schema=public";
+      JWT_SECRET = "test1234";
+      MEDIA_LOCATION = "./data/media/";
+      MEDIA_LOCATION_DOWNLOAD_CACHE = "/data/media/downloadCache";
+      MEDIA_LOCATION_INCOMING = "/data/media/incoming";
+      MINIO_HOST = "minio";
+      MINIO_PORT = "9000";
+      MINIO_ROOT_PASSWORD = "password";
+      MINIO_ROOT_USER = "blackbird";
+      NODE_ENV = "development";
+      PORT = "3000";
+      POSTGRES_LOCAL_MACHINE_PORT = "5434";
+      POSTGRES_PASSWORD = "nomads";
+      POSTGRES_USER = "nomads";
+      REACT_APP_API_DOMAIN = "http://localhost:3000";
+      REDIS_HOST = "redis";
+      REDIS_PASSWORD = "password";
+      REDIS_PORT = "6379";
+      REFRESH_TOKEN_SECRET = "test1234";
+      STATIC_MEDIA_HOST = "http://localhost:3000";
+      STRIPE_KEY = "";
+    };
+    volumes = [
+      "/home/anish/.ssh:/root/.ssh:rw"
+      "/home/anish/usr/mirlo:/var/www/api:rw"
+      "/home/anish/usr/mirlo/data/media/processing:/data/media/processing:rw"
+    ];
+    dependsOn = [
+      "blackbird-api"
+      "blackbird-minio"
+      "blackbird-pgsql"
+      "blackbird-redis"
+    ];
+    log-driver = "journald";
+    extraOptions = [
+      "--network-alias=background"
+      "--network=mirlo-api-network"
+      "--network=mirlo-redis-network"
+    ];
+  };
+  systemd.services."podman-blackbird-background" = {
+    serviceConfig = {
+      Restart = lib.mkOverride 500 "always";
+    };
+    after = [
+      "podman-network-mirlo-api-network.service"
+      "podman-network-mirlo-redis-network.service"
+    ];
+    requires = [
+      "podman-network-mirlo-api-network.service"
+      "podman-network-mirlo-redis-network.service"
+    ];
+    partOf = [
+      "podman-compose-mirlo-root.target"
+    ];
+    unitConfig.UpheldBy = [
+      "podman-blackbird-api.service"
+      "podman-blackbird-minio.service"
+      "podman-blackbird-pgsql.service"
+      "podman-blackbird-redis.service"
+    ];
+    wantedBy = [
+      "podman-compose-mirlo-root.target"
+    ];
+  };
+  virtualisation.oci-containers.containers."blackbird-minio" = {
+    image = "minio/minio";
+    environment = {
+      API_DOMAIN = "http://localhost:3000";
+      DATABASE_URL = "postgresql://nomads:nomads@pgsql:5432/nomads?schema=public";
+      JWT_SECRET = "test1234";
+      MEDIA_LOCATION = "./data/media/";
+      MEDIA_LOCATION_DOWNLOAD_CACHE = "/data/media/downloadCache";
+      MEDIA_LOCATION_INCOMING = "/data/media/incoming";
+      MINIO_HOST = "minio";
+      MINIO_PORT = "9000";
+      MINIO_ROOT_PASSWORD = "password";
+      MINIO_ROOT_USER = "blackbird";
+      PORT = "3000";
+      POSTGRES_LOCAL_MACHINE_PORT = "5434";
+      POSTGRES_PASSWORD = "nomads";
+      POSTGRES_USER = "nomads";
+      REACT_APP_API_DOMAIN = "http://localhost:3000";
+      REDIS_HOST = "redis";
+      REDIS_PASSWORD = "password";
+      REDIS_PORT = "6379";
+      REFRESH_TOKEN_SECRET = "test1234";
+      STATIC_MEDIA_HOST = "http://localhost:3000";
+      STRIPE_KEY = "";
+    };
+    volumes = [
+      "/home/anish/usr/mirlo/data/minio_storage:/data:rw"
+    ];
+    ports = [
+      "9000:9000/tcp"
+      "9001:9001/tcp"
+    ];
+    cmd = [ "server" "--console-address" ":9001" "/data" ];
+    log-driver = "journald";
+    extraOptions = [
+      "--network-alias=minio"
+      "--network=mirlo-api-network:alias=minio"
+    ];
+  };
+  systemd.services."podman-blackbird-minio" = {
+    serviceConfig = {
+      Restart = lib.mkOverride 500 "no";
+    };
+    after = [
+      "podman-network-mirlo-api-network.service"
+    ];
+    requires = [
+      "podman-network-mirlo-api-network.service"
+    ];
+    partOf = [
+      "podman-compose-mirlo-root.target"
+    ];
+    wantedBy = [
+      "podman-compose-mirlo-root.target"
+    ];
+  };
+  virtualisation.oci-containers.containers."blackbird-pgsql" = {
+    image = "postgres:14-alpine";
+    environment = {
+      API_DOMAIN = "http://localhost:3000";
+      DATABASE_URL = "postgresql://nomads:nomads@pgsql:5432/nomads?schema=public";
+      JWT_SECRET = "test1234";
+      MEDIA_LOCATION = "./data/media/";
+      MEDIA_LOCATION_DOWNLOAD_CACHE = "/data/media/downloadCache";
+      MEDIA_LOCATION_INCOMING = "/data/media/incoming";
+      MINIO_HOST = "minio";
+      MINIO_PORT = "9000";
+      MINIO_ROOT_PASSWORD = "password";
+      MINIO_ROOT_USER = "blackbird";
+      PORT = "3000";
+      POSTGRES_LOCAL_MACHINE_PORT = "5434";
+      POSTGRES_PASSWORD = "nomads";
+      POSTGRES_USER = "nomads";
+      REACT_APP_API_DOMAIN = "http://localhost:3000";
+      REDIS_HOST = "redis";
+      REDIS_PASSWORD = "password";
+      REDIS_PORT = "6379";
+      REFRESH_TOKEN_SECRET = "test1234";
+      STATIC_MEDIA_HOST = "http://localhost:3000";
+      STRIPE_KEY = "";
+    };
+    volumes = [
+      "/home/anish/usr/mirlo/data/pgsql:/var/lib/postgresql/data:rw"
+      "/home/anish/usr/mirlo/data/pgsql_backups:/backups:rw"
+    ];
+    ports = [
+      "5432:5432/tcp"
+    ];
+    log-driver = "journald";
+    extraOptions = [
+      "--network-alias=pgsql"
+      "--network=mirlo-api-network:alias=pgsql"
+    ];
+  };
+  systemd.services."podman-blackbird-pgsql" = {
+    serviceConfig = {
+      Restart = lib.mkOverride 500 "no";
+    };
+    after = [
+      "podman-network-mirlo-api-network.service"
+    ];
+    requires = [
+      "podman-network-mirlo-api-network.service"
+    ];
+    partOf = [
+      "podman-compose-mirlo-root.target"
+    ];
+    wantedBy = [
+      "podman-compose-mirlo-root.target"
+    ];
+  };
+  virtualisation.oci-containers.containers."blackbird-redis" = {
+    image = "redis";
+    ports = [
+      "6379:6379/tcp"
+    ];
+    cmd = [ "redis-server" "--appendonly" "yes" "--requirepass " ];
+    log-driver = "journald";
+    extraOptions = [
+      "--network-alias=redis"
+      "--network=mirlo-redis-network"
+    ];
+  };
+  systemd.services."podman-blackbird-redis" = {
+    serviceConfig = {
+      Restart = lib.mkOverride 500 "always";
+    };
+    after = [
+      "podman-network-mirlo-redis-network.service"
+    ];
+    requires = [
+      "podman-network-mirlo-redis-network.service"
+    ];
+    partOf = [
+      "podman-compose-mirlo-root.target"
+    ];
+    wantedBy = [
+      "podman-compose-mirlo-root.target"
+    ];
+  };
+
+  # Networks
+  systemd.services."podman-network-mirlo-api-network" = {
+    path = [ pkgs.podman ];
+    serviceConfig = {
+      Type = "oneshot";
+      RemainAfterExit = true;
+      ExecStop = "${pkgs.podman}/bin/podman network rm -f mirlo-api-network";
+    };
+    script = ''
+      podman network inspect mirlo-api-network || podman network create mirlo-api-network --opt isolate=true
+    '';
+    partOf = [ "podman-compose-mirlo-root.target" ];
+    wantedBy = [ "podman-compose-mirlo-root.target" ];
+  };
+  systemd.services."podman-network-mirlo-redis-network" = {
+    path = [ pkgs.podman ];
+    serviceConfig = {
+      Type = "oneshot";
+      RemainAfterExit = true;
+      ExecStop = "${pkgs.podman}/bin/podman network rm -f mirlo-redis-network";
+    };
+    script = ''
+      podman network inspect mirlo-redis-network || podman network create mirlo-redis-network --opt isolate=true
+    '';
+    partOf = [ "podman-compose-mirlo-root.target" ];
+    wantedBy = [ "podman-compose-mirlo-root.target" ];
+  };
+
+  # Root service
+  # When started, this will automatically create all resources and start
+  # the containers. When stopped, this will teardown all resources.
+  systemd.targets."podman-compose-mirlo-root" = {
+    unitConfig = {
+      Description = "Root target generated by compose2nix.";
+    };
+    wantedBy = [ "multi-user.target" ];
+  };
+}

hosts/helix/default.nix

···
     # ../profiles/mount-mossnet
     ../profiles/freshrss
     ../profiles/microbin
+    ../profiles/site
+    
+    # ../profiles/postgres_upgrade_script
   ];
 
   # Capsul specific
···
     privateKeyFile = "/run/agenix/helix-wg";
   };
 
-  services.postgresql.package = pkgs.postgresql_11;
+  services.postgresql.package = pkgs.postgresql_15;
   services.postgresqlBackup = {
     # TODO needs working wireguard to box
     enable = false;
-    databases = [ "gitea" "freshrss" "woodpecker" ];
+    databases = [ "gitea" "freshrss"  ]; # "woodpecker"
     location = "/mnt/two/postgres";
   };
 
···
     paths = [
       "/var/lib/gitea"
       "/var/lib/freshrss"
-      "/var/lib/woodpecker"
+      # "/var/lib/woodpecker"
       "/var/lib/microbin"
     ];
 

hosts/lituus/hardware-configuration.nix

···
       fsType = "btrfs";
     };
 
-  fileSystems."/storage" =
-    { device = "/dev/disk/by-uuid/c2181608-cbb0-40ab-b62b-158cdc9b9300";
-      fsType = "btrfs";
-    };
-
   swapDevices = [ ];
 
   hardware.cpu.intel.updateMicrocode = lib.mkDefault config.hardware.enableRedistributableFirmware;

hosts/profiles/core/default.nix

···
   };
 
   environment.systemPackages = with pkgs; [
-    # pinentry_gnome
+    pinentry-gnome3
     cached-nix-shell
   ];
 

hosts/profiles/desktop/default.nix

···
     feh
     sxiv
     xkblayout-state
-    vcv-rack
     zathura
     calibre
     mpv
···
     rofi
     rofimoji
     rofi-calc
-    # eww
     obs-studio
     lightdm
     dunst
···
         night = 3700;
       };
     };
+    displayManager.defaultSession = "none+bspwm";
     xserver = {
       enable = false;
       xkb.layout = "us,dvorak";
       desktopManager.wallpaper.mode = "fill";
       desktopManager.gnome.enable = true;
       displayManager = {
-	# gdm.enable = true;
+        # gdm.enable = true;
         # defaultSession = "none+bspwm";
         sessionCommands = ''
           ${pkgs.xorg.xrdb}/bin/xrdb -merge <<EOF

hosts/profiles/dns/default.nix

···
     "tracks.mossnet.lan"
     "grasp.mossnet.lan"
     "photos.mossnet.lan"
+    "pod.mossnet.lan"
   ];
 
 in

hosts/profiles/finance/default.nix

···
   services.paperless = {
     enable = false;
     consumptionDirIsPublic = true;
-    extraConfig.PAPERLESS_AUTO_LOGIN_USERNAME = "admin";
+    settings.PAPERLESS_AUTO_LOGIN_USERNAME = "admin";
   };
 
   environment.systemPackages = [

hosts/profiles/freshrss/default.nix

···
 
   services.postgresql = {
     enable = true; # Ensure postgresql is enabled
-    authentication = ''
-      local freshrss all ident map=freshrss-users
-    '';
-    identMap = # Map the freshrss user to postgresql
-      ''
-        freshrss-users freshrss freshrss
-      '';
+    # authentication = ''
+    #   local freshrss all ident map=freshrss-users
+    # '';
+    # identMap = # Map the freshrss user to postgresql
+    #   ''
+    #     freshrss-users freshrss freshrss
+    #     freshrss-users postgres freshrss
+    #   '';
     ensureDatabases = [ "freshrss" ];
     ensureUsers = [{ 
       name = "freshrss"; 

hosts/profiles/gitea/default.nix

···
   age.secrets.gitea-dbpass.file = "${self}/secrets/gitea-dbpass.age";
   age.secrets.gitea-dbpass.owner = "gitea";
 
-  services.gitea = {
+  services.forgejo = {
     enable = true;
-    package = pkgs.forgejo;
-    appName = "Sealight Git Forge";
+    user = "gitea";
+    group = "gitea";
+    stateDir = "/var/lib/gitea";
     database = {
       type = "postgres";
+      user = "gitea";
+      name = "gitea";
       passwordFile = "/run/agenix/gitea-dbpass";
     };
     settings = {
+      DEFAULT.APP_NAME = "Sealight Git Forge";
       server = {
         DOMAIN = "git.sealight.xyz";
         ROOT_URL = "https://git.sealight.xyz";
···
       repository = {
         DEFAULT_BRANCH = "main";
       };
+      service.DISABLE_REGISTRATION = true;
       "markup.restructuredtext" = {
         ENABLED = true;
         FILE_EXTENSIONS = ".rst";
···
     };
   };
 
+  users.users.gitea = {
+    home = "/var/lib/gitea";
+    useDefaultShell = true;
+    group = "gitea";
+    isSystemUser = true;
+  };
+
+  users.groups.gitea = {};
+
   environment.systemPackages = [ pkgs.pandoc ];
   services.postgresql = {
     enable = true; # Ensure postgresql is enabled
-    authentication = ''
-      local gitea all ident map=gitea-users
-    '';
-    identMap = # Map the gitea user to postgresql
-      ''
-        gitea-users gitea gitea
-      '';
+    # authentication = ''
+    #   local gitea all ident map=gitea-users
+    # '';
+    # identMap = # Map the gitea user to postgresql
+    #   ''
+    #     gitea-users gitea gitea
+    #     gitea-users postgres gitea
+    #   '';
     ensureDatabases = [ "gitea" ];
     ensureUsers = [{ 
       name = "gitea"; 

hosts/profiles/gonic/default.nix

···
     music-path /mnt/two/music/
     podcast-path /data/podcasts
     cache-path /data/cache
+    playlists-path /data/playlists
   '';
-  mossnet.gonic.user = "headphones";
+  mossnet.gonic.user = "gonic";
   mossnet.gonic.group = "audio";
   networking.firewall.allowedTCPPorts = [ 4747 ];
+
+  users.users.gonic = {
+    # uid = config.ids.uids.headphones;
+    # isSystemUser = true;
+    group = "audio";
+    # home = "/var/lib/headphones";
+    createHome = true;
+  };
 }

hosts/profiles/gonic/module-gonic.nix

···
         Group = cfg.group;
         DevicePolicy = "closed";
         NoNewPrivileges = " yes";
-        PrivateTmp = "yes";
-        PrivateUsers = "yes";
         ProtectControlGroups = "yes";
         ProtectKernelModules = "yes";
         ProtectKernelTunables = "yes";
         RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-        RestrictNamespaces = "yes";
-        RestrictRealtime = "yes";
         SystemCallFilter = "~@clock @debug @module @mount @obsolete @privileged @reboot @setuid @swap";
         ReadWritePaths = dataFolder;
         StateDirectory = baseNameOf dataFolder;

hosts/profiles/gpodder/default.nix

···
+{
+  services.gpodder.enable = true;
+  networking.firewall.allowedTCPPorts = [ 3005 ];
+  services.nginx.virtualHosts."pod.mossnet.lan" = {
+    extraConfig = "client_max_body_size 20M;";
+
+    locations."/" = {
+      extraConfig = ''
+        proxy_pass http://localhost:3005/;
+        proxy_set_header    X-Forwarded-Proto $scheme;
+        proxy_set_header    X-Real-IP $remote_addr;
+        proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
+      '';
+    };
+  };
+}

hosts/profiles/headphones/default.nix

···
     enable = true;
     host = "0.0.0.0";
     port = 8181;
+    package = "${pkgs.unstable.headphones}";
     user = "headphones";
     group = "audio";
     dataDir = "/data/music";

hosts/profiles/matrix/mautrix-services.nix

···
       signal = {
         port = 29184;
         format = "mautrix-python";
-        package = pkgs.mautrix-signal;
+        package = pkgs.unstable.mautrix-signal;
         serviceConfig = {
           StateDirectory = [ "matrix-as-signal" "signald" ];
           SupplementaryGroups = [ "signald" ];

hosts/profiles/microbin/default.nix

···
 { config, lib, pkgs, ... }:
 {
   services.microbin.enable = true;
-  services.microbin.hostname = "bin.sealight.xyz";
-  services.microbin.port = 4949;
+  services.microbin.settings.PUBLIC_PATH = "bin.sealight.xyz"; 
+  services.microbin.settings.MICROBIN_PORT = 4949;
   networking.firewall.allowedTCPPorts = [ 4949 ];
   services.nginx.virtualHosts."bin.sealight.xyz" = {
     enableACME = true;

hosts/profiles/mossnet-hosts/default.nix

···
     192.168.1.240 tracks.mossnet.lan
     192.168.1.240 grasp.mossnet.lan
     192.168.1.240 photos.mossnet.lan
+    192.168.1.240 pod.mossnet.lan
   '';
   # 10.0.69.4 mossnet.lan
   #  10.0.69.4 links.mossnet.lan

hosts/profiles/music/default.nix

···
     orca-c
     supercollider
     dirt
-    sunvox
+    # sunvox
     vcv-rack
     lmms
     bespokesynth
···
     alsa.enable = true;
     alsa.support32Bit = false;
     pulse.enable = true;
-   jack.enable = true;
+    jack.enable = true;
     # Deprecated as of 23.05
     # config = {
     #   pipewire."context.properties"."default.clock.rate" = "48000";

hosts/profiles/postgres_upgrade_script/default.nix

···
       # TODO it's perhaps advisable to stop all services that depend on postgresql
       systemctl stop postgresql
 
-      # TODO replace `<new version>` with the psqlSchema here
       # The schema can be found by running:
-      # nix-instantiate '<nixpkgs>' --eval -A postgresql_14.psqlSchema
-      export NEWDATA="/var/lib/postgresql/<new version>"
+      # nix eval --raw nixpkgs#postgresql_15.psqlSchema
+      export NEWDATA="/var/lib/postgresql/15"
 
       # TODO specify the postgresql package you'd like to upgrade to
-      export NEWBIN="${pkgs.postgresql_14}/bin"
+      export NEWBIN="${pkgs.postgresql_15}/bin"
 
       export OLDDATA="${config.services.postgresql.dataDir}"
       export OLDBIN="${config.services.postgresql.package}/bin"

hosts/profiles/rss-bridge/default.nix

···
   services.rss-bridge = {
     enable = true;
     virtualHost = "bridge.sealight.xyz";
-    whitelist = [ "Facebook" "Bandcamp" "Twitter" "Telegram" "Instagram" "Reddit" ];
+    config.system.enabled_bridges = [ "Facebook" "Bandcamp" "Twitter" "Telegram" "Instagram" "Reddit" ];
   };
 
   services.nginx.virtualHosts."bridge.sealight.xyz".forceSSL = true;

hosts/profiles/sync/website/default.nix

···
     path = [
       pkgs.git
       pkgs.coreutils
-      pkgs.nixUnstable
+      pkgs.nixVersions.latest
       pkgs.openssh
       pkgs.deploy
     ];
···
       git add flake.lock
       git diff-index --quiet HEAD || git commit -m 'updating website' # if nothing, don't exit 1
       git push
-      deploy .#cube
+      deploy .#helix
       exit 0
     '';
     serviceConfig = {

hosts/profiles/ulogger-server/default.nix

···
     ensureDatabases = [ "ulogger" ];
     ensureUsers = [{
       name = "ulogger";
-      nsureDBOwnership = true;
+      ensureDBOwnership = true;
     }];
   };
 

hosts/profiles/wallabag/default.nix

···
 { self, pkgs, config, lib, ... }:
 
 {
-  # age.secrets.wallabag-password.file = "${self}/secrets/wallabag-password.age";
-  # age.secrets.wallabag-secret.file = "${self}/secrets/wallabag-secret.age";
-  # age.secrets.wallabag-password.owner = "wallabag";
-  # age.secrets.wallabag-secret.owner = "wallabag";
+  age.secrets.wallabag-password.file = "${self}/secrets/wallabag-password.age";
+  age.secrets.wallabag-secret.file = "${self}/secrets/wallabag-secret.age";
+  age.secrets.wallabag-password.owner = "wallabag";
+  age.secrets.wallabag-secret.owner = "wallabag";
   services.postgresql = {
     enable = true;
     package = pkgs.postgresql_15;
···
       }
     ];
     authentication = ''
-      local wallabag all md5
+      local wallabag all peer
     '';
   };
 
   services.wallabag = {
     enable = true;
-    hostName = "read.mossnet.lan";
-    package = pkgs.wallabag;
-    conf = ''
-      # This file is a "template" of what your parameters.yml file should look like
-      parameters:
-          database_driver: pdo_pgsql
-          database_host: localhost
-          database_port: ~
-          database_name: wallabag
-          database_user: wallabag
-          database_password: wallabag 
-          # For SQLite, database_path should be "%kernel.project_dir%/data/db/wallabag.sqlite"
-          database_path: ~
-          database_table_prefix: wallabag_
-          database_socket: null
-          # with PostgreSQL and SQLite, you must set "utf8"
-          database_charset: utf8
-
-          domain_name: http://read.mossnet.lan/
-          server_name: "mossnet wallabag instance"
-
-          mailer_dsn: null://
-          locale: en
-
-          # A secret key that's used to generate certain security-related tokens
-          secret: SAFGOECRIlfal89oe6u0(*^dsaaih961
-
-          # two factor stuff
-          twofactor_auth: false
-          twofactor_sender: [e-mail]
-
-          # fosuser stuff
-          fosuser_registration: false
-          fosuser_confirmation: true
-
-          # how long the access token should live in seconds for the API
-          fos_oauth_server_access_token_lifetime: 3600
-          # how long the refresh token should life in seconds for the API
-          fos_oauth_server_refresh_token_lifetime: 1209600
-
-          from_email: [e-mail]
-
-          rss_limit: 50
-
-          # RabbitMQ processing
-          rabbitmq_host: localhost
-          rabbitmq_port: 5672
-          rabbitmq_user: guest
-          rabbitmq_password: guest
-          rabbitmq_prefetch_count: 10
-
-          # Redis processing
-          redis_scheme: tcp
-          redis_host: localhost
-          redis_port: 6379
-          redis_path: null
-          redis_password: null
-
-          # sentry logging
-          sentry_dsn: ~
-    '';
+    domain = "read.mossnet.lan";
+    virtualHost.enable = true;
+    package = pkgs.my-wallabag;
+    # Systemd now defaults to /var/lib?
+    # dataDir = "/var/lib/wallabag";
+    parameters = {
+      "env(SECRET_FILE)" = config.age.secrets.wallabag-secret.path;
+      secret = "%env(file:resolve:SECRET_FILE)%";
+    };
   };
-  # networking.firewall.allowedTCPPorts = [ 8080 ];
 } 

hosts/profiles/wireguard-server/default.nix

···
         publicKey = "gcdq86hhEUlqF2chqYB/F8pALyAMNFvwLycxBoHuoDs=";
         allowedIPs = [ "10.0.69.5/32" ];
       }
-      # {
-      #   # hyperplane
-      #   publicKey = "";
-      #   allowedIPs = [ "10.0.69.6/32" ];
-      # }
+      {
+        # hyperplane
+        publicKey = "v+EUuM60yZLvBmdCG9GxfFAtSjS1VvbUWcyNb8emjDg=";
+        allowedIPs = [ "10.0.69.6/32" ];
+      }
+      {
+        # work
+        publicKey = "/gv66s8DfppCCjaEN/jlc8z95IhEWPgDumykqKEl0QU=";
+        allowedIPs = [ "10.0.69.7/32" ];
+      }
     ];
   };
 }

hosts/users/anish/default.nix

···
   programs.zsh.enable = true;
   users.users.anish = {
     description = "Personal user for Anish";
-    hashedPassword = "$y$j9T$y3DPt/dWaPE.gRazQqw1w0$1RMH5sl/Nu8kW3ZMywYCPRniHD/jF5qRh0VKrdJ.bV2";
+    hashedPassword =
+      "$y$j9T$y3DPt/dWaPE.gRazQqw1w0$1RMH5sl/Nu8kW3ZMywYCPRniHD/jF5qRh0VKrdJ.bV2";
     shell = pkgs.zsh;
     isNormalUser = true;
     extraGroups = [ "wheel" "audio" "networkmanager" "video" ];
     openssh.authorizedKeys.keys = [
       # Curve
       "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDM0Zvei46x/yZl/IeBCq6+IYQQ0avulzVyBysF9cPigZMCybWRV7IEU+E3k9t6JrbdbdGfJkcZIWmsWDdKS8W8mBnZpVoT0ffLynu8JQ/TKdGm4Qv6bgUeKNrGsNv0ZPs2CDaGSLj0oJfRF7Ko10tcLP0vW+yujrh+y6TH/vVzJioaV4TGvtCUpn+wEQah9ROwPQLUUofsSWdnRsDJ/gp37zXWs4l5wyjSKtP3O9RZUP7kBekbSqEgSXiTk0oUQSVqIWl9NDiP6onk/gSOjXsR/JPqsSN/XI/c/yj6gyY0f51Ru2D7iBxuMJIJcWV+rU6coIj+ULcQWLzt/7TI8jq5AOOzI/ll4zbL24Eo84Rz+TP9tvMMhDZ0VaMN22AJ8qQEjc5P09tWKsX7Jg39XelyV1jHXncE4yvIE9F4RSCHzWCeKeXakizQNuzSaxTxIExRFYHjNW5bR6+3MTGwVrEIXU+qML+0yFTR86MT+tdY5AreAJQLwbog79O1NupeXJE= anish@curve"
-      # Line
-      "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDtU2GMYjXj6RGO1+mwM4TDGOo0qrKLTL4Di8+QgDX0p5vUEsnE1PS9wnuqCmSu75U8g0XIAMtvtdYyGk1N+Bx01erAZpT8DLYtIXFCyaiN28PVu5T1D0T+TQ7xgIH1qenXZR2DOQdf6kpvKEfm7+7bWhCo0N/KFMpmReubyzHDQcq/1qQasxTL+YALQFOjwKqsOTBXbHwZ103AEAcQX4ftBFEOfVli4/1aKIK4dNSZYB7J9Htq707YnsEqo9RLAMh0aOTTYgTx9AoSUDeqGuh/AGkcB7NcS7EEtI6d5YUGylwZh/gF6hqE0jl8kn2m5jMKXL3CRohZvjifue8x/GIjpu5WRabUuhBEbrfTQQaC7taHnt5rvYCGzKZx09TexUzhuz2CL480DRoxSG+P+lCNm1dIg/EZrnGEzXCSr36PlOqS5t5gm8tPkzCmZf2wU15A3ZIYUPmnYLqsn4WmIV7rKmdqt2ctWELUXow3PPiZXBucP9P3xpsYEfF1SB2SGNc= u0_a139@localhost"
       # Box
       "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDKN8/SH55DBiwVoSnTU8k2Pen+wmovL9QaMyehxGEsJJv/8fzwsswGalD4C/4O51LOvdu4UKkZW5hG02uVSK+58p3UV3pOPyoqsu/aDeIsWsqmTeTzUrBIWOlNzcDKnohLz2oGC5YO+wyTJ9Iteq6aGJDjErsW7sG3h5lXCs551EmJNNGhtBQaaoytMNnWqSdlVjDNCijurH7WUpp40U/RjEp532l4rX6eIIj3jBKEFbhZkFSSjqbj4xM4SyFt+Jmigb1RMjsQjmpfY1vDtM84RcYfpTUte/T5w2dkD5H6kccmWnwKSJpm9wXfx4E7lR9APdUGnau2U1+XxiD3ytGl anish@box"
+      # Nix-on-droid line
+      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJOiXBPVvZAp1fY0a0Tupxj0Ml6MoA51lvqt/jAQq249 nix-on-droid@localhost"
+      # Work
+      "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC/vvh0i6+uAN0GWlK6ZfyTlc/AW54xe2CroUDsDSoGnFKeIUiSsWexobODlVakNhqwCKfsvUh6g+RdA8ZVcamATcYqxysP4X5fRksmAzRm5281O7ZBDHMB2BdcfHSTgiz7JvMRIQYWDlU8Ck6IL4wlN0b2GMUj9t/GeG37us8280rxpRNoIY7M27AJEZ7XNQhctBIVujxctVBgIMYmZiTwziU7ywJv4rNT5OAWvjRXSo1rkxdvx3VESv4y/mp8m7dEupZpIjIFsLs52+UG5LtadulUqtTWg05sCw8LEcmRhflgZSAvjw60RrKFCuWxc8+/Pmaw+zExeBMenqi0NzuTc3S3k2wCKVIZDh/0tlXzIwZ6WRqxDevUtEKfvbEFMXd8akhTfYs0dyszcFRevBxOBPbcKku+FK/HkdPLmEANvxYty3cv+Eipkz3c8JPJPvXNTXrjepXMm0LUKodO3c15hGogCOxUO38kykkyYnn+MxxHparoMfEr2+oHNpQoS5wA1G43ppqjVoRDgnhleu6ixwRkLZzphY3cnOd5jL9Ie5xIGbFWH1qSlQRdHBkHjuf85z7+QK8nFYAhmG1K3Vt3GNtF8LN1tYQkfwBJ/vsroMNzGPoq4PjVbqb80Eq+96cP89XKfU2/xw1g+p2lJDm/zC1WCjXVzf8NRwC7gqPavQ== [e-mail]"
     ];
   };
 }

install-yubikey.sh

···
 
 # Yubikey Setup
 SLOT=2
-ykpersonalize -"$SLOT" -ochal-resp -ochal-hmac
+# ykpersonalize -"$SLOT" -ochal-resp -ochal-hmac
 SALT_LENGTH=16
 salt="$(dd if=/dev/random bs=1 count=$SALT_LENGTH 2>/dev/null | rbtohex)"
 k_user=PASSWORDCHANGEMEPLAEASES 
···
   sound.enable = true;
   hardware.pulseaudio.enable = true;
 
-  services.xserver.libinput.enable = true;
+  services.libinput.enable = true;
 
   # Hmmm maybe somewhere else? 
   users.users.anish = {

modules/nixos/default.nix

···
   wireguard = import ./wireguard.nix;
   backup = import ./backup.nix;
   ulogger-server = import ./ulogger.nix;
-  # microbin = import ./microbin.nix; includide in 23.11
+  gpodder2go = import ./gpodder2go.nix;
+  # microbin = import ./microbin.nix; # includide in 23.11
 }

modules/nixos/gpodder2go.nix

···
+{ self, config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.gpodder;
+in
+{
+  options = {
+
+    services.gpodder = {
+      enable = mkEnableOption "A gpodder instance";
+
+      user = mkOption {
+        type = types.str;
+        default = "gpodder";
+        description = "User account under which gpodder runs.";
+      };
+
+      group = mkOption {
+        type = types.str;
+        default = "gpodder";
+        description = "Group account under which gpodder runs.";
+      };
+
+      hostname = mkOption {
+        type = types.str;
+        description = "Hostname of your gpodder service";
+      };
+
+      dataFolder = mkOption {
+        type = types.str;
+        default = "/var/lib/gpodder";
+        description = "State director";
+      };
+
+      VERIFIER_SECRET_KEY = mkOption {
+        type = types.str;
+        default = "satnheiycglsrcgaecrlufg";
+        description = "Verifer Secret";
+      };
+
+    };
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.gpodder = {
+      description = "gpodder2go A gpodder instance";
+      after = [ "remote-fs.target" "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.gpodder2go}/bin/gpodder2go serve";
+        Environment = [
+          "VERIFIER_SECRET_KEY=${cfg.VERIFIER_SECRET_KEY}"
+        ];
+        WorkingDirectory = cfg.dataFolder;
+        TimeoutStopSec = " 20 ";
+        KillMode = " process ";
+        RestartSec = " 10 ";
+        User = cfg.user;
+        Group = cfg.group;
+        DevicePolicy = " closed ";
+        NoNewPrivileges = " yes ";
+        PrivateTmp = " yes ";
+        PrivateUsers = " yes ";
+        ProtectControlGroups = " yes ";
+        ProtectKernelModules = " yes ";
+        ProtectKernelTunables = " yes ";
+        RestrictAddressFamilies = "
+          AF_UNIX
+          AF_INET
+          AF_INET6 ";
+        RestrictNamespaces = " yes ";
+        RestrictRealtime = " yes ";
+        SystemCallFilter = "~@clock @debug @module @mount @obsolete @privileged @reboot @setuid @swap";
+        ReadWritePaths = cfg.dataFolder;
+        StateDirectory = baseNameOf cfg.dataFolder;
+      };
+    };
+
+    users.users = optionalAttrs (cfg.user == "gpodder") ({
+      gpodder = {
+        description = "gpodder service user";
+        name = cfg.user;
+        group = cfg.group;
+        isSystemUser = true;
+      };
+    });
+
+    users.groups = optionalAttrs (cfg.group == "gpodder") ({
+      gpodder = { };
+    });
+
+    # systemd.services.gpodder-install = {
+    #   description = "gpodder install service";
+    #   wantedBy = [ "multi-user.target" ];
+    #   before = [ "gpodder.service" ];
+    #   path = with pkgs; [ gpodder2go ];
+
+    #   serviceConfig = {
+    #     User = cfg.user;
+    #     Type = "oneshot";
+    #     CacheDirectory = "gpodder";
+    #     # Stores sessions.
+    #     CacheDirectoryMode = "700";
+    #     ConfigurationDirectory = "gpodder";
+    #     LogsDirectory = "gpodder";
+    #     StateDirectory = "gpodder";
+    #   };
+
+    #   script = ''
+    #   if [ ! -f "${cfg.dataFolder}/installed" ]; then
+    #     ${pkgs.gpodder2go}/bin/gpodder2go init
+    #     touch "${cfg.dataFolder}/installed"
+    #   fi
+    # '';
+    # };
+  };
+}
+

modules/nixos/wallabag.nix

···
-{ config, options, lib, pkgs, ... }:
-
-with lib;
+{ config, lib, pkgs, ... }:
 let
-  cfg = config.services.wallabag;
+  # Based on https://github.com/wallabag/wallabag/blob/2.6.6/app/config/parameters.yml.dist
+  settings = {
+    database_driver = "${cfg.database_type}";
+    database_host = null;
+    database_port = 5432;
+    database_name = "wallabag";
+    database_user = "wallabag";
+    database_password = null;
+    database_path = null;
+    database_table_prefix = "wallabag_";
+    database_socket = "/run/postgresql";
+    database_charset = "utf8";
 
-  poolName = "wallabag";
+    domain_name = "http://${cfg.domain}";
+    server_name = "Wallabag";
 
-  configFile = pkgs.writeTextFile {
-    name = "wallabag-config";
-    text = cfg.conf;
-    destination = "/app/config/parameters.yml";
-  };
+    # Needs an explicit command since Symfony version used by Wallabag does not yet support the `native` transport
+    # and the `sendmail` transport does not respect `sendmail_path` configured in `php.ini`.
+    mailer_dsn = "sendmail://default?command=/run/wrappers/bin/sendmail%%20-t%%20-i";
 
-  appDir = pkgs.buildEnv {
-    name = "wallabag-app-dir";
-    ignoreCollisions = true;
-    checkCollisionContents = false;
-    paths = [ configFile "${cfg.package}" ];
-    pathsToLink = [ "/app" "/src" "/translations" ];
-  };
+    locale = "en";
 
-  # See there for available commands:
-  # https://doc.wallabag.org/en/admin/console_commands.html
-  # A user can be made admin with the fos:user:promote --super <user> command
-  console = pkgs.writeShellScriptBin "wallabag-console" ''
-    export WALLABAG_DATA="${cfg.dataDir}"
-    cd "${cfg.dataDir}"
-    ${pkgs.php}/bin/php ${pkgs.wallabag}/bin/console --env=prod $@
-  '';
+    # A secret key that's used to generate certain security-related tokens.
+    # "env(SECRET_FILE)" = "/run/secrets/wallabag";
+    # secret = "%env(file:resolve:SECRET_FILE)%";
 
-in
-{
+    # two factor stuff
+    twofactor_auth = false;
+    twofactor_sender = "";
 
-  options = {
+    # fosuser stuff
+    fosuser_registration = false;
+    fosuser_confirmation = false;
 
-    services.wallabag = {
-      enable = mkEnableOption "wallabag";
+    # how long the access token should live in seconds for the API
+    fos_oauth_server_access_token_lifetime = 3600;
+    # how long the refresh token should life in seconds for the API
+    fos_oauth_server_refresh_token_lifetime = 1209600;
 
-      user = mkOption {
-        type = types.str;
-        default = "nginx";
-        description = ''
-          User account under which both the update daemon and the web-application run.
-        '';
-      };
+    from_email = "[e-mail]";
 
-      dataDir = mkOption {
-        type = types.path;
-        default = "/var/lib/wallabag";
-        description = ''
-          Data directory.
-        '';
-      };
+    # RabbitMQ processing
+    redis_scheme = "unix";
+    redis_host = ""; # Ignored for unix scheme
+    redis_port = 0; # Ignored for unix scheme
+    redis_path = config.services.redis.servers.wallabag.unixSocket;
+    redis_password = null;
 
-      package = mkOption {
-        type = types.package;
-        default = pkgs.wallabag;
-        description = ''
-          Wallabag package to use.
-        '';
-      };
+    # Redis processing
+    rabbitmq_host = "";
+    rabbitmq_port = 0;
+    rabbitmq_user = "";
+    rabbitmq_password = "";
+    rabbitmq_prefetch_count = 0;
 
-      hostName = mkOption {
-        type = types.str;
-        description = ''
-          Name of the nginx virtualhost to use and setup.
-        '';
-      };
+    # sentry logging
+    sentry_dsn = null;
+  } // cfg.parameters;
 
-      poolConfig = mkOption {
-        type = types.lines;
-        default = ''
-          pm = dynamic
-          pm.max_children = 75
-          pm.start_servers = 1
-          pm.min_spare_servers = 1
-          pm.max_spare_servers = 20
-          pm.max_requests = 500
-          catch_workers_output = 1
-        '';
-        description = ''
-          Options for wallabag's PHP pool. See the documentation on <literal>php-fpm.conf</literal> for details on configuration directives.
-        '';
-      };
+  php = cfg.php.package.withExtensions ({ enabled, all }: enabled ++ (with all; [
+    imagick
+    tidy
+  ]));
 
-      conf = mkOption {
-        type = types.str;
-        description = ''
-          Contents of the wallabag configuration file (parameters.yml)
-        '';
-      };
-    };
+  commonServiceConfig = {
+    CacheDirectory = "wallabag";
+    # Stores sessions.
+    CacheDirectoryMode = "700";
+    ConfigurationDirectory = "wallabag";
+    LogsDirectory = "wallabag";
+    StateDirectory = "wallabag";
+    # Stores site-credentials-secret-key.txt.
+    StateDirectoryMode = "700";
   };
 
+  cfg = config.services.wallabag;
+in {
+  options.services.wallabag = with lib; {
+    enable = mkEnableOption (mdDoc "Wallabag read-it-later service");
 
-  config = mkIf cfg.enable {
+    package = mkOption {
+      type = types.package;
+      default = pkgs.wallabag;
+    };
 
-    services.phpfpm.pools."${poolName}" = {
-      user = "${cfg.user}";
-      group = "nginx";
-      phpPackage = pkgs.php;
-      phpEnv = {
-        WALLABAG_DATA = cfg.dataDir;
-        PATH = lib.makeBinPath [pkgs.php];
-      };
-      settings = {
-        "listen.owner" = "nginx";
-        "listen.group" = "nginx";
-        "listen.mode" = "0600";
-        "user" = "${cfg.user}";
-        "group" = "nginx";
-        "pm" = "dynamic";
-        "pm.max_children" = "75";
-        "pm.min_spare_servers" = "5";
-        "pm.max_spare_servers" = "20";
-        "pm.max_requests" = "10";
-        "catch_workers_output" = "1";
-        "php_admin_value[error_log]" = "stderr";
-        "php_admin_flag[log_errors]" = true;
-      };
+    php.package = mkOption {
+      type = types.package;
+      default = pkgs.php;
     };
-    services.phpfpm.phpOptions = ''
-      max_execution_time = 120
-    '';
 
-    services.nginx.enable = mkDefault true;
-    environment.systemPackages = [ console ];
+    parameters = mkOption {
+      type = types.attrsOf types.str;
+      default = {};
+      description = mdDoc "Parameters to override from the default. See <https://doc.wallabag.org/en/admin/parameters.html> for values.";
+    };
 
-    # services.nginx.virtualHosts."${cfg.hostName}" = {
-    #   forceSSL = false;
-    #   enableACME = false;
-    #   extraConfig = ''
-    #     error_log /var/log/nginx/wallabag_error.log;
-    #     access_log /var/log/nginx/wallabag_access.log;
-    #   '';
+    database_type = mkOption {
+      type = types.enum [
+        "pdo_sqlite3"
+        "pdo_pgsql"
+      ];
+      default = if config.services.postgresql.enable
+                then "pdo_pgsql"
+                else "pdo_sqlite3";
+      defaultText = ''
+        if config.services.postgresql.enable
+        then "pdo_pgsql"
+        else "pdo_sqlite3"
+      '';
+      description = mdDoc ''
+        The database engine name. Can be pdo_sqlite3 or pdo_pgsql.
+      '';
+    };
 
-    #   root = "${cfg.package}/web";
-    #   locations."/" = {
-    #     priority = 10;
-    #     tryFiles = "$uri /app.php$is_args$args";
-    #   };
-    #   locations."/assets".root = "${cfg.dataDir}/web";
-    #   locations."~ ^/app\\.php(/|$)" = {
-    #     priority = 100;
-    #     fastcgiParams = {
-    #       SCRIPT_FILENAME = "$realpath_root$fastcgi_script_name";
-    #       DOCUMENT_ROOT = "$realpath_root";
-    #     };
-    #     extraConfig = ''
-    #       fastcgi_pass unix:${config.services.phpfpm.pools."${poolName}".socket};
-    #       include ${config.services.nginx.package}/conf/fastcgi_params;
-    #       include ${config.services.nginx.package}/conf/fastcgi.conf;
-    #       internal;
-    #     '';
-    #   };
-    #   locations."~ \\.php$" = {
-    #     priority = 1000;
-    #     return = "404";
-    #   };
-    # };
+    domain = mkOption {
+      type = types.str;
+      description = "Bare domain name for Wallabag";
+    };
 
+    virtualHost.enable = mkEnableOption (mdDoc "Define nginx virtualhost for Wallabag");
+  };
 
-    services.nginx.virtualHosts."${cfg.hostName}" = {
-      enableACME = false;
-      forceSSL = false;
-      root = "${cfg.package}/web";
+  config = lib.mkIf cfg.enable {
+    environment.etc."wallabag/parameters.yml" = {
+      source = pkgs.writeTextFile {
+        name = "wallabag-config";
+        text = builtins.toJSON {
+          parameters = settings;
+        };
+      };
+    };
+
+    services.nginx = lib.mkIf cfg.virtualHost.enable {
+      enable = true;
+
+      virtualHosts = {
+        "${cfg.domain}" = {
+          root = "${pkgs.wallabag}/web";
+
+          extraConfig = ''
+          add_header X-Frame-Options SAMEORIGIN;
+          add_header X-Content-Type-Options nosniff;
+          add_header X-XSS-Protection "1; mode=block";
+        '';
 
-      extraConfig = ''
-        add_header X-Frame-Options SAMEORIGIN;
-        add_header X-Content-Type-Options nosniff;
-        add_header X-XSS-Protection "1; mode=block";
-      '';
+          locations."/" = {
+            extraConfig = ''
+            try_files $uri /app.php$is_args$args;
+          '';
+          };
 
-      locations."/" = {
-        tryFiles = "$uri /app.php$is_args$args";
-      };
+          locations."/assets".root = "${pkgs.wallabag}/app/web";
 
-      locations."/assets".root = "${cfg.dataDir}/web";
+          locations."~ ^/app\\.php(/|$)" = {
+            extraConfig = ''
+            fastcgi_pass unix:${config.services.phpfpm.pools.wallabag.socket};
+            include ${config.services.nginx.package}/conf/fastcgi.conf;
+            fastcgi_param PATH_INFO $fastcgi_path_info;
+            fastcgi_param PATH_TRANSLATED $document_root$fastcgi_path_info;
+            fastcgi_param SCRIPT_FILENAME ${pkgs.wallabag}/web/$fastcgi_script_name;
+            fastcgi_param DOCUMENT_ROOT ${pkgs.wallabag}/web;
+            fastcgi_read_timeout 120;
+            internal;
+          '';
+          };
 
-      locations."~ ^/app\\.php(/|$)" = {
-        fastcgiParams = {
-          SCRIPT_FILENAME = "$realpath_root$fastcgi_script_name";
-          DOCUMENT_ROOT = "$realpath_root";
+          locations."~ /(?!app)\\.php$" = {
+            extraConfig = ''
+            return 404;
+          '';
+          };
         };
-        extraConfig = ''
-          fastcgi_pass unix:${config.services.phpfpm.pools."${poolName}".socket};
-          include ${config.services.nginx.package}/conf/fastcgi_params;
-          include ${config.services.nginx.package}/conf/fastcgi.conf;
-          internal;
-        '';
-        # extraConfig = ''
-        #   fastcgi_pass unix:${config.services.phpfpm.pools."${poolName}".socket};
-        #   fastcgi_split_path_info ^(.+\.php)(/.*)$;
-        #   include ${pkgs.nginx}/conf/fastcgi_params;
-        #   fastcgi_param SCRIPT_FILENAME ${cfg.package}/web/$fastcgi_script_name;
-        #   fastcgi_param DOCUMENT_ROOT ${cfg.package}/web;
-        #   fastcgi_read_timeout 120;
-        #   internal;
-        # '';
       };
+    };
 
-      locations."~ /(?!app)\\.php$" = {
-        extraConfig = ''
-          return 404;
-        '';
+    services.phpfpm.pools.wallabag = {
+      user = config.users.users.wallabag.name;
+      phpPackage = php;
+      settings = {
+        "catch_workers_output" = true;
+
+        "listen.owner" = config.services.nginx.user;
+        "listen.group" = "root";
+        "pm" = "dynamic";
+        "pm.max_children" = 5;
+        "pm.start_servers" = 2;
+        "pm.min_spare_servers" = 1;
+        "pm.max_spare_servers" = 3;
+        "php_admin_value[error_log]" = "/var/log/wallabag/error.log";
+        "php_admin_value[access_log]" = "/var/log/wallabag/access.log";
+        "php_admin_flag[log_errors]" = true;
+      };
+      phpOptions = ''
+      ; Set up $_ENV superglobal.
+      ; http://php.net/request-order
+      variables_order = "EGPCS"
+      # Wallabag will crash on start-up.
+      # https://github.com/wallabag/wallabag/issues/6042
+      # error_reporting = E_ALL & ~E_USER_DEPRECATED & ~E_DEPRECATED
+    '';
+      settings = {
+        # Accept settings from the systemd service.
+        clear_env = false;
       };
     };
 
+    users.users.wallabag = {
+      isSystemUser = true;
+      group = "wallabag";
+    };
+    users.groups.wallabag = {};
+    services.redis.servers.wallabag = {
+      enable = true;
+      user = "wallabag";
+    };
+    services.rabbitmq.enable = false;
+
+    systemd.services.phpfpm-wallabag.serviceConfig = commonServiceConfig;
+
     systemd.services.wallabag-install = {
       description = "Wallabag install service";
       wantedBy = [ "multi-user.target" ];
       before = [ "phpfpm-wallabag.service" ];
-      after = [ "mysql.service" "postgresql.service" ];
+      after = [ "postgresql.service" ];
       path = with pkgs; [ coreutils php phpPackages.composer ];
 
       serviceConfig = {
-        User = cfg.user;
+        User = "wallabag";
         Type = "oneshot";
-        RemainAfterExit = "yes";
-        PermissionsStartOnly = true;
-      };
-
-      preStart = ''
-        mkdir -p "${cfg.dataDir}"
-        chown ${cfg.user}:nginx "${cfg.dataDir}"
-      '';
+      } // commonServiceConfig;
 
       script = ''
-        echo "Setting up wallabag files in ${cfg.dataDir} ..."
-        cd "${cfg.dataDir}"
-
-        rm -rf var/cache/*
-        rm -f app src translations
-        ln -sf ${appDir}/app app
-        ln -sf ${appDir}/src src
-        ln -sf ${appDir}/translations translations
-        ln -sf ${cfg.package}/composer.{json,lock} .
-
-        export WALLABAG_DATA="${cfg.dataDir}"
-        if [ ! -f installed ]; then
-          echo "Install file not found, installing ..."
-          php ${cfg.package}/bin/console --env=prod doctrine:database:create --if-not-exists --no-interaction
-          php ${cfg.package}/bin/console --env=prod doctrine:migrations:migrate --no-interaction
-          # Until https://github.com/wallabag/wallabag/issues/3662 is fixed
-          # yes no | php ${cfg.package}/bin/console --env=prod wallabag:install
-          touch installed
-        else
-          php ${cfg.package}/bin/console --env=prod doctrine:migrations:migrate --no-interaction
-        fi
-        php ${cfg.package}/bin/console --env=prod cache:clear
-      '';
+      if [ ! -f "$STATE_DIRECTORY/installed" ]; then
+        php ${pkgs.wallabag}/bin/console --env=prod wallabag:install
+        touch "$STATE_DIRECTORY/installed"
+      else
+        php ${pkgs.wallabag}/bin/console --env=prod doctrine:migrations:migrate --no-interaction
+      fi
+      php ${pkgs.wallabag}/bin/console --env=prod cache:clear
+    '';
     };
-  };
-
-  meta = with stdenv.lib; {
-    maintainers = with maintainers; [ nadrieril ];
   };
 }

mount-crypted.sh

···
 #!/usr/bin/env bash
+
+# nix-shell https://github.com/sgillespie/nixos-yubikey-luks/archive/master.tar.gz
+
+rbtohex() {
+    ( od -An -vtx1 | tr -d ' \n' )
+}
+
+hextorb() {
+    ( tr '[:lower:]' '[:upper:]' | sed -e 's/\([0-9A-F]\{2\}\)/\\\\\\x\1/gI'| xargs printf )
+}
+
 key_length=512
-iterations="$(head -n 2 /boot/crypted-storage/default)"
-salt="$(head -n 1 /boot/crypted-storage/default)"
+iterations=1000000
+salt="$(head -n 1 /mnt/crypt-storage/default)"
 chal="$(echo -n $salt | openssl dgst -binary -sha512 | rbtohex)"
 resp="$(ykchalresp -2 -x $chal 2>/dev/null)"
-user_key="$(read -s)"
+user_key=
+read -r user_key
 luks_key="$(echo -n $user_key | pbkdf2-sha512 $(($key_length / 8)) $iterations $resp | rbtohex)"
 echo -n $luks_key | hextorb | sudo cryptsetup luksOpen /dev/sda2 crypted --key-file=-

overlays/default.nix

···
       buildInputs = prevAttrs.propagatedBuildInputs ++ [ final.python3.pkgs.aiosqlite ]; # We're using sqlite and upstream doesn't package this dependency
     });
 
+    wallabag = prev.wallabag.overrideAttrs (attrs: {
+      patches = builtins.filter (patch: builtins.baseNameOf patch != "wallabag-data.patch") attrs.patches ++ [
+        # Out of the box, Wallabag wants to write to various subdirectories of the project directory.
+        # Let’s replace references to such paths with designated systemd locations
+        # so that the project source can remain immutable.
+        ../pkgs/wallabag-data.patch
+      ];
+    });
+
     # Need to do server and agent too, maybe
     # woodpecker-cli-next = 
     # let

pkgs/default.nix

···
   plymouth-themes = pkgs.callPackage ./plymouth.nix { };
   tic-80 = pkgs.callPackage ./tic-80.nix { };
   fennel-ls = pkgs.callPackage ./fennel-ls.nix { };
-  kobopatch = pkgs.callPackage ./kobopatch.nix { };
+  # kobopatch = pkgs.callPackage ./kobopatch.nix { };
   my-mautrix-discord = pkgs.callPackage ./mautrix-discord.nix { }; # Handled by matrix-appservices input
   ulogger-server = pkgs.callPackage ./ulogger.nix { };
+  # Wallabag is now an overlay
+  # TODO: we still use the patch from this folder though
+  my-wallabag = pkgs.callPackage ./wallabag.nix { };
+  mautrix-slack = pkgs.callPackage ./mautrix-slack.nix { }; 
+  gpodder2go = pkgs.callPackage ./gpodder2go.nix { }; 
 }

pkgs/gpodder2go.nix

···
+{ pkgs, ... }:
+
+pkgs.buildGoModule rec {
+  name = "gpodder2go";
+  src = pkgs.fetchFromGitHub {
+    owner = "oxtyped";
+    repo = "gpodder2go";
+    rev = "v0.1.2";
+    hash = "sha256-RAt0rd4DZwI7b7IEFd1o4s4ivADzgzBzBaeGVL8OmYo";
+  };
+
+  vendorHash = "sha256-mbSgY5WjIAesT27uRgaiRF3N06yuUntjTp6kjUMh6Bw";
+  doCheck = false;
+}

pkgs/kobopatch.nix

···
 { lib, buildGoModule, fetchFromGitHub }:
 
-buildGoModule rec {
+buildGoModule {
   name = "kobopatch";
   version = "0.15.0";
 
-  vendorSha256 = "1i6srhyig4x8mywyc2l8wzzm1afvb7wxmjsr84c447sb1xss6p7x";
+  vendorHash = "sha256-1i6srhyig4x8mywyc2l8wzzm1afvb7wxmjsr84c447sb1xss6p7x";
 
   src = fetchFromGitHub {
     owner = "geek1011";
     repo = "kobopatch";
     rev = "653070c67c83ec61884854efc4f8a3132d82a2e5";
-    sha256 = "09hr3zh0w0f78cx40d2yydqv0mmjdh4iwdgia7sikraphvha85nn";
+    hash = "sha256-09hr3zh0w0f78cx40d2yydqv0mmjdh4iwdgia7sikraphvha85nn";
   };
 
   meta = with lib; {

pkgs/koboutils.nix

···
   name = "koboutils";
   version = "git_2020-04-08";
 
-  vendorSha256 = "1hqvizvbc29yib6awmvlklxkq7j8c0d32gxsipdiwhkh79xbd6wq";
+  vendorha256 = "1hqvizvbc29yib6awmvlklxkq7j8c0d32gxsipdiwhkh79xbd6wq";
   deleteVendor = true;
 
   src = fetchFromGitHub {

pkgs/mautrix-slack.nix

···
+{ lib, buildGoModule, fetchFromGitHub, olm }:
+
+buildGoModule rec {
+  pname = "mautrix-discord";
+  version = "unstable-2022-11-04";
+
+  src = fetchFromGitHub {
+    owner = "mautrix";
+    repo = "slack";
+    rev = "4530ff397d08d93b673cd71da4c2a75d969ca0df";
+    hash = "";
+  };
+
+  buildInputs = [ olm ];
+
+  vendorHash = "sha256-yday2mSnPwuhXWkCG4XY7qoBl3DXHcSvzBoZbjgYz/c=";
+
+  ldflags = [ "-s" "-w" ]; # https://github.com/NixOS/nixpkgs/issues/177698
+
+  doCheck = false; # No tests available
+
+  meta = with lib; {
+    homepage = "https://go.mau.fi/mautrix-slack";
+    description = "Matrix to Slack hybrid puppeting/relaybot bridge";
+    license = licenses.agpl3Plus;
+    maintainers = with maintainers; [ ];
+  };
+}
+

pkgs/tic-80.nix

···
   };
   buildInputs = with pkgs; [
     gcc
-    pkgconfig
+    pkg-config
     autoconf
     automake
     libtool
···
     gtk3-x11
     cmake
     cmakeCurses
-    elementary-cmake-modules
+    # elementary-cmake-modules
     extra-cmake-modules
     libglvnd
     mesa_glu

pkgs/wallabag-data.patch

···
+diff --git a/app/AppKernel.php b/app/AppKernel.php
+index 61b734e06..0902c20fc 100644
+--- a/app/AppKernel.php
++++ b/app/AppKernel.php
+@@ -64,12 +64,12 @@ class AppKernel extends Kernel
+ 
+     public function getCacheDir()
+     {
+-        return dirname(__DIR__) . '/var/cache/' . $this->getEnvironment();
++        return getenv('CACHE_DIRECTORY') . '/' . $this->getEnvironment();
+     }
+ 
+     public function getLogDir()
+     {
+-        return dirname(__DIR__) . '/var/logs';
++        return getenv('LOGS_DIRECTORY');
+     }
+ 
+     public function registerContainerConfiguration(LoaderInterface $loader)
+diff --git a/app/config/config.yml b/app/config/config.yml
+index 7f0a4ca6c..77b5175c8 100644
+--- a/app/config/config.yml
++++ b/app/config/config.yml
+@@ -1,5 +1,7 @@
+ imports:
+-    - { resource: parameters.yml }
++    # Unfortunately, we cannot use %env(string:CONFIGURATION_DIRECTORY)%. Hardcoding the path for simplicity.
++    # https://symfony.com/doc/current/service_container/import.html#importing-configuration-with-imports
++    - { resource: '/etc/wallabag/parameters.yml' }
+     - { resource: security.yml }
+     - { resource: services.yml }
+     - { resource: wallabag.yml }
+@@ -28,7 +30,7 @@ framework:
+     session:
+         # handler_id set to null will use default session handler from php.ini
+         handler_id: session.handler.native_file
+-        save_path: "%kernel.project_dir%/var/sessions/%kernel.environment%"
++        save_path: "%env(string:CACHE_DIRECTORY)%/sessions/%kernel.environment%"
+         cookie_secure: auto
+     fragments: ~
+     http_method_override: true
+diff --git a/app/config/wallabag.yml b/app/config/wallabag.yml
+index bd57d6377..8e1cd0970 100644
+--- a/app/config/wallabag.yml
++++ b/app/config/wallabag.yml
+@@ -35,7 +35,7 @@ wallabag_core:
+     fetching_error_message: |
+         wallabag can't retrieve contents for this article. Please <a href="https://doc.wallabag.org/en/user/errors_during_fetching.html#how-can-i-help-to-fix-that">troubleshoot this issue</a>.
+     api_limit_mass_actions: 10
+-    encryption_key_path: "%kernel.project_dir%/data/site-credentials-secret-key.txt"
++    encryption_key_path: "%env(string:STATE_DIRECTORY)%/site-credentials-secret-key.txt"
+     default_internal_settings:
+         -
+             name: share_public
+

pkgs/wallabag.nix

···
+{ lib
+, stdenv
+, fetchurl
+}:
+
+# Point the environment variable $WALLABAG_DATA to a data directory
+# that contains the folder `app` which must be a clone of
+# wallabag's configuration files with your customized `parameters.yml`.
+# In practice you need to copy `${pkgs.wallabag}/app` and the
+# customizzed `parameters.yml` to $WALLABAG_DATA.
+# These need to be updated every package upgrade.
+#
+# After a package upgrade, empty the `var/cache` folder or unexpected
+# error will occur.
+
+let
+  pname = "wallabag";
+  version = "2.6.9";
+in
+stdenv.mkDerivation {
+  inherit pname version;
+
+  # Release tarball includes vendored files
+  src = fetchurl {
+    url = "https://github.com/wallabag/wallabag/releases/download/${version}/wallabag-${version}.tar.gz";
+    hash = "sha256-V4s5/y9fFAmZ+WnUxU03UyRivEihD1ZUKQOOq4TLEKw=";
+  };
+
+  patches = [
+    ./wallabag-data.patch # exposes $WALLABAG_DATA
+  ];
+
+  dontBuild = true;
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir $out
+    cp -R * $out/
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "wallabag is a self hostable application for saving web pages";
+    longDescription = ''
+      wallabag is a self-hostable PHP application allowing you to not
+      miss any content anymore. Click, save and read it when you can.
+      It extracts content so that you can read it when you have time.
+    '';
+    license = licenses.mit;
+    homepage = "http://wallabag.org";
+    changelog = "https://github.com/wallabag/wallabag/releases/tag/${version}";
+    maintainers = with maintainers; [ schneefux ];
+    platforms = platforms.all;
+  };
+}

shell.nix

···
   default = pkgs.mkShell {
     # Enable experimental features without having to specify the argument
     NIX_CONFIG = "experimental-features = nix-command flakes";
-    nativeBuildInputs = with pkgs; [ nix home-manager git agenix deploy-rs dnscontrol ];
+    nativeBuildInputs = with pkgs; [
+      nix
+      home-manager
+      git
+      agenix
+      deploy-rs
+      dnscontrol
+      git-bug
+    ];
   };
 }