just use fileset from lib

package: just use fileset from lib
The following command is now sufficient to build Lix from outside of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: Ie6b14b446480ac07c7266d4fba20042b04cc35b9
2024-04-07 15:11:03 -06:00 · 2024-04-07 15:10:44 -06:00 · 2024-04-07 15:10:02 -06:00 · 2024-04-07 15:09:39 -06:00 · 2024-04-07 15:09:39 -06:00 · 2024-04-07 14:30:07 -06:00
1686 changed files with 2 additions and 148691 deletions
--- a/.clang-format
+++ b/.clang-format
@ -1,50 +0,0 @@
 ---
 BasedOnStyle: LLVM
 AccessModifierOffset: -4
 AlignAfterOpenBracket: BlockIndent
 AlignEscapedNewlines: Left
 AlignOperands: DontAlign
 AllowShortBlocksOnASingleLine: Always
 AllowShortFunctionsOnASingleLine: Empty
 AllowShortIfStatementsOnASingleLine: WithoutElse
 AlwaysBreakBeforeMultilineStrings: true
 AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: false
 BinPackParameters: false
 BitFieldColonSpacing: None
 BraceWrapping:
  AfterCaseLabel: false
  AfterClass: true
  AfterControlStatement: MultiLine
  AfterEnum: false
  AfterFunction: true
  AfterNamespace: false
  AfterObjCDeclaration: false
  AfterStruct: true
  AfterUnion: true
  AfterExternBlock: false
  BeforeCatch: false
  BeforeElse: false
  BeforeLambdaBody: false
  BeforeWhile: false
  IndentBraces: false
  SplitEmptyFunction: true
  SplitEmptyRecord: false
  SplitEmptyNamespace: true
 BreakAfterAttributes: Always
 BreakBeforeBinaryOperators: NonAssignment
 BreakBeforeBraces: Custom
 BreakConstructorInitializers: BeforeComma
 ColumnLimit: 100
 EmptyLineAfterAccessModifier: Leave
 EmptyLineBeforeAccessModifier: Leave
 FixNamespaceComments: false
 IndentWidth: 4
 InsertBraces: true
 InsertTrailingCommas: Wrapped
 LambdaBodyIndentation: Signature
 PackConstructorInitializers: CurrentLine
 PointerAlignment: Middle
 SortIncludes: Never
 SpaceAfterCStyleCast: true
 SpaceAfterTemplateKeyword: false
--- a/.clang-tidy
+++ b/.clang-tidy
@ -1,18 +0,0 @@
 UseColor: true
 Checks:
  - -*
  - bugprone-*
    # too many warnings
  - -bugprone-assignment-in-if-condition
    # too many warnings
  - -bugprone-narrowing-conversions
    # kind of nonsense
  - -bugprone-easily-swappable-parameters
    # too many warnings for now
  - -bugprone-implicit-widening-of-multiplication-result
    # Lix's exception handling is Questionable
  - -bugprone-empty-catch
    # many warnings
  - -bugprone-unchecked-optional-access
    # many warnings, seems like a questionable lint
  - -bugprone-branch-clone
--- a/.dir-locals.el
+++ b/.dir-locals.el
@ -1,18 +0,0 @@
 ((c++-mode . (
  (c-file-style . "k&r")
  (c-basic-offset . 4)
  (c-block-comment-prefix . "  ")
  (indent-tabs-mode . nil)
  (tab-width . 4)
  (show-trailing-whitespace . t)
  (indicate-empty-lines . t)
  (eval . (c-set-offset 'innamespace 0))
  (eval . (c-set-offset 'defun-open 0))
  (eval . (c-set-offset 'inline-open 0))
  (eval . (c-set-offset 'arglist-intro '+))
  (eval . (c-set-offset 'arglist-cont 0))
  (eval . (c-set-offset 'arglist-cont-nonempty '+))
  (eval . (c-set-offset 'substatement-open 0))
  (eval . (c-set-offset 'access-label '-))
  (eval . (c-set-offset 'inlambda 0))
  )))
--- a/.editorconfig
+++ b/.editorconfig
@ -1,26 +0,0 @@
 # EditorConfig configuration for nix
 # http://EditorConfig.org
 # Top-most EditorConfig file
 root = true
 # Unix-style newlines with a newline ending every file, utf-8 charset
 [*]
 end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true
 charset = utf-8
 # Match nix files, set indent to spaces with width of two
 [*.nix]
 indent_style = space
 indent_size = 2
 # Match c++/shell/perl, set indent to spaces with width of four
 [*.{hpp,cc,hh,sh,pl}]
 indent_style = space
 indent_size = 4
 # Match diffs, avoid to trim trailing whitespace
 [*.{diff,patch}]
 trim_trailing_whitespace = false
--- a/.envrc
+++ b/.envrc
@ -1,9 +0,0 @@
 # shellcheck shell=bash
 source_env_if_exists .envrc.local
 # TODO: `use flake .#native-clangStdenvPackages` on macOS?
 use flake ".#${LIX_SHELL_VARIANT:-default}" "${LIX_SHELL_EXTRA_ARGS[@]}"
 export MAKEFLAGS="$MAKEFLAGS -e"
 if [[ -n "$NIX_BUILD_CORES" ]]; then
    export MAKEFLAGS="$MAKEFLAGS -j $NIX_BUILD_CORES"
 fi
 export GTEST_BRIEF=1
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@ -1,18 +0,0 @@
 # Pull requests concerning the listed files will automatically invite the respective maintainers as reviewers.
 # This file is not used for denoting any kind of ownership, but is merely a tool for handling notifications.
 #
 # Merge permissions are required for maintaining an entry in this file.
 # For documentation on this mechanism, see https://help.github.com/articles/about-codeowners/
 # Default reviewers if nothing else matches
 * @edolstra
 # This file
 .github/CODEOWNERS @edolstra
 # Public documentation
 /doc @fricklerhandwerk
 *.md @fricklerhandwerk
 # Libstore layer
 /src/libstore @thufschmitt
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -1,32 +0,0 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 title: ''
 labels: bug
 assignees: ''
 ---
 ## Describe the bug
 A clear and concise description of what the bug is.
 If you have a problem with a specific package or NixOS,
 you probably want to file an issue at https://github.com/NixOS/nixpkgs/issues.
 ## Steps To Reproduce
 1. Go to '...'
 2. Click on '....'
 3. Scroll down to '....'
 4. See error
 ## Expected behavior
 A clear and concise description of what you expected to happen.
 ## `nix --version` output
 ## Additional context
 Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -1,24 +0,0 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
 title: ''
 labels: feature
 assignees: ''
 ---
 ## Is your feature request related to a problem? Please describe.
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 ## Describe the solution you'd like
 A clear and concise description of what you want to happen.
 ## Describe alternatives you've considered
 A clear and concise description of any alternative solutions or features you've considered.
 ## Additional context
 Add any other context or screenshots about the feature request here.
--- a/.github/ISSUE_TEMPLATE/installer.md
+++ b/.github/ISSUE_TEMPLATE/installer.md
@ -1,32 +0,0 @@
 ---
 name: Installer issue
 about: Report problems with installation
 title: ''
 labels: installer
 assignees: ''
 ---
 ## Platform
 <!-- select the platform on which you tried to install Nix -->
 - [ ] Linux: <!-- state your distribution, e.g. Arch Linux, Ubuntu, ... -->
 - [ ] macOS
 - [ ] WSL
 ## Additional information
 <!-- state special circumstances on your system or additional steps you have taken prior to installation -->
 ## Output
 <details><summary>Output</summary>
 ```log
 <!-- paste console output here and remove this comment -->
 ```
 </details>
--- a/.github/ISSUE_TEMPLATE/missing_documentation.md
+++ b/.github/ISSUE_TEMPLATE/missing_documentation.md
@ -1,27 +0,0 @@
 ---
 name: Missing or incorrect documentation
 about: Help us improve the reference manual
 title: ''
 labels: documentation
 assignees: ''
 ---
 ## Problem
 <!-- describe your problem -->
 ## Proposal
 <!-- propose a solution -->
 ## Checklist
 <!-- make sure this issue is not redundant or obsolete -->
 - [ ] checked [latest Nix manual] \([source])
 - [ ] checked [open documentation issues and pull requests] for possible duplicates
 [latest Nix manual]: https://nixos.org/manual/nix/unstable/
 [source]: https://github.com/NixOS/nix/tree/master/doc/manual/src
 [open documentation issues and pull requests]: https://github.com/NixOS/nix/labels/documentation
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,11 +0,0 @@
 # Motivation
 <!-- Briefly explain what the change is about and why it is desirable. -->
 # Context
 <!-- Provide context. Reference open issues if available. -->
 <!-- Non-trivial change: Briefly outline the implementation strategy. -->
 <!-- Invasive change: Discuss alternative designs or approaches you considered. -->
 <!-- Large change: Provide instructions to reviewers how to read the diff. -->
--- a/.github/STALE-BOT.md
+++ b/.github/STALE-BOT.md
@ -1,35 +0,0 @@
 # Stale bot information
 - Thanks for your contribution!
 - To remove the stale label, just leave a new comment.
 - _How to find the right people to ping?_ &rarr; [`git blame`](https://git-scm.com/docs/git-blame) to the rescue! (or GitHub's history and blame buttons.)
 - You can always ask for help on [our Discourse Forum](https://discourse.nixos.org/) or on [Matrix - #nix:nixos.org](https://matrix.to/#/#nix:nixos.org).
 ## Suggestions for PRs
 1. GitHub sometimes doesn't notify people who commented / reviewed a PR previously, when you (force) push commits. If you have addressed the reviews you can [officially ask for a review](https://docs.github.com/en/free-pro-team@latest/github/collaborating-with-issues-and-pull-requests/requesting-a-pull-request-review) from those who commented to you or anyone else.
 2. If it is unfinished but you plan to finish it, please mark it as a draft.
 3. If you don't expect to work on it any time soon, closing it with a short comment may encourage someone else to pick up your work.
 4. To get things rolling again, rebase the PR against the target branch and address valid comments.
 5. If you need a review to move forward, ask in [the Discourse thread for PRs that need help](https://discourse.nixos.org/t/prs-in-distress/3604).
 6. If all you need is a merge, check the git history to find and [request reviews](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/requesting-a-pull-request-review) from people who usually merge related contributions.
 ## Suggestions for issues
 1. If it is resolved (either for you personally, or in general), please consider closing it.
 2. If this might still be an issue, but you are not interested in promoting its resolution, please consider closing it while encouraging others to take over and reopen an issue if they care enough.
 3. If you still have interest in resolving it, try to ping somebody who you believe might have an interest in the topic. Consider discussing the problem in [our Discourse Forum](https://discourse.nixos.org/).
 4. As with all open source projects, your best option is to submit a Pull Request that addresses this issue. We :heart: this attitude!
 **Memorandum on closing issues**
 Don't be afraid to close an issue that holds valuable information. Closed issues stay in the system for people to search, read, cross-reference, or even reopen--nothing is lost! Closing obsolete issues is an important way to help maintainers focus their time and effort.
 ## Useful GitHub search queries
 - [Open PRs with any stale-bot interaction](https://github.com/NixOS/nix/pulls?q=is%3Apr+is%3Aopen+commenter%3Aapp%2Fstale+)
 - [Open PRs with any stale-bot interaction and `stale`](https://github.com/NixOS/nix/pulls?q=is%3Apr+is%3Aopen+commenter%3Aapp%2Fstale+label%3A%22stale%22)
 - [Open PRs with any stale-bot interaction and NOT `stale`](https://github.com/NixOS/nix/pulls?q=is%3Apr+is%3Aopen+commenter%3Aapp%2Fstale+-label%3A%22stale%22+)
 - [Open Issues with any stale-bot interaction](https://github.com/NixOS/nix/issues?q=is%3Aissue+is%3Aopen+commenter%3Aapp%2Fstale+)
 - [Open Issues with any stale-bot interaction and `stale`](https://github.com/NixOS/nix/issues?q=is%3Aissue+is%3Aopen+commenter%3Aapp%2Fstale+label%3A%22stale%22+)
 - [Open Issues with any stale-bot interaction and NOT `stale`](https://github.com/NixOS/nix/issues?q=is%3Aissue+is%3Aopen+commenter%3Aapp%2Fstale+-label%3A%22stale%22+)
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@ -1,6 +0,0 @@
 version: 2
 updates:
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@ -1,23 +0,0 @@
 "documentation":
  - doc/manual/*
  - src/nix/**/*.md
 "store":
  - src/libstore/store-api.*
  - src/libstore/*-store.*
 "fetching":
  - src/libfetchers/**/*
 "repl":
  - src/libcmd/repl.*
  - src/nix/repl.*
 "new-cli":
  - src/nix/**/*
 "with-tests":
  # Unit tests
  - src/*/tests/**/*
  # Functional and integration tests
  - tests/functional/**/*
--- a/.github/stale.yml
+++ b/.github/stale.yml
@ -1,9 +0,0 @@
 # Configuration for probot-stale - https://github.com/probot/stale
 daysUntilStale: 180
 daysUntilClose: false
 exemptLabels:
  - "critical"
  - "never-stale"
 staleLabel: "stale"
 markComment: false
 closeComment: false
--- a/.github/workflows/backport.yml
+++ b/.github/workflows/backport.yml
@ -1,32 +0,0 @@
 name: Backport
 on:
  pull_request_target:
    types: [closed, labeled]
 permissions:
  contents: read
 jobs:
  backport:
    name: Backport Pull Request
    permissions:
      # for zeebe-io/backport-action
      contents: write
      pull-requests: write
    if: github.repository_owner == 'NixOS' && github.event.pull_request.merged == true && (github.event_name != 'labeled' || startsWith('backport', github.event.label.name))
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          # required to find all branches
          fetch-depth: 0
      - name: Create backport PRs
        # should be kept in sync with `version`
        uses: zeebe-io/backport-action@v1.4.0
        with:
          # Config README: https://github.com/zeebe-io/backport-action#backport-action
          github_token: ${{ secrets.GITHUB_TOKEN }}
          github_workspace: ${{ github.workspace }}
          pull_description: |-
            Automatic backport to `${target_branch}`, triggered by a label in #${pull_number}.
          # should be kept in sync with `uses`
          version: v0.0.5
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,135 +0,0 @@
 name: "CI"
 on:
  pull_request:
  push:
 permissions: read-all
 jobs:
  tests:
    needs: [check_secrets]
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    timeout-minutes: 60
    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0
    - uses: cachix/install-nix-action@v23
      with:
        # The sandbox would otherwise be disabled by default on Darwin
        extra_nix_config: "sandbox = true"
    - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
    - uses: cachix/cachix-action@v12
      if: needs.check_secrets.outputs.cachix == 'true'
      with:
        name: '${{ env.CACHIX_NAME }}'
        signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'
        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
    - run: nix --experimental-features 'nix-command flakes' flake check -L
  check_secrets:
    permissions:
      contents: none
    name: Check Cachix and Docker secrets present for installer tests
    runs-on: ubuntu-latest
    outputs:
      cachix: ${{ steps.secret.outputs.cachix }}
      docker: ${{ steps.secret.outputs.docker }}
    steps:
      - name: Check for secrets
        id: secret
        env:
          _CACHIX_SECRETS: ${{ secrets.CACHIX_SIGNING_KEY }}${{ secrets.CACHIX_AUTH_TOKEN }}
          _DOCKER_SECRETS: ${{ secrets.DOCKERHUB_USERNAME }}${{ secrets.DOCKERHUB_TOKEN }}
        run: |
          echo "::set-output name=cachix::${{ env._CACHIX_SECRETS != '' }}"
          echo "::set-output name=docker::${{ env._DOCKER_SECRETS != '' }}"
  installer:
    needs: [tests, check_secrets]
    if: github.event_name == 'push' && needs.check_secrets.outputs.cachix == 'true'
    runs-on: ubuntu-latest
    outputs:
      installerURL: ${{ steps.prepare-installer.outputs.installerURL }}
    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0
    - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
    - uses: cachix/install-nix-action@v23
      with:
        install_url: https://releases.nixos.org/nix/nix-2.13.3/install
    - uses: cachix/cachix-action@v12
      with:
        name: '${{ env.CACHIX_NAME }}'
        signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'
        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
    - id: prepare-installer
      run: scripts/prepare-installer-for-github-actions
  installer_test:
    needs: [installer, check_secrets]
    if: github.event_name == 'push' && needs.check_secrets.outputs.cachix == 'true'
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
    - uses: actions/checkout@v4
    - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
    - uses: cachix/install-nix-action@v23
      with:
        install_url: '${{needs.installer.outputs.installerURL}}'
        install_options: "--tarball-url-prefix https://${{ env.CACHIX_NAME }}.cachix.org/serve"
    - run: sudo apt install fish zsh
      if: matrix.os == 'ubuntu-latest'
    - run: brew install fish
      if: matrix.os == 'macos-latest'
    - run: exec bash -c "nix-instantiate -E 'builtins.currentTime' --eval"
    - run: exec sh -c "nix-instantiate -E 'builtins.currentTime' --eval"
    - run: exec zsh -c "nix-instantiate -E 'builtins.currentTime' --eval"
    - run: exec fish -c "nix-instantiate -E 'builtins.currentTime' --eval"
    - run: exec bash -c "nix-channel --add https://releases.nixos.org/nixos/unstable/nixos-23.05pre466020.60c1d71f2ba nixpkgs"
    - run: exec bash -c "nix-channel --update && nix-env -iA nixpkgs.hello && hello"
  docker_push_image:
    needs: [check_secrets, tests]
    if: >-
      github.event_name == 'push' &&
      github.ref_name == 'master' &&
      needs.check_secrets.outputs.cachix == 'true' &&
      needs.check_secrets.outputs.docker == 'true'
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0
    - uses: cachix/install-nix-action@v23
      with:
        install_url: https://releases.nixos.org/nix/nix-2.13.3/install
    - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
    - run: echo NIX_VERSION="$(nix --experimental-features 'nix-command flakes' eval .\#default.version | tr -d \")" >> $GITHUB_ENV
    - uses: cachix/cachix-action@v12
      if: needs.check_secrets.outputs.cachix == 'true'
      with:
        name: '${{ env.CACHIX_NAME }}'
        signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'
        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
    - run: nix --experimental-features 'nix-command flakes' build .#dockerImage -L
    - run: docker load -i ./result/image.tar.gz
    - run: docker tag nix:$NIX_VERSION nixos/nix:$NIX_VERSION
    - run: docker tag nix:$NIX_VERSION nixos/nix:master
    - name: Login to Docker Hub
      uses: docker/login-action@v3
      with:
        username: ${{ secrets.DOCKERHUB_USERNAME }}
        password: ${{ secrets.DOCKERHUB_TOKEN }}
    - run: docker push nixos/nix:$NIX_VERSION
    - run: docker push nixos/nix:master
--- a/.github/workflows/hydra_status.yml
+++ b/.github/workflows/hydra_status.yml
@ -1,19 +0,0 @@
 name: Hydra status
 permissions: read-all
 on:
  schedule:
    - cron: "12,42 * * * *"
  workflow_dispatch:
 jobs:
  check_hydra_status:
    name: Check Hydra status
    if: github.repository_owner == 'NixOS'
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0
    - run: bash scripts/check-hydra-status.sh
--- a/.github/workflows/labels.yml
+++ b/.github/workflows/labels.yml
@ -1,24 +0,0 @@
 name: "Label PR"
 on:
  pull_request_target:
    types: [edited, opened, synchronize, reopened]
 # WARNING:
 # When extending this action, be aware that $GITHUB_TOKEN allows some write
 # access to the GitHub API. This means that it should not evaluate user input in
 # a way that allows code injection.
 permissions:
  contents: read
  pull-requests: write
 jobs:
  labels:
    runs-on: ubuntu-latest
    if: github.repository_owner == 'NixOS'
    steps:
    - uses: actions/labeler@v4
      with:
        repo-token: ${{ secrets.GITHUB_TOKEN }}
        sync-labels: false
--- a/.gitignore
+++ b/.gitignore
@ -1,164 +0,0 @@
 Makefile.config
 perl/Makefile.config
 # /
 /aclocal.m4
 /autom4te.cache
 /precompiled-headers.h.gch
 /config.*
 /configure
 /stamp-h1
 /svn-revision
 /libtool
 /config
 # /doc/manual/
 /doc/manual/*.1
 /doc/manual/*.5
 /doc/manual/*.8
 /doc/manual/generated/*
 /doc/manual/nix.json
 /doc/manual/conf-file.json
 /doc/manual/language.json
 /doc/manual/xp-features.json
 /doc/manual/src/SUMMARY.md
 /doc/manual/src/SUMMARY-rl-next.md
 /doc/manual/src/command-ref/new-cli
 /doc/manual/src/command-ref/conf-file.md
 /doc/manual/src/command-ref/experimental-features-shortlist.md
 /doc/manual/src/contributing/experimental-feature-descriptions.md
 /doc/manual/src/language/builtins.md
 /doc/manual/src/language/builtin-constants.md
 /doc/manual/src/release-notes/rl-next.md
 # /scripts/
 /scripts/nix-profile.sh
 /scripts/nix-profile-daemon.sh
 /scripts/nix-profile.fish
 /scripts/nix-profile-daemon.fish
 # /src/libexpr/
 /src/libexpr/lexer-tab.cc
 /src/libexpr/lexer-tab.hh
 /src/libexpr/parser-tab.cc
 /src/libexpr/parser-tab.hh
 /src/libexpr/parser-tab.output
 /src/libexpr/nix.tbl
 /src/libexpr/tests
 /tests/unit/libexpr/libnixexpr-tests
 # /src/libstore/
 *.gen.*
 /src/libstore/tests
 /tests/unit/libstore/libnixstore-tests
 # /src/libutil/
 /src/libutil/tests
 /tests/unit/libutil/libnixutil-tests
 /src/nix/nix
 /src/nix/doc
 # /src/nix-env/
 /src/nix-env/nix-env
 # /src/nix-instantiate/
 /src/nix-instantiate/nix-instantiate
 # /src/nix-store/
 /src/nix-store/nix-store
 /src/nix-prefetch-url/nix-prefetch-url
 /src/nix-collect-garbage/nix-collect-garbage
 # /src/nix-channel/
 /src/nix-channel/nix-channel
 # /src/nix-build/
 /src/nix-build/nix-build
 /src/nix-copy-closure/nix-copy-closure
 /src/error-demo/error-demo
 /src/build-remote/build-remote
 # /tests/functional/
 /tests/functional/test-tmp
 /tests/functional/common/vars-and-functions.sh
 /tests/functional/result*
 /tests/functional/restricted-innocent
 /tests/functional/shell
 /tests/functional/shell.drv
 /tests/functional/config.nix
 /tests/functional/ca/config.nix
 /tests/functional/dyn-drv/config.nix
 /tests/functional/repl-result-out
 /tests/functional/debugger-test-out
 /tests/functional/test-libstoreconsumer/test-libstoreconsumer
 # /tests/functional/lang/
 /tests/functional/lang/*.out
 /tests/functional/lang/*.out.xml
 /tests/functional/lang/*.err
 /tests/functional/lang/*.ast
 /perl/lib/Nix/Config.pm
 /perl/lib/Nix/Store.cc
 /misc/systemd/nix-daemon.service
 /misc/systemd/nix-daemon.socket
 /misc/systemd/nix-daemon.conf
 /misc/upstart/nix-daemon.conf
 /src/resolve-system-dependencies/resolve-system-dependencies
 outputs/
 *.a
 *.o
 *.o.tmp
 *.so
 *.dylib
 *.dll
 *.exe
 *.dep
 *~
 *.pc
 *.plist
 # GNU Global
 GPATH
 GRTAGS
 GSYMS
 GTAGS
 # ccls
 /.ccls-cache
 # auto-generated compilation database
 compile_commands.json
 nix-rust/target
 result
 result-*
 .vscode/
 .direnv/
 .envrc.local
 # clangd and possibly more
 .cache/
 # Mac OS
 .DS_Store
 # ClangBuildAnalyzer output, see maintainers/buildtime_report.sh
 buildtime.bin
 .envrc.local
 # We generate this with a Nix shell hook
 /.pre-commit-config.yaml
--- a/.version
+++ b/.version
@ -1 +0,0 @@
 2.90.0
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -1,76 +0,0 @@
 # Contributing to Nix
 Welcome and thank you for your interest in contributing to Nix!
 We appreciate your support.
 Reading and following these guidelines will help us make the contribution process easy and effective for everyone involved.
 ## Report a bug
 1. Check on the [GitHub issue tracker](https://github.com/NixOS/nix/issues) if your bug was already reported.
 2. If you were not able to find the bug or feature [open a new issue](https://github.com/NixOS/nix/issues/new/choose)
 3. The issue templates will guide you in specifying your issue.
   The more complete the information you provide, the more likely it can be found by others and the more useful it is in the future.
   Make sure reported bugs can be reproduced easily.
 4. Once submitted, do not expect issues to be picked up or solved right away.
   The only way to ensure this, is to [work on the issue yourself](#making-changes-to-nix).
 ## Report a security vulnerability
 Check out the [security policy](https://github.com/NixOS/nix/security/policy).
 ## Making changes to Nix
 1. Check for [pull requests](https://github.com/NixOS/nix/pulls) that might already cover the contribution you are about to make.
   There are many open pull requests that might already do what you intent to work on.
   You can use [labels](https://github.com/NixOS/nix/labels) to filter for relevant topics.
 2. Search for related issues that cover what you're going to work on. It could help to mention there that you will work on the issue.
   Issues labeled [good first issue](https://github.com/NixOS/nix/labels/good-first-issue) should be relatively easy to fix and are likely to get merged quickly.
   Pull requests addressing issues labeled [idea approved](https://github.com/NixOS/nix/labels/idea%20approved) are especially welcomed by maintainers and will receive prioritised review.
 3. Check the [Nix reference manual](https://nixos.org/manual/nix/unstable/contributing/hacking.html) for information on building Nix and running its tests.
   For contributions to the command line interface, please check the [CLI guidelines](https://nixos.org/manual/nix/unstable/contributing/cli-guideline.html).
 4. Make your changes!
 5. [Create a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) for your changes.
   * Link related issues in your pull request to inform interested parties and future contributors about your change.
   * Make sure to have [a clean history of commits on your branch by using rebase](https://www.digitalocean.com/community/tutorials/how-to-rebase-and-update-a-pull-request).
     If your pull request closes one or multiple issues, note that in the description using `Closes: #<number>`, as it will then happen automatically when your change is merged.
   * [Mark the pull request as draft](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/changing-the-stage-of-a-pull-request) if you're not done with the changes.
 6. Do not expect your pull request to be reviewed immediately.
   Nix maintainers follow a [structured process for reviews and design decisions](https://github.com/NixOS/nix/tree/master/maintainers#project-board-protocol), which may or may not prioritise your work.
   Following this checklist will make the process smoother for everyone:
   - [ ] Fixes an [idea approved](https://github.com/NixOS/nix/labels/idea%20approved) issue
   - [ ] Tests, as appropriate:
     - Functional tests – [`tests/functional/**.sh`](./tests/functional)
     - Unit tests – [`src/*/tests`](./src/)
     - Integration tests – [`tests/nixos/*`](./tests/nixos)
   - [ ] User documentation in the [manual](..doc/manual/src)
   - [ ] API documentation in header files
   - [ ] Code and comments are self-explanatory
   - [ ] Commit message explains **why** the change was made
   - [ ] New feature or incompatible change: updated [release notes](./doc/manual/src/release-notes/rl-next.md)
 7. If you need additional feedback or help to getting pull request into shape, ask other contributors using [@mentions](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#mentioning-people-and-teams).
 ## Making changes to the Nix manual
 The Nix reference manual is hosted on https://nixos.org/manual/nix.
 The underlying source files are located in [`doc/manual/src`](./doc/manual/src).
 For small changes you can [use GitHub to edit these files](https://docs.github.com/en/repositories/working-with-files/managing-files/editing-files)
 For larger changes see the [Nix reference manual](https://nixos.org/manual/nix/unstable/contributing/hacking.html).
 ## Getting help
 Whenever you're stuck or do not know how to proceed, you can always ask for help.
 The appropriate channels to do so can be found on the [NixOS Community](https://nixos.org/community/) page.
--- a/502
+++ b/502
@ -1,502 +0,0 @@
 		  GNU LESSER GENERAL PUBLIC LICENSE
 		       Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 Licenses are intended to guarantee your freedom to share and change
 free software--to make sure the software is free for all its users.
  This license, the Lesser General Public License, applies to some
 specially designated software packages--typically libraries--of the
 Free Software Foundation and other authors who decide to use it.  You
 can use it too, but we suggest you first think carefully about whether
 this license or the ordinary General Public License is the better
 strategy to use in any particular case, based on the explanations below.
  When we speak of free software, we are referring to freedom of use,
 not price.  Our General Public Licenses are designed to make sure that
 you have the freedom to distribute copies of free software (and charge
 for this service if you wish); that you receive source code or can get
 it if you want it; that you can change the software and use pieces of
 it in new free programs; and that you are informed that you can do
 these things.
  To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights.  These restrictions translate to certain responsibilities for
 you if you distribute copies of the library or if you modify it.
  For example, if you distribute copies of the library, whether gratis
 or for a fee, you must give the recipients all the rights that we gave
 you.  You must make sure that they, too, receive or can get the source
 code.  If you link other code with the library, you must provide
 complete object files to the recipients, so that they can relink them
 with the library after making changes to the library and recompiling
 it.  And you must show them these terms so they know their rights.
  We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
  To protect each distributor, we want to make it very clear that
 there is no warranty for the free library.  Also, if the library is
 modified by someone else and passed on, the recipients should know
 that what they have is not the original version, so that the original
 author's reputation will not be affected by problems that might be
 introduced by others.
  Finally, software patents pose a constant threat to the existence of
 any free program.  We wish to make sure that a company cannot
 effectively restrict the users of a free program by obtaining a
 restrictive license from a patent holder.  Therefore, we insist that
 any patent license obtained for a version of the library must be
 consistent with the full freedom of use specified in this license.
  Most GNU software, including some libraries, is covered by the
 ordinary GNU General Public License.  This license, the GNU Lesser
 General Public License, applies to certain designated libraries, and
 is quite different from the ordinary General Public License.  We use
 this license for certain libraries in order to permit linking those
 libraries into non-free programs.
  When a program is linked with a library, whether statically or using
 a shared library, the combination of the two is legally speaking a
 combined work, a derivative of the original library.  The ordinary
 General Public License therefore permits such linking only if the
 entire combination fits its criteria of freedom.  The Lesser General
 Public License permits more lax criteria for linking other code with
 the library.
  We call this license the "Lesser" General Public License because it
 does Less to protect the user's freedom than the ordinary General
 Public License.  It also provides other free software developers Less
 of an advantage over competing non-free programs.  These disadvantages
 are the reason we use the ordinary General Public License for many
 libraries.  However, the Lesser license provides advantages in certain
 special circumstances.
  For example, on rare occasions, there may be a special need to
 encourage the widest possible use of a certain library, so that it becomes
 a de-facto standard.  To achieve this, non-free programs must be
 allowed to use the library.  A more frequent case is that a free
 library does the same job as widely used non-free libraries.  In this
 case, there is little to gain by limiting the free library to free
 software only, so we use the Lesser General Public License.
  In other cases, permission to use a particular library in non-free
 programs enables a greater number of people to use a large body of
 free software.  For example, permission to use the GNU C Library in
 non-free programs enables many more people to use the whole GNU
 operating system, as well as its variant, the GNU/Linux operating
 system.
  Although the Lesser General Public License is Less protective of the
 users' freedom, it does ensure that the user of a program that is
 linked with the Library has the freedom and the wherewithal to run
 that program using a modified version of the Library.
  The precise terms and conditions for copying, distribution and
 modification follow.  Pay close attention to the difference between a
 "work based on the library" and a "work that uses the library".  The
 former contains code derived from the library, whereas the latter must
 be combined with the library in order to run.
 		  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License Agreement applies to any software library or other
 program which contains a notice placed by the copyright holder or
 other authorized party saying it may be distributed under the terms of
 this Lesser General Public License (also called "this License").
 Each licensee is addressed as "you".
  A "library" means a collection of software functions and/or data
 prepared so as to be conveniently linked with application programs
 (which use some of those functions and data) to form executables.
  The "Library", below, refers to any such software library or work
 which has been distributed under these terms.  A "work based on the
 Library" means either the Library or any derivative work under
 copyright law: that is to say, a work containing the Library or a
 portion of it, either verbatim or with modifications and/or translated
 straightforwardly into another language.  (Hereinafter, translation is
 included without limitation in the term "modification".)
  "Source code" for a work means the preferred form of the work for
 making modifications to it.  For a library, complete source code means
 all the source code for all modules it contains, plus any associated
 interface definition files, plus the scripts used to control compilation
 and installation of the library.
  Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running a program using the Library is not restricted, and output from
 such a program is covered only if its contents constitute a work based
 on the Library (independent of the use of the Library in a tool for
 writing it).  Whether that is true depends on what the Library does
 and what the program that uses the Library does.
  1. You may copy and distribute verbatim copies of the Library's
 complete source code as you receive it, in any medium, provided that
 you conspicuously and appropriately publish on each copy an
 appropriate copyright notice and disclaimer of warranty; keep intact
 all the notices that refer to this License and to the absence of any
 warranty; and distribute a copy of this License along with the
 Library.
  You may charge a fee for the physical act of transferring a copy,
 and you may at your option offer warranty protection in exchange for a
 fee.
  2. You may modify your copy or copies of the Library or any portion
 of it, thus forming a work based on the Library, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) The modified work must itself be a software library.
    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.
    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.
    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.
    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Library,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Library, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote
 it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Library.
 In addition, mere aggregation of another work not based on the Library
 with the Library (or with a work based on the Library) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may opt to apply the terms of the ordinary GNU General Public
 License instead of this License to a given copy of the Library.  To do
 this, you must alter all the notices that refer to this License, so
 that they refer to the ordinary GNU General Public License, version 2,
 instead of to this License.  (If a newer version than version 2 of the
 ordinary GNU General Public License has appeared, then you can specify
 that version instead if you wish.)  Do not make any other change in
 these notices.
  Once this change is made in a given copy, it is irreversible for
 that copy, so the ordinary GNU General Public License applies to all
 subsequent copies and derivative works made from that copy.
  This option is useful when you wish to copy part of the code of
 the Library into a program that is not a library.
  4. You may copy and distribute the Library (or a portion or
 derivative of it, under Section 2) in object code or executable form
 under the terms of Sections 1 and 2 above provided that you accompany
 it with the complete corresponding machine-readable source code, which
 must be distributed under the terms of Sections 1 and 2 above on a
 medium customarily used for software interchange.
  If distribution of object code is made by offering access to copy
 from a designated place, then offering equivalent access to copy the
 source code from the same place satisfies the requirement to
 distribute the source code, even though third parties are not
 compelled to copy the source along with the object code.
  5. A program that contains no derivative of any portion of the
 Library, but is designed to work with the Library by being compiled or
 linked with it, is called a "work that uses the Library".  Such a
 work, in isolation, is not a derivative work of the Library, and
 therefore falls outside the scope of this License.
  However, linking a "work that uses the Library" with the Library
 creates an executable that is a derivative of the Library (because it
 contains portions of the Library), rather than a "work that uses the
 library".  The executable is therefore covered by this License.
 Section 6 states terms for distribution of such executables.
  When a "work that uses the Library" uses material from a header file
 that is part of the Library, the object code for the work may be a
 derivative work of the Library even though the source code is not.
 Whether this is true is especially significant if the work can be
 linked without the Library, or if the work is itself a library.  The
 threshold for this to be true is not precisely defined by law.
  If such an object file uses only numerical parameters, data
 structure layouts and accessors, and small macros and small inline
 functions (ten lines or less in length), then the use of the object
 file is unrestricted, regardless of whether it is legally a derivative
 work.  (Executables containing this object code plus portions of the
 Library will still fall under Section 6.)
  Otherwise, if the work is a derivative of the Library, you may
 distribute the object code for the work under the terms of Section 6.
 Any executables containing that work also fall under Section 6,
 whether or not they are linked directly with the Library itself.
  6. As an exception to the Sections above, you may also combine or
 link a "work that uses the Library" with the Library to produce a
 work containing portions of the Library, and distribute that work
 under terms of your choice, provided that the terms permit
 modification of the work for the customer's own use and reverse
 engineering for debugging such modifications.
  You must give prominent notice with each copy of the work that the
 Library is used in it and that the Library and its use are covered by
 this License.  You must supply a copy of this License.  If the work
 during execution displays copyright notices, you must include the
 copyright notice for the Library among them, as well as a reference
 directing the user to the copy of this License.  Also, you must do one
 of these things:
    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)
    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.
    c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.
    d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.
    e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.
  For an executable, the required form of the "work that uses the
 Library" must include any data and utility programs needed for
 reproducing the executable from it.  However, as a special exception,
 the materials to be distributed need not include anything that is
 normally distributed (in either source or binary form) with the major
 components (compiler, kernel, and so on) of the operating system on
 which the executable runs, unless that component itself accompanies
 the executable.
  It may happen that this requirement contradicts the license
 restrictions of other proprietary libraries that do not normally
 accompany the operating system.  Such a contradiction means you cannot
 use both them and the Library together in an executable that you
 distribute.
  7. You may place library facilities that are a work based on the
 Library side-by-side in a single library together with other library
 facilities not covered by this License, and distribute such a combined
 library, provided that the separate distribution of the work based on
 the Library and of the other library facilities is otherwise
 permitted, and provided that you do these two things:
    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.
    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.
  8. You may not copy, modify, sublicense, link with, or distribute
 the Library except as expressly provided under this License.  Any
 attempt otherwise to copy, modify, sublicense, link with, or
 distribute the Library is void, and will automatically terminate your
 rights under this License.  However, parties who have received copies,
 or rights, from you under this License will not have their licenses
 terminated so long as such parties remain in full compliance.
  9. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Library or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Library (or any work based on the
 Library), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Library or works based on it.
  10. Each time you redistribute the Library (or any work based on the
 Library), the recipient automatically receives a license from the
 original licensor to copy, distribute, link with or modify the Library
 subject to these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties with
 this License.
  11. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Library at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Library by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Library.
 If any portion of this section is held invalid or unenforceable under any
 particular circumstance, the balance of the section is intended to apply,
 and the section as a whole is intended to apply in other circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  12. If the distribution and/or use of the Library is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Library under this License may add
 an explicit geographical distribution limitation excluding those countries,
 so that distribution is permitted only in or among countries not thus
 excluded.  In such case, this License incorporates the limitation as if
 written in the body of this License.
  13. The Free Software Foundation may publish revised and/or new
 versions of the Lesser General Public License from time to time.
 Such new versions will be similar in spirit to the present version,
 but may differ in detail to address new problems or concerns.
 Each version is given a distinguishing version number.  If the Library
 specifies a version number of this License which applies to it and
 "any later version", you have the option of following the terms and
 conditions either of that version or of any later version published by
 the Free Software Foundation.  If the Library does not specify a
 license version number, you may choose any version ever published by
 the Free Software Foundation.
  14. If you wish to incorporate parts of the Library into other free
 programs whose distribution conditions are incompatible with these,
 write to the author to ask for permission.  For software which is
 copyrighted by the Free Software Foundation, write to the Free
 Software Foundation; we sometimes make exceptions for this.  Our
 decision will be guided by the two goals of preserving the free status
 of all derivatives of our free software and of promoting the sharing
 and reuse of software generally.
 			    NO WARRANTY
  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
 WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
 EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
 OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
 KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
 LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
 THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
 WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
 AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
 FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
 CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
 LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
 RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
 FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGES.
 		     END OF TERMS AND CONDITIONS
           How to Apply These Terms to Your New Libraries
  If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change.  You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
  To apply these terms, attach the following notices to the library.  It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
    <one line to give the library's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
  <signature of Ty Coon>, 1 April 1990
  Ty Coon, President of Vice
 That's all there is to it!
--- a/71
+++ b/71
@ -1,71 +0,0 @@
 include mk/build-dir.mk
 -include $(buildprefix)Makefile.config
 clean-files += $(buildprefix)Makefile.config
 ifeq ($(ENABLE_BUILD), yes)
 makefiles = \
  mk/precompiled-headers.mk \
  local.mk \
  src/libutil/local.mk \
  src/libstore/local.mk \
  src/libfetchers/local.mk \
  src/libmain/local.mk \
  src/libexpr/local.mk \
  src/libcmd/local.mk \
  src/nix/local.mk \
  src/resolve-system-dependencies/local.mk \
  scripts/local.mk \
  misc/bash/local.mk \
  misc/fish/local.mk \
  misc/zsh/local.mk \
  misc/systemd/local.mk \
  misc/launchd/local.mk
 endif
 ifeq ($(ENABLE_BUILD)_$(ENABLE_TESTS), yes_yes)
 UNIT_TEST_ENV = _NIX_TEST_UNIT_DATA=unit-test-data
 makefiles += \
  tests/unit/libutil/local.mk \
  tests/unit/libutil-support/local.mk \
  tests/unit/libstore/local.mk
 endif
 ifeq ($(ENABLE_TESTS), yes)
 makefiles += \
  tests/unit/libstore-support/local.mk \
  tests/unit/libexpr/local.mk \
  tests/unit/libexpr-support/local.mk \
  tests/functional/local.mk \
  tests/functional/ca/local.mk \
  tests/functional/dyn-drv/local.mk \
  tests/functional/test-libstoreconsumer/local.mk \
  tests/functional/repl_characterization/local.mk \
  tests/functional/plugins/local.mk
 else
 makefiles += \
  mk/disable-tests.mk
 endif
 # Some makefiles require access to built programs and must be included late.
 makefiles-late =
 ifeq ($(ENABLE_BUILD), yes)
 makefiles-late += doc/manual/local.mk
 makefiles-late += doc/internal-api/local.mk
 endif
 # Miscellaneous global Flags
 OPTIMIZE = 1
 ifeq ($(OPTIMIZE), 1)
  GLOBAL_CXXFLAGS += -O2 $(CXXLTO)
  GLOBAL_LDFLAGS += $(CXXLTO)
 else
  GLOBAL_CXXFLAGS += -O0 -U_FORTIFY_SOURCE
 endif
 include mk/lib.mk
 GLOBAL_CXXFLAGS += -g -Wall -Wimplicit-fallthrough -include $(buildprefix)config.h -std=c++2a -I src
--- a/Makefile.config.in
+++ b/Makefile.config.in
@ -1,52 +0,0 @@
 AR = @AR@
 BDW_GC_LIBS = @BDW_GC_LIBS@
 BOOST_LDFLAGS = @BOOST_LDFLAGS@
 BUILD_SHARED_LIBS = @BUILD_SHARED_LIBS@
 CC = @CC@
 CFLAGS = @CFLAGS@
 CXX = @CXX@
 CXXFLAGS = @CXXFLAGS@
 CXXLTO = @CXXLTO@
 EDITLINE_LIBS = @EDITLINE_LIBS@
 ENABLE_S3 = @ENABLE_S3@
 GTEST_LIBS = @GTEST_LIBS@
 HAVE_LIBCPUID = @HAVE_LIBCPUID@
 HAVE_SECCOMP = @HAVE_SECCOMP@
 HOST_OS = @host_os@
 LDFLAGS = @LDFLAGS@
 LIBARCHIVE_LIBS = @LIBARCHIVE_LIBS@
 LIBBROTLI_LIBS = @LIBBROTLI_LIBS@
 LIBCURL_LIBS = @LIBCURL_LIBS@
 LIBSECCOMP_LIBS = @LIBSECCOMP_LIBS@
 LOWDOWN_LIBS = @LOWDOWN_LIBS@
 NIXDOC_LIBS = -lnix_doc
 OPENSSL_LIBS = @OPENSSL_LIBS@
 PACKAGE_NAME = @PACKAGE_NAME@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 RAPIDCHECK_HEADERS = @RAPIDCHECK_HEADERS@
 SHELL = @bash@
 SODIUM_LIBS = @SODIUM_LIBS@
 SQLITE3_LIBS = @SQLITE3_LIBS@
 bash = @bash@
 bindir = @bindir@
 datadir = @datadir@
 datarootdir = @datarootdir@
 doc_generate = @doc_generate@
 docdir = @docdir@
 embedded_sandbox_shell = @embedded_sandbox_shell@
 exec_prefix = @exec_prefix@
 includedir = @includedir@
 libdir = @libdir@
 libexecdir = @libexecdir@
 localstatedir = @localstatedir@
 lsof = @lsof@
 mandir = @mandir@
 pkglibdir = $(libdir)/$(PACKAGE_NAME)
 prefix = @prefix@
 sandbox_shell = @sandbox_shell@
 storedir = @storedir@
 sysconfdir = @sysconfdir@
 system = @system@
 ENABLE_BUILD = @ENABLE_BUILD@
 ENABLE_TESTS = @ENABLE_TESTS@
 internal_api_docs = @internal_api_docs@
--- a/README.md
+++ b/README.md
@ -1,36 +0,0 @@
 # Nix
 [![Open Collective supporters](https://opencollective.com/nixos/tiers/supporter/badge.svg?label=Supporters&color=brightgreen)](https://opencollective.com/nixos)
 [![Test](https://github.com/NixOS/nix/workflows/Test/badge.svg)](https://github.com/NixOS/nix/actions)
 Nix is a powerful package manager for Linux and other Unix systems that makes package
 management reliable and reproducible. Please refer to the [Nix manual](https://nixos.org/nix/manual)
 for more details.
 ## Installation
 On Linux and macOS the easiest way to install Nix is to run the following shell command
 (as a user other than root):
 ```console
 $ curl -L https://nixos.org/nix/install | sh
 ```
 Information on additional installation methods is available on the [Nix download page](https://nixos.org/download.html).
 ## Building And Developing
 See our [Hacking guide](https://nixos.org/manual/nix/unstable/contributing/hacking.html) in our manual for instruction on how to
 to set up a development environment and build Nix from source.
 ## Additional Resources
 - [Nix manual](https://nixos.org/nix/manual)
 - [Nix jobsets on hydra.nixos.org](https://hydra.nixos.org/project/nix)
 - [NixOS Discourse](https://discourse.nixos.org/)
 - [Matrix - #nix:nixos.org](https://matrix.to/#/#nix:nixos.org)
 - [IRC - #nixos on libera.chat](irc://irc.libera.chat/#nixos)
 ## License
 Nix is released under the [LGPL v2.1](./COPYING).
--- a/1
+++ b/1
@ -0,0 +1 @@
 Subproject commit 08713d5a15799b4bd099e702a407c37c9bf78663
--- a/boehmgc-coroutine-sp-fallback.diff
+++ b/boehmgc-coroutine-sp-fallback.diff
@ -1,99 +0,0 @@
 diff --git a/darwin_stop_world.c b/darwin_stop_world.c
 index 0468aaec..b348d869 100644
 --- a/darwin_stop_world.c
 +++ b/darwin_stop_world.c
@@ -356,6 +356,7 @@ GC_INNER void GC_push_all_stacks(void)
   int nthreads = 0;
   word total_size = 0;
   mach_msg_type_number_t listcount = (mach_msg_type_number_t)THREAD_TABLE_SZ;
 +  size_t stack_limit;
   if (!EXPECT(GC_thr_initialized, TRUE))
     GC_thr_init();
@@ -411,6 +412,19 @@ GC_INNER void GC_push_all_stacks(void)
             GC_push_all_stack_sections(lo, hi, p->traced_stack_sect);
           }
           if (altstack_lo) {
 +            // When a thread goes into a coroutine, we lose its original sp until
 +            // control flow returns to the thread.
 +            // While in the coroutine, the sp points outside the thread stack,
 +            // so we can detect this and push the entire thread stack instead,
 +            // as an approximation.
 +            // We assume that the coroutine has similarly added its entire stack.
 +            // This could be made accurate by cooperating with the application
 +            // via new functions and/or callbacks.
 +            stack_limit = pthread_get_stacksize_np(p->id);
 +            if (altstack_lo >= altstack_hi || altstack_lo < altstack_hi - stack_limit) { // sp outside stack
 +              altstack_lo = altstack_hi - stack_limit;
 +            }
 +
             total_size += altstack_hi - altstack_lo;
             GC_push_all_stack(altstack_lo, altstack_hi);
           }
 diff --git a/include/gc.h b/include/gc.h
 index edab6c22..f2c61282 100644
 --- a/include/gc.h
 +++ b/include/gc.h
@@ -2172,6 +2172,11 @@ GC_API void GC_CALL GC_win32_free_heap(void);
         (*GC_amiga_allocwrapper_do)(a,GC_malloc_atomic_ignore_off_page)
 #endif /* _AMIGA && !GC_AMIGA_MAKINGLIB */
 +#if !__APPLE__
 +/* Patch doesn't work on apple */
 +#define NIX_BOEHM_PATCH_VERSION 1
 +#endif
 +
 #ifdef __cplusplus
   } /* extern "C" */
 #endif
 diff --git a/pthread_stop_world.c b/pthread_stop_world.c
 index b5d71e62..aed7b0bf 100644
 --- a/pthread_stop_world.c
 +++ b/pthread_stop_world.c
@@ -768,6 +768,8 @@ STATIC void GC_restart_handler(int sig)
 /* world is stopped.  Should not fail if it isn't.                      */
 GC_INNER void GC_push_all_stacks(void)
 {
 +    size_t stack_limit;
 +    pthread_attr_t pattr;
     GC_bool found_me = FALSE;
     size_t nthreads = 0;
     int i;
@@ -851,6 +853,37 @@ GC_INNER void GC_push_all_stacks(void)
           hi = p->altstack + p->altstack_size;
           /* FIXME: Need to scan the normal stack too, but how ? */
           /* FIXME: Assume stack grows down */
 +        } else {
 +#ifdef HAVE_PTHREAD_ATTR_GET_NP
 +          if (!pthread_attr_init(&pattr)
 +              || !pthread_attr_get_np(p->id, &pattr))
 +#else /* HAVE_PTHREAD_GETATTR_NP */
 +          if (pthread_getattr_np(p->id, &pattr))
 +#endif
 +          {
 +            ABORT("GC_push_all_stacks: pthread_getattr_np failed!");
 +          }
 +          if (pthread_attr_getstacksize(&pattr, &stack_limit)) {
 +            ABORT("GC_push_all_stacks: pthread_attr_getstacksize failed!");
 +          }
 +          if (pthread_attr_destroy(&pattr)) {
 +            ABORT("GC_push_all_stacks: pthread_attr_destroy failed!");
 +          }
 +          // When a thread goes into a coroutine, we lose its original sp until
 +          // control flow returns to the thread.
 +          // While in the coroutine, the sp points outside the thread stack,
 +          // so we can detect this and push the entire thread stack instead,
 +          // as an approximation.
 +          // We assume that the coroutine has similarly added its entire stack.
 +          // This could be made accurate by cooperating with the application
 +          // via new functions and/or callbacks.
 +          #ifndef STACK_GROWS_UP
 +            if (lo >= hi || lo < hi - stack_limit) { // sp outside stack
 +              lo = hi - stack_limit;
 +            }
 +          #else
 +          #error "STACK_GROWS_UP not supported in boost_coroutine2 (as of june 2021), so we don't support it in Nix."
 +          #endif
         }
         GC_push_all_stack_sections(lo, hi, traced_stack_sect);
 #       ifdef STACK_GROWS_UP
--- a/boehmgc-traceable_allocator-public.diff
+++ b/boehmgc-traceable_allocator-public.diff
@ -1,12 +0,0 @@
 diff --git a/include/gc_allocator.h b/include/gc_allocator.h
 index 597c7f13..587286be 100644
 --- a/include/gc_allocator.h
 +++ b/include/gc_allocator.h
@@ -312,6 +312,7 @@ public:
 template<>
 class traceable_allocator<void> {
 +public:
   typedef size_t      size_type;
   typedef ptrdiff_t   difference_type;
   typedef void*       pointer;
--- a/clang-tidy/.clang-format
+++ b/clang-tidy/.clang-format
@ -1 +0,0 @@
 BasedOnStyle: llvm
--- a/clang-tidy/.editorconfig
+++ b/clang-tidy/.editorconfig
@ -1,4 +0,0 @@
 # LLVM style code is 2-space indented
 [*.{cc,hh}]
 indent_style = space
 indent_size = 2
--- a/clang-tidy/FixIncludes.cc
+++ b/clang-tidy/FixIncludes.cc
@ -1,81 +0,0 @@
 #include "FixIncludes.hh"
 #include <clang-tidy/ClangTidyCheck.h>
 #include <clang/Basic/Diagnostic.h>
 #include <clang/Basic/SourceManager.h>
 #include <clang/Lex/PPCallbacks.h>
 #include <clang/Lex/Preprocessor.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/Debug.h>
 #include <memory>
 #include <set>
 #include <string>
 namespace nix::clang_tidy {
 using namespace clang;
 using namespace clang::tidy;
 class FixIncludesCallbacks : public PPCallbacks {
 public:
  ClangTidyCheck &Check;
  Preprocessor &PP;
  FixIncludesCallbacks(ClangTidyCheck &Check, Preprocessor &PP)
      : Check(Check), PP(PP) {}
 private:
  bool Ignore = false;
  virtual void LexedFileChanged(FileID FID, LexedFileChangeReason Reason,
                                SrcMgr::CharacteristicKind FileType,
                                FileID PrevFID, SourceLocation Loc) override;
  virtual void InclusionDirective(SourceLocation HashLoc,
                                  const Token &IncludeTok, StringRef FileName,
                                  bool IsAngled, CharSourceRange FilenameRange,
                                  OptionalFileEntryRef File,
                                  StringRef SearchPath, StringRef RelativePath,
                                  const Module *Imported,
                                  SrcMgr::CharacteristicKind FileType) override;
 };
 void FixIncludesCallbacks::LexedFileChanged(FileID, LexedFileChangeReason,
                                            SrcMgr::CharacteristicKind FileType,
                                            FileID, SourceLocation) {
  Ignore = FileType != SrcMgr::C_User;
 }
 void FixIncludesCallbacks::InclusionDirective(
    SourceLocation, const Token &, StringRef, bool,
    CharSourceRange FilenameRange, OptionalFileEntryRef File, StringRef,
    StringRef, const Module *, SrcMgr::CharacteristicKind) {
  if (Ignore)
    return;
  // FIXME: this is kinda evil, but this is a one-time fixup
  const std::string SourceDir = "src/";
  if (File && File->getNameAsRequested().contains(SourceDir)) {
    StringRef Name = File->getNameAsRequested();
    auto Idx = Name.find(SourceDir);
    assert(Idx != std::string::npos);
    StringRef Suffix = Name.drop_front(Idx + SourceDir.length());
    if (!Suffix.starts_with("lib")) {
      llvm::dbgs() << "ignored: " << Suffix << "\n";
      return;
    }
    auto Diag = Check.diag(FilenameRange.getBegin(),
                           "include needs to specify the source subdir");
    Diag << FilenameRange
         << FixItHint::CreateReplacement(FilenameRange,
                                         ("\"" + Suffix + "\"").str());
  }
 }
 void FixIncludesCheck::registerPPCallbacks(const SourceManager &,
                                           Preprocessor *PP, Preprocessor *) {
  PP->addPPCallbacks(std::make_unique<FixIncludesCallbacks>(*this, *PP));
 }
 }; // namespace nix::clang_tidy
--- a/clang-tidy/FixIncludes.hh
+++ b/clang-tidy/FixIncludes.hh
@ -1,21 +0,0 @@
 #pragma once
 ///@file
 #include <clang-tidy/ClangTidyCheck.h>
 #include <clang/ASTMatchers/ASTMatchFinder.h>
 #include <llvm/ADT/StringRef.h>
 namespace nix::clang_tidy {
 using namespace clang;
 using namespace clang::tidy;
 class FixIncludesCheck : public ClangTidyCheck {
    public:
    FixIncludesCheck(StringRef Name, ClangTidyContext *Context)
            : ClangTidyCheck(Name, Context) {}
    void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) override;
 };
 };
--- a/clang-tidy/HasPrefixSuffix.cc
+++ b/clang-tidy/HasPrefixSuffix.cc
@ -1,80 +0,0 @@
 #include "HasPrefixSuffix.hh"
 #include <clang/AST/ASTTypeTraits.h>
 #include <clang/AST/Expr.h>
 #include <clang/AST/PrettyPrinter.h>
 #include <clang/AST/Type.h>
 #include <clang/ASTMatchers/ASTMatchers.h>
 #include <clang/Basic/Diagnostic.h>
 #include <clang/Frontend/FrontendAction.h>
 #include <clang/Frontend/FrontendPluginRegistry.h>
 #include <clang/Tooling/Transformer/SourceCode.h>
 #include <clang/Tooling/Transformer/SourceCodeBuilders.h>
 #include <iostream>
 namespace nix::clang_tidy {
 using namespace clang::ast_matchers;
 using namespace clang;
 void HasPrefixSuffixCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
  Finder->addMatcher(
      traverse(clang::TK_AsIs,
               callExpr(callee(functionDecl(anyOf(hasName("hasPrefix"),
                                                  hasName("hasSuffix")))
                                   .bind("callee-decl")),
                        optionally(hasArgument(
                            0, cxxConstructExpr(
                                   hasDeclaration(functionDecl(hasParameter(
                                       0, parmVarDecl(hasType(
                                              asString("const char *")))))))
                                   .bind("implicit-cast"))))
                   .bind("call")),
      this);
 }
 void HasPrefixSuffixCheck::check(
    const ast_matchers::MatchFinder::MatchResult &Result) {
  const auto *CalleeDecl = Result.Nodes.getNodeAs<FunctionDecl>("callee-decl");
  auto FuncName = std::string(CalleeDecl->getName());
  std::string NewName;
  if (FuncName == "hasPrefix") {
    NewName = "starts_with";
  } else if (FuncName == "hasSuffix") {
    NewName = "ends_with";
  } else {
    llvm_unreachable("nix-has-prefix: invalid callee");
  }
  const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("call");
  const auto *ImplicitConvertArg =
      Result.Nodes.getNodeAs<CXXConstructExpr>("implicit-cast");
  const auto *Lhs = MatchedDecl->getArg(0);
  const auto *Rhs = MatchedDecl->getArg(1);
  auto Diag = diag(MatchedDecl->getExprLoc(), FuncName + " is deprecated");
  std::string Text = "";
  // Form possible cast to string_view, or nothing.
  if (ImplicitConvertArg) {
    Text = "std::string_view(";
    Text.append(tooling::getText(*Lhs, *Result.Context));
    Text.append(").");
  } else {
    Text.append(*tooling::buildAccess(*Lhs, *Result.Context));
  }
  // Call .starts_with.
  Text.append(NewName);
  Text.push_back('(');
  Text.append(tooling::getText(*Rhs, *Result.Context));
  Text.push_back(')');
  Diag << FixItHint::CreateReplacement(MatchedDecl->getSourceRange(), Text);
  // for (const auto *arg : MatchedDecl->arguments()) {
  //   arg->dumpColor();
  //   arg->getType().dump();
  // }
 }
 }; // namespace nix::clang_tidy
--- a/clang-tidy/HasPrefixSuffix.hh
+++ b/clang-tidy/HasPrefixSuffix.hh
@ -1,25 +0,0 @@
 #pragma once
 ///@file
 /// This is an example of a clang-tidy automated refactoring against the Nix
 /// codebase. The refactoring has been completed in
 /// https://gerrit.lix.systems/c/lix/+/565 so this code is around as
 /// an example.
 #include <clang-tidy/ClangTidyCheck.h>
 #include <clang/ASTMatchers/ASTMatchFinder.h>
 #include <llvm/ADT/StringRef.h>
 namespace nix::clang_tidy {
 using namespace clang;
 using namespace clang::tidy;
 using namespace llvm;
 class HasPrefixSuffixCheck : public ClangTidyCheck {
 public:
  HasPrefixSuffixCheck(StringRef Name, ClangTidyContext *Context)
      : ClangTidyCheck(Name, Context) {}
  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 }; // namespace nix::clang_tidy
--- a/clang-tidy/LixClangTidyChecks.cc
+++ b/clang-tidy/LixClangTidyChecks.cc
@ -1,19 +0,0 @@
 #include <clang-tidy/ClangTidyModule.h>
 #include <clang-tidy/ClangTidyModuleRegistry.h>
 #include "FixIncludes.hh"
 #include "HasPrefixSuffix.hh"
 namespace nix::clang_tidy {
 using namespace clang;
 using namespace clang::tidy;
 class NixClangTidyChecks : public ClangTidyModule {
    public:
        void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
            CheckFactories.registerCheck<HasPrefixSuffixCheck>("lix-hasprefixsuffix");
            CheckFactories.registerCheck<FixIncludesCheck>("lix-fixincludes");
        }
 };
 static ClangTidyModuleRegistry::Add<NixClangTidyChecks> X("lix-module", "Adds lix specific checks");
 };
--- a/clang-tidy/README.md
+++ b/clang-tidy/README.md
@ -1,56 +0,0 @@
 # Clang tidy lints for Nix
 This is a skeleton of a clang-tidy lints library for Nix.
 Currently there is one check (which is already obsolete as it has served its
 goal and is there as an example), `HasPrefixSuffixCheck`.
 ## Running fixes/checks
 One file:
 ```
 ninja -C build && clang-tidy --checks='-*,nix-*' --load=build/libnix-clang-tidy.so -p ../compile_commands.json --fix ../src/libcmd/installables.cc
 ```
 Several files, in parallel:
 ```
 ninja -C build && run-clang-tidy -checks='-*,nix-*' -load=build/libnix-clang-tidy.so -p .. -fix ../src | tee -a clang-tidy-result
 ```
 ## Resources
 * https://firefox-source-docs.mozilla.org/code-quality/static-analysis/writing-new/clang-query.html
 * https://clang.llvm.org/docs/LibASTMatchersReference.html
 * https://devblogs.microsoft.com/cppblog/exploring-clang-tooling-part-3-rewriting-code-with-clang-tidy/
 ## Developing new checks
 Put something like so in `myquery.txt`:
 ```
 set traversal     IgnoreUnlessSpelledInSource
 # ^ Ignore implicit AST nodes. May need to use AsIs depending on how you are
 # working.
 set bind-root     true
 # ^ true unless you use any .bind("foo") commands
 set print-matcher true
 enable output     dump
 match callExpr(callee(functionDecl(hasName("hasPrefix"))), optionally(hasArgument( 0, cxxConstructExpr(hasDeclaration(functionDecl(hasParameter(0, parmVarDecl(hasType(asString("const char *"))).bind("meow2"))))))))
 ```
 Then run, e.g. `clang-query --preload hasprefix.query -p compile_commands.json src/libcmd/installables.cc`.
 With this you can iterate a query before writing it in C++ and suffering from
 C++.
 ### Tips and tricks for the C++
 There is a function `dump()` on many things that will dump to stderr. Also
 `llvm::errs()` lets you print to stderr.
 When I wrote `HasPrefixSuffixCheck`, I was not really able to figure out how
 the structured replacement system was supposed to work. In principle you can
 describe the replacement with a nice DSL. Look up the Stencil system in Clang
 for details.
--- a/clang-tidy/meson.build
+++ b/clang-tidy/meson.build
@ -1,13 +0,0 @@
 project('lix-clang-tidy', ['cpp', 'c'],
  version : '0.1',
  default_options : ['warning_level=3', 'cpp_std=c++20'])
 llvm = dependency('Clang', version: '>= 14', modules: ['libclang'])
 sources = files(
  'HasPrefixSuffix.cc',
  'LixClangTidyChecks.cc',
  'FixIncludes.cc',
 )
 shared_module('lix-clang-tidy', sources,
  dependencies: llvm)
--- a/configure.ac
+++ b/configure.ac
@ -1,396 +0,0 @@
 AC_INIT([nix],[m4_esyscmd(bash -c "echo -n $(cat ./.version)$VERSION_SUFFIX")])
 AC_CONFIG_MACRO_DIRS([m4])
 AC_CONFIG_SRCDIR(README.md)
 AC_CONFIG_AUX_DIR(config)
 AC_PROG_SED
 # Construct a Nix system name (like "i686-linux"):
 # https://www.gnu.org/software/autoconf/manual/html_node/Canonicalizing.html#index-AC_005fCANONICAL_005fHOST-1
 # The inital value is produced by the `config/config.guess` script:
 # upstream: https://git.savannah.gnu.org/cgit/config.git/tree/config.guess
 # It has the following form, which is not documented anywhere:
 # <cpu>-<vendor>-<os>[<version>][-<abi>]
 # If `./configure` is passed any of the `--host`, `--build`, `--target` options, the value comes from `config/config.sub` instead:
 # upstream: https://git.savannah.gnu.org/cgit/config.git/tree/config.sub
 AC_CANONICAL_HOST
 AC_MSG_CHECKING([for the canonical Nix system name])
 AC_ARG_WITH(system, AS_HELP_STRING([--with-system=SYSTEM],[Platform identifier (e.g., `i686-linux').]),
  [system=$withval],
  [case "$host_cpu" in
     i*86)
        machine_name="i686";;
     amd64)
        machine_name="x86_64";;
     armv6|armv7)
        machine_name="${host_cpu}l";;
     *)
        machine_name="$host_cpu";;
   esac
   case "$host_os" in
     linux-gnu*|linux-musl*)
        # For backward compatibility, strip the `-gnu' part.
        system="$machine_name-linux";;
     *)
        # Strip the version number from names such as `gnu0.3',
        # `darwin10.2.0', etc.
        system="$machine_name-`echo $host_os | "$SED" -e's/@<:@0-9.@:>@*$//g'`";;
   esac])
 AC_MSG_RESULT($system)
 AC_SUBST(system)
 AC_DEFINE_UNQUOTED(SYSTEM, ["$system"], [platform identifier ('cpu-os')])
 # State should be stored in /nix/var, unless the user overrides it explicitly.
 test "$localstatedir" = '${prefix}/var' && localstatedir=/nix/var
 # Assign a default value to C{,XX}FLAGS as the default configure script sets them
 # to -O2 otherwise, which we don't want to have hardcoded
 CFLAGS=${CFLAGS-""}
 CXXFLAGS=${CXXFLAGS-""}
 AC_PROG_CC
 AC_PROG_CXX
 AC_PROG_CPP
 AC_CHECK_TOOL([AR], [ar])
 # Use 64-bit file system calls so that we can support files > 2 GiB.
 AC_SYS_LARGEFILE
 # Solaris-specific stuff.
 AC_STRUCT_DIRENT_D_TYPE
 case "$host_os" in
  solaris*)
    # Solaris requires -lsocket -lnsl for network functions
    LDFLAGS="-lsocket -lnsl $LDFLAGS"
    ;;
 esac
 ENSURE_NO_GCC_BUG_80431
 # Check for pubsetbuf.
 AC_MSG_CHECKING([for pubsetbuf])
 AC_LANG_PUSH(C++)
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <iostream>
 using namespace std;
 static char buf[1024];]],
    [[cerr.rdbuf()->pubsetbuf(buf, sizeof(buf));]])],
    [AC_MSG_RESULT(yes) AC_DEFINE(HAVE_PUBSETBUF, 1, [Whether pubsetbuf is available.])],
    AC_MSG_RESULT(no))
 AC_LANG_POP(C++)
 AC_CHECK_FUNCS([statvfs pipe2])
 # Check for lutimes, optionally used for changing the mtime of
 # symlinks.
 AC_CHECK_FUNCS([lutimes])
 # Check whether the store optimiser can optimise symlinks.
 AC_MSG_CHECKING([whether it is possible to create a link to a symlink])
 ln -s bla tmp_link
 if ln tmp_link tmp_link2 2> /dev/null; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(CAN_LINK_SYMLINK, 1, [Whether link() works on symlinks.])
 else
    AC_MSG_RESULT(no)
 fi
 rm -f tmp_link tmp_link2
 # Check for <locale>.
 AC_LANG_PUSH(C++)
 AC_CHECK_HEADERS([locale])
 AC_LANG_POP(C++)
 AC_DEFUN([NEED_PROG],
 [
 AC_PATH_PROG($1, $2)
 if test -z "$$1"; then
    AC_MSG_ERROR([$2 is required])
 fi
 ])
 NEED_PROG(bash, bash)
 AC_PATH_PROG(flex, flex, false)
 AC_PATH_PROG(bison, bison, false)
 AC_PATH_PROG(dot, dot)
 AC_PATH_PROG(lsof, lsof, lsof)
 NEED_PROG(jq, jq)
 AC_SUBST(coreutils, [$(dirname $(type -p cat))])
 AC_ARG_WITH(store-dir, AS_HELP_STRING([--with-store-dir=PATH],[path of the Nix store (defaults to /nix/store)]),
  storedir=$withval, storedir='/nix/store')
 AC_SUBST(storedir)
 # Look for boost, a required dependency.
 # Note that AX_BOOST_BASE only exports *CPP* BOOST_CPPFLAGS, no CXX flags,
 # and CPPFLAGS are not passed to the C++ compiler automatically.
 # Thus we append the returned CPPFLAGS to the CXXFLAGS here.
 AX_BOOST_BASE([1.66], [CXXFLAGS="$BOOST_CPPFLAGS $CXXFLAGS"], [AC_MSG_ERROR([Nix requires boost.])])
 # For unknown reasons, setting this directly in the ACTION-IF-FOUND above
 # ends up with LDFLAGS being empty, so we set it afterwards.
 LDFLAGS="$BOOST_LDFLAGS $LDFLAGS"
 # On some platforms, new-style atomics need a helper library
 AC_MSG_CHECKING(whether -latomic is needed)
 AC_LINK_IFELSE([AC_LANG_SOURCE([[
 #include <stdint.h>
 uint64_t v;
 int main() {
    return (int)__atomic_load_n(&v, __ATOMIC_ACQUIRE);
 }]])], GCC_ATOMIC_BUILTINS_NEED_LIBATOMIC=no, GCC_ATOMIC_BUILTINS_NEED_LIBATOMIC=yes)
 AC_MSG_RESULT($GCC_ATOMIC_BUILTINS_NEED_LIBATOMIC)
 if test "x$GCC_ATOMIC_BUILTINS_NEED_LIBATOMIC" = xyes; then
    LDFLAGS="-latomic $LDFLAGS"
 fi
 # Running the functional tests without building Nix is useful for testing
 # different pre-built versions of Nix against each other.
 AC_ARG_ENABLE(build, AS_HELP_STRING([--disable-build],[Do not build nix]),
  ENABLE_BUILD=$enableval, ENABLE_BUILD=yes)
 AC_SUBST(ENABLE_BUILD)
 # Building without tests is useful for bootstrapping with a smaller footprint
 # or running the tests in a separate derivation. Otherwise, we do compile and
 # run them.
 AC_ARG_ENABLE(tests, AS_HELP_STRING([--disable-tests],[Do not build the tests]),
  ENABLE_TESTS=$enableval, ENABLE_TESTS=yes)
 AC_SUBST(ENABLE_TESTS)
 # Building without API docs is the default as Nix' C++ interfaces are internal and unstable.
 AC_ARG_ENABLE(internal_api_docs, AS_HELP_STRING([--enable-internal-api-docs],[Build API docs for Nix's internal unstable C++ interfaces]),
  internal_api_docs=$enableval, internal_api_docs=no)
 AC_SUBST(internal_api_docs)
 # LTO is currently broken with clang for unknown reasons; ld segfaults in the llvm plugin
 AC_ARG_ENABLE(lto, AS_HELP_STRING([--enable-lto],[Enable LTO (only supported with GCC) [default=no]]),
  lto=$enableval, lto=no)
 if test "$lto" = yes; then
    if $CXX --version | grep -q GCC; then
        AC_SUBST(CXXLTO, [-flto=jobserver])
    else
        echo "error: LTO is only supported with GCC at the moment" >&2
        exit 1
    fi
 else
    AC_SUBST(CXXLTO, [""])
 fi
 PKG_PROG_PKG_CONFIG
 AC_ARG_ENABLE(shared, AS_HELP_STRING([--enable-shared],[Build shared libraries for Nix [default=yes]]),
  shared=$enableval, shared=yes)
 if test "$shared" = yes; then
  AC_SUBST(BUILD_SHARED_LIBS, 1, [Whether to build shared libraries.])
 else
  AC_SUBST(BUILD_SHARED_LIBS, 0, [Whether to build shared libraries.])
  PKG_CONFIG="$PKG_CONFIG --static"
 fi
 # Look for OpenSSL, a required dependency. FIXME: this is only (maybe)
 # used by S3BinaryCacheStore.
 PKG_CHECK_MODULES([OPENSSL], [libcrypto >= 1.1.1], [CXXFLAGS="$OPENSSL_CFLAGS $CXXFLAGS"])
 # Look for libarchive.
 PKG_CHECK_MODULES([LIBARCHIVE], [libarchive >= 3.1.2], [CXXFLAGS="$LIBARCHIVE_CFLAGS $CXXFLAGS"])
 # Workaround until https://github.com/libarchive/libarchive/issues/1446 is fixed
 if test "$shared" != yes; then
    LIBARCHIVE_LIBS+=' -lz'
 fi
 # Look for SQLite, a required dependency.
 PKG_CHECK_MODULES([SQLITE3], [sqlite3 >= 3.6.19], [CXXFLAGS="$SQLITE3_CFLAGS $CXXFLAGS"])
 # Look for libcurl, a required dependency.
 PKG_CHECK_MODULES([LIBCURL], [libcurl], [CXXFLAGS="$LIBCURL_CFLAGS $CXXFLAGS"])
 # Look for editline, a required dependency.
 # The the libeditline.pc file was added only in libeditline >= 1.15.2,
 # see https://github.com/troglobit/editline/commit/0a8f2ef4203c3a4a4726b9dd1336869cd0da8607,
 # but e.g. Ubuntu 16.04 has an older version, so we fall back to searching for
 # editline.h when the pkg-config approach fails.
 PKG_CHECK_MODULES([EDITLINE], [libeditline], [CXXFLAGS="$EDITLINE_CFLAGS $CXXFLAGS"], [
  AC_CHECK_HEADERS([editline.h], [true],
    [AC_MSG_ERROR([Nix requires libeditline; it was found neither via pkg-config nor its normal header.])])
  AC_SEARCH_LIBS([readline read_history], [editline], [],
    [AC_MSG_ERROR([Nix requires libeditline; it was not found via pkg-config, but via its header, but required functions do not work. Maybe it is too old? >= 1.14 is required.])])
 ])
 # Look for libsodium.
 PKG_CHECK_MODULES([SODIUM], [libsodium], [CXXFLAGS="$SODIUM_CFLAGS $CXXFLAGS"])
 # Look for libbrotli{enc,dec}.
 PKG_CHECK_MODULES([LIBBROTLI], [libbrotlienc libbrotlidec], [CXXFLAGS="$LIBBROTLI_CFLAGS $CXXFLAGS"])
 # Look for libcpuid.
 have_libcpuid=
 if test "$machine_name" = "x86_64"; then
    AC_ARG_ENABLE([cpuid],
                  AS_HELP_STRING([--disable-cpuid], [Do not determine microarchitecture levels with libcpuid (relevant to x86_64 only)]))
    if test "x$enable_cpuid" != "xno"; then
      PKG_CHECK_MODULES([LIBCPUID], [libcpuid],
        [CXXFLAGS="$LIBCPUID_CFLAGS $CXXFLAGS"
         have_libcpuid=1
         AC_DEFINE([HAVE_LIBCPUID], [1], [Use libcpuid])]
      )
    fi
 fi
 AC_SUBST(HAVE_LIBCPUID, [$have_libcpuid])
 # Look for libseccomp, required for Linux sandboxing.
 case "$host_os" in
  linux*)
    AC_ARG_ENABLE([seccomp-sandboxing],
                  AS_HELP_STRING([--disable-seccomp-sandboxing],[Don't build support for seccomp sandboxing (only recommended if your arch doesn't support libseccomp yet!)
                                ]))
    if test "x$enable_seccomp_sandboxing" != "xno"; then
      PKG_CHECK_MODULES([LIBSECCOMP], [libseccomp],
                        [CXXFLAGS="$LIBSECCOMP_CFLAGS $CXXFLAGS"])
      have_seccomp=1
      AC_DEFINE([HAVE_SECCOMP], [1], [Whether seccomp is available and should be used for sandboxing.])
    else
      have_seccomp=
    fi
    ;;
  *)
    have_seccomp=
    ;;
 esac
 AC_SUBST(HAVE_SECCOMP, [$have_seccomp])
 # Look for aws-cpp-sdk-s3.
 AC_LANG_PUSH(C++)
 AC_CHECK_HEADERS([aws/s3/S3Client.h],
  [AC_DEFINE([ENABLE_S3], [1], [Whether to enable S3 support via aws-sdk-cpp.]) enable_s3=1],
  [AC_DEFINE([ENABLE_S3], [0], [Whether to enable S3 support via aws-sdk-cpp.]) enable_s3=])
 AC_SUBST(ENABLE_S3, [$enable_s3])
 AC_LANG_POP(C++)
 if test -n "$enable_s3"; then
  declare -a aws_version_tokens=($(printf '#include <aws/core/VersionConfig.h>\nAWS_SDK_VERSION_STRING' | $CPP $CPPFLAGS - | grep -v '^#.*' | sed 's/"//g' | tr '.' ' '))
  AC_DEFINE_UNQUOTED([AWS_VERSION_MAJOR], ${aws_version_tokens@<:@0@:>@}, [Major version of aws-sdk-cpp.])
  AC_DEFINE_UNQUOTED([AWS_VERSION_MINOR], ${aws_version_tokens@<:@1@:>@}, [Minor version of aws-sdk-cpp.])
  AC_DEFINE_UNQUOTED([AWS_VERSION_PATCH], ${aws_version_tokens@<:@2@:>@}, [Patch version of aws-sdk-cpp.])
 fi
 # Whether to use the Boehm garbage collector.
 AC_ARG_ENABLE(gc, AS_HELP_STRING([--enable-gc],[enable garbage collection in the Nix expression evaluator (requires Boehm GC) [default=yes]]),
  gc=$enableval, gc=yes)
 if test "$gc" = yes; then
  PKG_CHECK_MODULES([BDW_GC], [bdw-gc])
  CXXFLAGS="$BDW_GC_CFLAGS $CXXFLAGS"
  AC_DEFINE(HAVE_BOEHMGC, 1, [Whether to use the Boehm garbage collector.])
 fi
 if test "$ENABLE_TESTS" = yes; then
 # Look for gtest.
 PKG_CHECK_MODULES([GTEST], [gtest_main gmock_main])
 # Look for rapidcheck.
 AC_ARG_VAR([RAPIDCHECK_HEADERS], [include path of gtest headers shipped by RAPIDCHECK])
 # No pkg-config yet, https://github.com/emil-e/rapidcheck/issues/302
 AC_LANG_PUSH(C++)
 AC_SUBST(RAPIDCHECK_HEADERS)
 [CXXFLAGS="-I $RAPIDCHECK_HEADERS $CXXFLAGS"]
 [LIBS="-lrapidcheck -lgtest $LIBS"]
 AC_CHECK_HEADERS([rapidcheck/gtest.h], [], [], [#include <gtest/gtest.h>])
 dnl AC_CHECK_LIB doesn't work for C++ libs with mangled symbols
 AC_LINK_IFELSE([
    AC_LANG_PROGRAM([[
      #include <gtest/gtest.h>
      #include <rapidcheck/gtest.h>
    ]], [[
      return RUN_ALL_TESTS();
    ]])
  ],
  [],
  [AC_MSG_ERROR([librapidcheck is not found.])])
 AC_LANG_POP(C++)
 fi
 # Look for nlohmann/json.
 PKG_CHECK_MODULES([NLOHMANN_JSON], [nlohmann_json >= 3.9])
 # documentation generation switch
 AC_ARG_ENABLE(doc-gen, AS_HELP_STRING([--disable-doc-gen],[disable documentation generation]),
  doc_generate=$enableval, doc_generate=yes)
 AC_SUBST(doc_generate)
 # Look for lowdown library.
 PKG_CHECK_MODULES([LOWDOWN], [lowdown >= 0.9.0], [CXXFLAGS="$LOWDOWN_CFLAGS $CXXFLAGS"])
 # Look for toml11, a required dependency.
 AC_ARG_VAR([TOML11_HEADERS], [include path of toml11 headers])
 AC_LANG_PUSH(C++)
 [CXXFLAGS="-I $TOML11_HEADERS $CXXFLAGS"]
 AC_CHECK_HEADER([toml.hpp], [], [AC_MSG_ERROR([toml11 is not found.])])
 AC_LANG_POP(C++)
 # Setuid installations.
 AC_CHECK_FUNCS([setresuid setreuid lchown])
 # Nice to have, but not essential.
 AC_CHECK_FUNCS([strsignal posix_fallocate sysconf])
 AC_ARG_WITH(sandbox-shell, AS_HELP_STRING([--with-sandbox-shell=PATH],[path of a statically-linked shell to use as /bin/sh in sandboxes]),
  sandbox_shell=$withval)
 AC_SUBST(sandbox_shell)
 if test ${cross_compiling:-no} = no && ! test -z ${sandbox_shell+x}; then
  AC_MSG_CHECKING([whether sandbox-shell has the standalone feature])
  # busybox shell sometimes allows executing other busybox applets,
  # even if they are not in the path, breaking our sandbox
  if PATH= $sandbox_shell -c "busybox" 2>&1 | grep -qv "not found"; then
    AC_MSG_RESULT(enabled)
    AC_MSG_ERROR([Please disable busybox FEATURE_SH_STANDALONE])
  else
    AC_MSG_RESULT(disabled)
  fi
 fi
 AC_ARG_ENABLE(embedded-sandbox-shell, AS_HELP_STRING([--enable-embedded-sandbox-shell],[include the sandbox shell in the Nix binary [default=no]]),
  embedded_sandbox_shell=$enableval, embedded_sandbox_shell=no)
 AC_SUBST(embedded_sandbox_shell)
 if test "$embedded_sandbox_shell" = yes; then
  AC_DEFINE(HAVE_EMBEDDED_SANDBOX_SHELL, 1, [Include the sandbox shell in the Nix binary.])
 fi
 # Expand all variables in config.status.
 test "$prefix" = NONE && prefix=$ac_default_prefix
 test "$exec_prefix" = NONE && exec_prefix='${prefix}'
 for name in $ac_subst_vars; do
    declare $name="$(eval echo "${!name}")"
    declare $name="$(eval echo "${!name}")"
    declare $name="$(eval echo "${!name}")"
 done
 rm -f Makefile.config
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_FILES([])
 AC_OUTPUT
--- a/contrib/stack-collapse.py
+++ b/contrib/stack-collapse.py
@ -1,38 +0,0 @@
 #!/usr/bin/env nix-shell
 #!nix-shell -i python3 -p python3 --pure
 # To be used with `--trace-function-calls` and `flamegraph.pl`.
 #
 # For example:
 #
 # nix-instantiate --trace-function-calls '<nixpkgs>' -A hello 2> nix-function-calls.trace
 # ./contrib/stack-collapse.py nix-function-calls.trace > nix-function-calls.folded
 # nix-shell -p flamegraph --run "flamegraph.pl nix-function-calls.folded > nix-function-calls.svg"
 import sys
 from pprint import pprint
 import fileinput
 stack = []
 timestack = []
 for line in fileinput.input():
    components = line.strip().split(" ", 2)
    if components[0] != "function-trace":
        continue
    direction = components[1]
    components = components[2].rsplit(" ", 2)
    loc = components[0]
    _at = components[1]
    time = int(components[2])
    if direction == "entered":
        stack.append(loc)
        timestack.append(time)
    elif direction == "exited":
        dur = time - timestack.pop()
        vst = ";".join(stack)
        print(f"{vst} {dur}")
        stack.pop()
--- a/default.nix
+++ b/default.nix
@ -1,10 +0,0 @@
 (import
  (
    let lock = builtins.fromJSON (builtins.readFile ./flake.lock); in
    fetchTarball {
      url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
      sha256 = lock.nodes.flake-compat.locked.narHash;
    }
  )
  { src = ./.; }
 ).defaultNix
--- a/doc/internal-api/.gitignore
+++ b/doc/internal-api/.gitignore
@ -1,3 +0,0 @@
 /doxygen.cfg
 /html
 /latex
--- a/doc/internal-api/doxygen.cfg.in
+++ b/doc/internal-api/doxygen.cfg.in
@ -1,97 +0,0 @@
 # Doxyfile 1.9.5
 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
 # double-quotes, unless you are using Doxywizard) that should identify the
 # project for which the documentation is generated. This name is used in the
 # title of most generated pages and in a few other places.
 # The default value is: My Project.
 PROJECT_NAME           = "Nix"
 # The PROJECT_NUMBER tag can be used to enter a project or revision number. This
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 PROJECT_NUMBER         = @PACKAGE_VERSION@
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
 # quick idea about the purpose of the project. Keep the description short.
 PROJECT_BRIEF          = "Nix, the purely functional package manager; unstable internal interfaces"
 # If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
 # The default value is: YES.
 GENERATE_LATEX         = NO
 # The INPUT tag is used to specify the files and/or directories that contain
 # documented source files. You may enter file names like myfile.cpp or
 # directories like /usr/src/myproject. Separate the files or directories with
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 # FIXME Make this list more maintainable somehow. We could maybe generate this
 # in the Makefile, but we would need to change how `.in` files are preprocessed
 # so they can expand variables despite configure variables.
 INPUT                  = \
  src/libcmd \
  src/libexpr \
  src/libexpr/flake \
  tests/unit/libexpr \
  tests/unit/libexpr/value \
  tests/unit/libexpr/test \
  tests/unit/libexpr/test/value \
  src/libexpr/value \
  src/libfetchers \
  src/libmain \
  src/libstore \
  src/libstore/build \
  src/libstore/builtins \
  tests/unit/libstore \
  tests/unit/libstore/test \
  src/libutil \
  tests/unit/libutil \
  tests/unit/libutil/test \
  src/nix \
  src/nix-env \
  src/nix-store
 # If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
 # in the source code. If set to NO, only conditional compilation will be
 # performed. Macro expansion can be done in a controlled way by setting
 # EXPAND_ONLY_PREDEF to YES.
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 MACRO_EXPANSION        = YES
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
 # the macro expansion is limited to the macros specified with the PREDEFINED and
 # EXPAND_AS_DEFINED tags.
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 EXPAND_ONLY_PREDEF     = YES
 # The INCLUDE_PATH tag can be used to specify one or more directories that
 # contain include files that are not input files but should be processed by the
 # preprocessor. Note that the INCLUDE_PATH is not recursive, so the setting of
 # RECURSIVE has no effect here.
 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
 INCLUDE_PATH           = @RAPIDCHECK_HEADERS@
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The
 # macro definition that is found in the sources will be used. Use the PREDEFINED
 # tag if you want to use a different macro definition that overrules the
 # definition found in the source code.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 EXPAND_AS_DEFINED      = \
  DECLARE_COMMON_SERIALISER \
  DECLARE_WORKER_SERIALISER \
  DECLARE_SERVE_SERIALISER \
  LENGTH_PREFIXED_PROTO_HELPER
--- a/doc/internal-api/local.mk
+++ b/doc/internal-api/local.mk
@ -1,19 +0,0 @@
 .PHONY: internal-api-html
 ifeq ($(internal_api_docs), yes)
 $(docdir)/internal-api/html/index.html $(docdir)/internal-api/latex: $(d)/doxygen.cfg
 	mkdir -p $(docdir)/internal-api
 	{ cat $< ; echo "OUTPUT_DIRECTORY=$(docdir)/internal-api" ; } | doxygen -
 # Generate the HTML API docs for Nix's unstable internal interfaces.
 internal-api-html: $(docdir)/internal-api/html/index.html
 else
 # Make a nicer error message
 internal-api-html:
 	@echo "Internal API docs are disabled. Configure with '--enable-internal-api-docs', or avoid calling 'make internal-api-html'."
 	@exit 1
 endif
--- a/doc/manual/anchors.jq
+++ b/doc/manual/anchors.jq
@ -1,31 +0,0 @@
 "\\[\\]\\{#(?<anchor>[^\\}]+?)\\}" as $empty_anchor_regex |
 "\\[(?<text>[^\\]]+?)\\]\\{#(?<anchor>[^\\}]+?)\\}" as $anchor_regex |
 def transform_anchors_html:
    . | gsub($empty_anchor_regex; "<a name=\"" + .anchor + "\"></a>")
      | gsub($anchor_regex; "<a href=\"#" + .anchor + "\" id=\"" + .anchor + "\">" + .text + "</a>");
 def transform_anchors_strip:
    . | gsub($empty_anchor_regex; "")
      | gsub($anchor_regex; .text);
 def map_contents_recursively(transformer):
    . + {
        Chapter: (.Chapter + {
            content: .Chapter.content | transformer,
            sub_items: .Chapter.sub_items | map(map_contents_recursively(transformer)),
        }),
    };
 def process_command:
    .[0] as $context |
    .[1] as $body |
    $body + {
        sections: $body.sections | map(map_contents_recursively(if $context.renderer == "html" then transform_anchors_html else transform_anchors_strip end)),
    };
 process_command
--- a/doc/manual/book.toml
+++ b/doc/manual/book.toml
@ -1,30 +0,0 @@
 [book]
 title = "Nix Reference Manual"
 [output.html]
 additional-css = ["custom.css"]
 additional-js = ["redirects.js"]
 edit-url-template = "https://github.com/NixOS/nix/tree/master/doc/manual/{path}"
 git-repository-url = "https://github.com/NixOS/nix"
 # Handles replacing @docroot@ with a path to ./src relative to that markdown file.
 [preprocessor.docroot]
 renderers = ["html", "linkcheck"]
 command = "python3 doc/manual/docroot.py"
 # I would have thought that @docroot@ replacement had to be done *before*
 # the link preprocessor gets its hands on this book, but nope it's actually
 # the opposite.
 after = ["links"]
 [preprocessor.anchors]
 renderers = ["html"]
 command = "jq --from-file doc/manual/anchors.jq"
 [output.linkcheck]
 # no Internet during the build (in the sandbox)
 follow-web-links = false
 # mdbook-linkcheck does not understand [foo]{#bar} style links, resulting in
 # excessive "Potential incomplete link" warnings. No other kind of warning was
 # produced at the time of writing.
 warning-policy = "ignore"
--- a/doc/manual/custom.css
+++ b/doc/manual/custom.css
@ -1,11 +0,0 @@
 h1:not(:first-of-type) {
    margin-top: 1.3em;
 }
 h2 {
    margin-top: 1em;
 }
 .hljs-meta {
    user-select: none;
 }
--- a/doc/manual/docroot.py
+++ b/doc/manual/docroot.py
@ -1,84 +0,0 @@
 #!/usr/bin/env python3
 from pathlib import Path
 import json
 import os, os.path
 import sys
 name = 'process-docroot.py'
 def log(*args, **kwargs):
    kwargs['file'] = sys.stderr
    return print(f'{name}:', *args, **kwargs)
 def replace_docroot(relative_md_path: Path, content: str, book_root: Path):
    assert not relative_md_path.is_absolute(), f'{relative_md_path=} from mdbook should be relative'
    md_path_abs = book_root / relative_md_path
    docroot_abs = md_path_abs.parent
    assert docroot_abs.is_dir(), f'supposed docroot {docroot_abs} is not a directory (cwd={os.getcwd()})'
    # The paths mdbook gives us are relative to the directory with book.toml.
    # @docroot@ wants to be replaced with the path relative to `src/`.
    docroot_rel = os.path.relpath(book_root / 'src', start=docroot_abs)
    return content.replace('@docroot@', docroot_rel)
 def recursive_replace(data, book_root):
    match data:
        case {'sections': sections}:
            return data | dict(
                sections = [recursive_replace(section, book_root) for section in sections],
            )
        case {'Chapter': chapter}:
            # Path to the .md file for this chapter, relative to book_root.
            path_to_chapter = Path('src') / chapter['path']
            chapter_content = chapter['content']
            return data | dict(
                Chapter = chapter | dict(
                    content = replace_docroot(path_to_chapter, chapter_content, book_root),
                    sub_items = [recursive_replace(sub_item, book_root) for sub_item in chapter['sub_items']],
                ),
            )
        case rest:
            assert False, f'should have been called on a dict, not {type(rest)=}\n\t{rest=}'
 def main():
    if len(sys.argv) > 1 and sys.argv[1] == 'supports':
        log('confirming to mdbook that we support their stuff')
        return 0
    # mdbook communicates with us over stdin and stdout.
    # It splorks us a JSON array, the first element describing the context,
    # the second element describing the book itself,
    # and then expects us to send it the modified book JSON over stdout.
    context, book = json.load(sys.stdin)
    # book_root is *not* @docroot@. @docroot@ gets replaced with a relative path to `./src/`.
    # book_root is the directory where book.toml, aka `src`'s parent.
    book_root = Path(context['root'])
    assert book_root.exists(), f'{book_root=} does not exist'
    assert book_root.joinpath('book.toml').is_file(), f'{book_root / "book.toml"} is not a file'
    log('replacing all occurrences of @docroot@ with a relative path')
    # Find @docroot@ in all parts of our recursive book structure.
    replaced_content = recursive_replace(book, book_root)
    replaced_content_str = json.dumps(replaced_content)
    # Give mdbook our changes.
    print(replaced_content_str)
    log('done!')
 try:
    sys.exit(main())
 except AssertionError as e:
    print(f'{name}: INTERNAL ERROR in mdbook preprocessor', file=sys.stderr)
    print(f'this is a bug in {name}')
    raise
--- a/doc/manual/generate-builtin-constants.nix
+++ b/doc/manual/generate-builtin-constants.nix
@ -1,31 +0,0 @@
 let
  inherit (builtins) concatStringsSep attrValues mapAttrs;
  inherit (import ./utils.nix) optionalString squash;
 in
 builtinsInfo:
 let
  showBuiltin = name: { doc, type, impure-only }:
    let
      type' = optionalString (type != null) " (${type})";
      impureNotice = optionalString impure-only ''
        > **Note**
        >
        > Not available in [pure evaluation mode](@docroot@/command-ref/conf-file.md#conf-pure-eval).
      '';
    in
    squash ''
      <dt id="builtins-${name}">
        <a href="#builtins-${name}"><code>${name}</code></a>${type'}
      </dt>
      <dd>
      ${doc}
      ${impureNotice}
      </dd>
    '';
 in
 concatStringsSep "\n" (attrValues (mapAttrs showBuiltin builtinsInfo))
--- a/doc/manual/generate-builtins.nix
+++ b/doc/manual/generate-builtins.nix
@ -1,28 +0,0 @@
 let
  inherit (builtins) concatStringsSep attrValues mapAttrs;
  inherit (import ./utils.nix) optionalString squash;
 in
 builtinsInfo:
 let
  showBuiltin = name: { doc, args, arity, experimental-feature }:
    let
      experimentalNotice = optionalString (experimental-feature != null) ''
        This function is only available if the [${experimental-feature}](@docroot@/contributing/experimental-features.md#xp-feature-${experimental-feature}) experimental feature is enabled.
      '';
    in
    squash ''
      <dt id="builtins-${name}">
        <a href="#builtins-${name}"><code>${name} ${listArgs args}</code></a>
      </dt>
      <dd>
      ${doc}
      ${experimentalNotice}
      </dd>
    '';
  listArgs = args: concatStringsSep " " (map (s: "<var>${s}</var>") args);
 in
 concatStringsSep "\n" (attrValues (mapAttrs showBuiltin builtinsInfo))
--- a/doc/manual/generate-manpage.nix
+++ b/doc/manual/generate-manpage.nix
@ -1,177 +0,0 @@
 let
  inherit (builtins)
    attrNames attrValues fromJSON listToAttrs mapAttrs
    concatStringsSep concatMap length lessThan replaceStrings sort;
  inherit (import ./utils.nix) concatStrings optionalString filterAttrs trim squash unique showSettings;
 in
 inlineHTML: commandDump:
 let
  commandInfo = fromJSON commandDump;
  showCommand = { command, details, filename, toplevel }:
    let
      result = ''
        > **Warning** \
        > This program is
        > [**experimental**](@docroot@/contributing/experimental-features.md#xp-feature-nix-command)
        > and its interface is subject to change.
        # Name
        `${command}` - ${details.description}
        # Synopsis
        ${showSynopsis command details.args}
        ${maybeSubcommands}
        ${maybeStoreDocs}
        ${maybeOptions}
      '';
      showSynopsis = command: args:
        let
          showArgument = arg: "*${arg.label}*" + optionalString (! arg ? arity) "...";
          arguments = concatStringsSep " " (map showArgument args);
        in ''
         `${command}` [*option*...] ${arguments}
        '';
      maybeSubcommands = optionalString (details ? commands && details.commands != {})
         ''
           where *subcommand* is one of the following:
           ${subcommands}
         '';
      subcommands = if length categories > 1
        then listCategories
        else listSubcommands details.commands;
      categories = sort (x: y: x.id < y.id) (unique (map (cmd: cmd.category) (attrValues details.commands)));
      listCategories = concatStrings (map showCategory categories);
      showCategory = cat: ''
        **${toString cat.description}:**
        ${listSubcommands (filterAttrs (n: v: v.category == cat) details.commands)}
      '';
      listSubcommands = cmds: concatStrings (attrValues (mapAttrs showSubcommand cmds));
      showSubcommand = name: subcmd: ''
        * [`${command} ${name}`](./${appendName filename name}.md) - ${subcmd.description}
      '';
      # TODO: move this confusing special case out of here when implementing #8496
      maybeStoreDocs = optionalString
        (details ? doc)
        (replaceStrings ["@stores@"] [storeDocs] details.doc);
      maybeOptions = optionalString (details.flags != {}) ''
        # Options
        ${showOptions details.flags toplevel.flags}
        > **Note**
        >
        > See [`man nix.conf`](@docroot@/command-ref/conf-file.md#command-line-flags) for overriding configuration settings with command line flags.
      '';
      showOptions = options: commonOptions:
        let
          allOptions = options // commonOptions;
          showCategory = cat: ''
            ${optionalString (cat != "") "**${cat}:**"}
            ${listOptions (filterAttrs (n: v: v.category == cat) allOptions)}
            '';
          listOptions = opts: concatStringsSep "\n" (attrValues (mapAttrs showOption opts));
          showOption = name: option:
            let
              result = trim ''
                - ${item}
                  ${option.description}
              '';
              item = if inlineHTML
                then ''<span id="opt-${name}">[`--${name}`](#opt-${name})</span> ${shortName} ${labels}''
                else "`--${name}` ${shortName} ${labels}";
              shortName = optionalString
                (option ? shortName)
                ("/ `-${option.shortName}`");
              labels = optionalString
                (option ? labels)
                (concatStringsSep " " (map (s: "*${s}*") option.labels));
            in result;
          categories = sort lessThan (unique (map (cmd: cmd.category) (attrValues allOptions)));
        in concatStrings (map showCategory categories);
    in squash result;
  appendName = filename: name: (if filename == "nix" then "nix3" else filename) + "-" + name;
  processCommand = { command, details, filename, toplevel }:
    let
      cmd = {
        inherit command;
        name = filename + ".md";
        value = showCommand { inherit command details filename toplevel; };
      };
      subcommand = subCmd: processCommand {
        command = command + " " + subCmd;
        details = details.commands.${subCmd};
        filename = appendName filename subCmd;
        inherit toplevel;
      };
    in [ cmd ] ++ concatMap subcommand (attrNames details.commands or {});
  manpages = processCommand {
    command = "nix";
    details = commandInfo.args;
    filename = "nix";
    toplevel = commandInfo.args;
  };
  tableOfContents = let
    showEntry = page:
      "    - [${page.command}](command-ref/new-cli/${page.name})";
    in concatStringsSep "\n" (map showEntry manpages) + "\n";
  storeDocs =
    let
      showStore = name: { settings, doc, experimentalFeature }:
        let
          experimentalFeatureNote = optionalString (experimentalFeature != null) ''
            > **Warning**
            > This store is part of an
            > [experimental feature](@docroot@/contributing/experimental-features.md).
            To use this store, you need to make sure the corresponding experimental feature,
            [`${experimentalFeature}`](@docroot@/contributing/experimental-features.md#xp-feature-${experimentalFeature}),
            is enabled.
            For example, include the following in [`nix.conf`](@docroot@/command-ref/conf-file.md):
            ```
            extra-experimental-features = ${experimentalFeature}
            ```
          '';
        in ''
          ## ${name}
          ${doc}
          ${experimentalFeatureNote}
          **Settings**:
          ${showSettings { inherit inlineHTML; } settings}
        '';
    in concatStrings (attrValues (mapAttrs showStore commandInfo.stores));
 in (listToAttrs manpages) // { "SUMMARY.md" = tableOfContents; }
--- a/doc/manual/generate-manpage.py
+++ b/doc/manual/generate-manpage.py
@ -1,63 +0,0 @@
 #!/usr/bin/env python3
 """
 This script is a helper for this project's Meson buildsystem, to generate
 manpages as mdbook markdown for nix3 CLI commands. It is an analogue to an
 inline sequence of bash commands in the autoconf+Make buildsystem, which works
 around a limitation in `nix eval --write-to`, in that it refuses to write to any
 directory that already exists.
 Basically, this script is a glorified but hopefully-more-robust version of:
 $ rm -rf $output
 $ nix eval --write-to $output.tmp --expr 'import doc/manual/generate-manpage.nix true
    (builtins.readFile ./generate-manpage.nix)'
 $ mv $output.tmp $output
 """
 import argparse
 import os.path
 import shlex
 import shutil
 import subprocess
 import sys
 import tempfile
 name = 'generate-manpage.py'
 def log(*args, **kwargs):
    kwargs['file'] = sys.stderr
    return print(f'{name}:', *args, **kwargs)
 def main():
    parser = argparse.ArgumentParser(name)
    parser.add_argument('--nix', required=True, help='Full path to the nix binary to use')
    parser.add_argument('-o', '--output', required=True, help='Output directory')
    parser.add_argument('--generator', required=True, help='Path to generate-manpage.nix')
    parser.add_argument('--cli-json', required=True, help='Path to the nix.json output from Nix')
    args = parser.parse_args()
    with tempfile.TemporaryDirectory() as tempdir:
        temp_out = os.path.join(tempdir, 'new-cli')
        nix_args = [
            args.nix,
            '--experimental-features',
            'nix-command',
            'eval',
            '-I', 'nix/corepkgs=corepkgs',
            '--store', 'dummy://',
            '--impure',
            '--raw',
            '--write-to', temp_out,
            '--expr',
            f'import {args.generator} true (builtins.readFile {args.cli_json})',
        ]
        log('generating nix3 man pages with', shlex.join(nix_args))
        subprocess.check_call(nix_args)
        shutil.copytree(temp_out, args.output, dirs_exist_ok=True)
 sys.exit(main())
--- a/doc/manual/generate-xp-features-shortlist.nix
+++ b/doc/manual/generate-xp-features-shortlist.nix
@ -1,9 +0,0 @@
 with builtins;
 with import ./utils.nix;
 let
  showExperimentalFeature = name: doc:
    ''
      - [`${name}`](@docroot@/contributing/experimental-features.md#xp-feature-${name})
    '';
 in xps: indent "  " (concatStrings (attrValues (mapAttrs showExperimentalFeature xps)))
--- a/doc/manual/generate-xp-features.nix
+++ b/doc/manual/generate-xp-features.nix
@ -1,11 +0,0 @@
 with builtins;
 with import ./utils.nix;
 let
  showExperimentalFeature = name: doc:
    squash ''
      ## [`${name}`]{#xp-feature-${name}}
      ${doc}
    '';
 in xps: (concatStringsSep "\n" (attrValues (mapAttrs showExperimentalFeature xps)))
--- a/doc/manual/local.mk
+++ b/doc/manual/local.mk
@ -1,177 +0,0 @@
 ifeq ($(doc_generate),yes)
 # The version of Nix used to generate the doc. Can also be
 # `$(nix_INSTALL_PATH)` or just `nix` (to grap ambient from the `PATH`),
 # if one prefers.
 doc_nix = $(nix_PATH)
 MANUAL_SRCS := \
 	$(call rwildcard, $(d)/src, *.md) \
 	$(call rwildcard, $(d)/src, */*.md)
 man-pages := $(foreach n, \
 	nix-env.1 nix-store.1 \
 	nix-build.1 nix-shell.1 nix-instantiate.1 \
 	nix-collect-garbage.1 \
 	nix-prefetch-url.1 nix-channel.1 \
 	nix-hash.1 nix-copy-closure.1 \
 	nix.conf.5 nix-daemon.8 \
 	nix-profiles.5 \
 , $(d)/$(n))
 # man pages for subcommands
 # convert from `$(d)/src/command-ref/nix-{1}/{2}.md` to `$(d)/nix-{1}-{2}.1`
 # FIXME: unify with how nix3-cli man pages are generated
 man-pages += $(foreach subcommand, \
 	$(filter-out %opt-common.md %env-common.md, $(wildcard $(d)/src/command-ref/nix-*/*.md)), \
 	$(d)/$(subst /,-,$(subst $(d)/src/command-ref/,,$(subst .md,.1,$(subcommand)))))
 clean-files += $(d)/*.1 $(d)/*.5 $(d)/*.8
 # Provide a dummy environment for nix, so that it will not access files outside the macOS sandbox.
 # Set cores to 0 because otherwise nix show-config resolves the cores based on the current machine
 dummy-env = env -i \
 	HOME=/dummy \
 	NIX_CONF_DIR=/dummy \
 	NIX_SSL_CERT_FILE=/dummy/no-ca-bundle.crt \
 	NIX_STATE_DIR=/dummy \
 	NIX_CONFIG='cores = 0'
 nix-eval = $(dummy-env) $(doc_nix) eval --experimental-features nix-command -I nix/corepkgs=corepkgs --store dummy:// --impure --raw
 $(d)/nix-env-%.1: $(d)/src/command-ref/nix-env/%.md
 	$(trace-gen) doc/manual/render-manpage.sh \
 		--out-no-smarty "$(subst nix-env-,nix-env --,$$(basename "$@" .1))" 1 $^ $^.tmp $@
 $(d)/nix-store-%.1: $(d)/src/command-ref/nix-store/%.md
 	$(trace-gen) doc/manual/render-manpage.sh \
 		--out-no-smarty "$(subst nix-store-,nix-store --,$$(basename "$@" .1))" 1 $^ $^.tmp $@
 $(d)/%.1: $(d)/src/command-ref/%.md
 	$(trace-gen) doc/manual/render-manpage.sh "$$(basename $@ .1)" 1 $^ $^.tmp $@
 $(d)/%.8: $(d)/src/command-ref/%.md
 	$(trace-gen) doc/manual/render-manpage.sh "$$(basename $@ .8)" 8 $^ $^.tmp $@
 $(d)/nix.conf.5: $(d)/src/command-ref/conf-file.md
 	$(trace-gen) doc/manual/render-manpage.sh "$$(basename $@ .5)" 5 $^ $^.tmp $@
 $(d)/nix-profiles.5: $(d)/src/command-ref/files/profiles.md
 	$(trace-gen) doc/manual/render-manpage.sh "$$(basename $@ .5)" 5 $^ $^.tmp $@
 $(d)/src/SUMMARY.md: $(d)/src/SUMMARY.md.in $(d)/src/SUMMARY-rl-next.md $(d)/src/command-ref/new-cli $(d)/src/contributing/experimental-feature-descriptions.md
 	@cp $< $@
 	@doc/manual/process-includes.sh $@ $@
 $(d)/src/command-ref/new-cli: $(d)/nix.json $(d)/utils.nix $(d)/generate-manpage.nix $(doc_nix)
 	@rm -rf $@ $@.tmp
 	$(trace-gen) $(nix-eval) --write-to $@.tmp --expr 'import doc/manual/generate-manpage.nix true (builtins.readFile $<)'
 	@mv $@.tmp $@
 $(d)/src/command-ref/conf-file.md: $(d)/conf-file.json $(d)/utils.nix $(d)/src/command-ref/conf-file-prefix.md $(d)/src/command-ref/experimental-features-shortlist.md $(doc_nix)
 	@cat doc/manual/src/command-ref/conf-file-prefix.md > $@.tmp
 	$(trace-gen) $(nix-eval) --expr '(import doc/manual/utils.nix).showSettings { inlineHTML = true; } (builtins.fromJSON (builtins.readFile $<))' >> $@.tmp;
 	@mv $@.tmp $@
 $(d)/nix.json: $(doc_nix)
 	$(trace-gen) $(dummy-env) $(doc_nix) __dump-cli > $@.tmp
 	@mv $@.tmp $@
 $(d)/conf-file.json: $(doc_nix)
 	$(trace-gen) $(dummy-env) $(doc_nix) show-config --json --experimental-features nix-command > $@.tmp
 	@mv $@.tmp $@
 $(d)/src/contributing/experimental-feature-descriptions.md: $(d)/xp-features.json $(d)/utils.nix $(d)/generate-xp-features.nix $(doc_nix)
 	@rm -rf $@ $@.tmp
 	$(trace-gen) $(nix-eval) --write-to $@.tmp --expr 'import doc/manual/generate-xp-features.nix (builtins.fromJSON (builtins.readFile $<))'
 	@mv $@.tmp $@
 $(d)/src/command-ref/experimental-features-shortlist.md: $(d)/xp-features.json $(d)/utils.nix $(d)/generate-xp-features-shortlist.nix $(doc_nix)
 	@rm -rf $@ $@.tmp
 	$(trace-gen) $(nix-eval) --write-to $@.tmp --expr 'import doc/manual/generate-xp-features-shortlist.nix (builtins.fromJSON (builtins.readFile $<))'
 	@mv $@.tmp $@
 $(d)/xp-features.json: $(doc_nix)
 	$(trace-gen) $(dummy-env) NIX_PATH=nix/corepkgs=corepkgs $(doc_nix) __dump-xp-features > $@.tmp
 	@mv $@.tmp $@
 $(d)/src/language/builtins.md: $(d)/language.json $(d)/generate-builtins.nix $(d)/src/language/builtins-prefix.md $(doc_nix)
 	@cat doc/manual/src/language/builtins-prefix.md > $@.tmp
 	$(trace-gen) $(nix-eval) --expr 'import doc/manual/generate-builtins.nix (builtins.fromJSON (builtins.readFile $<)).builtins' >> $@.tmp;
 	@cat doc/manual/src/language/builtins-suffix.md >> $@.tmp
 	@mv $@.tmp $@
 $(d)/src/language/builtin-constants.md: $(d)/language.json $(d)/generate-builtin-constants.nix $(d)/src/language/builtin-constants-prefix.md $(doc_nix)
 	@cat doc/manual/src/language/builtin-constants-prefix.md > $@.tmp
 	$(trace-gen) $(nix-eval) --expr 'import doc/manual/generate-builtin-constants.nix (builtins.fromJSON (builtins.readFile $<)).constants' >> $@.tmp;
 	@cat doc/manual/src/language/builtin-constants-suffix.md >> $@.tmp
 	@mv $@.tmp $@
 $(d)/language.json: $(doc_nix)
 	$(trace-gen) $(dummy-env) NIX_PATH=nix/corepkgs=corepkgs $(doc_nix) __dump-language > $@.tmp
 	@mv $@.tmp $@
 # Generate "Upcoming release" notes (or clear it and remove from menu)
 $(d)/src/release-notes/rl-next.md: $(d)/rl-next $(d)/rl-next/*
 	@if type -p build-release-notes > /dev/null; then \
 		echo "  GEN   " $@; \
 		build-release-notes doc/manual/rl-next > $@; \
 	else \
 		echo "  NULL  " $@; \
 		true > $@; \
 	fi
 $(d)/src/SUMMARY-rl-next.md: $(d)/src/release-notes/rl-next.md
 	$(trace-gen) true
 	@if [ -s $< ]; then \
 		echo '  - [Upcoming release](release-notes/rl-next.md)' > $@; \
 	else \
 	  true > $@; \
 	fi
 # Generate the HTML manual.
 .PHONY: manual-html
 manual-html: $(docdir)/manual/index.html
 install: $(docdir)/manual/index.html
 # Generate 'nix' manpages.
 install: $(mandir)/man1/nix3-manpages
 man: doc/manual/generated/man1/nix3-manpages
 all: doc/manual/generated/man1/nix3-manpages
 # FIXME: unify with how the other man pages are generated.
 # this one works differently and does not use any of the amenities provided by `/mk/lib.mk`.
 $(mandir)/man1/nix3-manpages: doc/manual/generated/man1/nix3-manpages
 	@mkdir -p $(DESTDIR)$$(dirname $@)
 	$(trace-install) install -m 0644 $$(dirname $<)/* $(DESTDIR)$$(dirname $@)
 doc/manual/generated/man1/nix3-manpages: $(d)/src/command-ref/new-cli
 	@mkdir -p $(DESTDIR)$$(dirname $@)
 	$(trace-gen) for i in doc/manual/src/command-ref/new-cli/*.md; do \
 		name=$$(basename $$i .md); \
 		tmpFile=$$(mktemp); \
 		if [[ $$name = SUMMARY ]]; then continue; fi; \
 		printf "Title: %s\n\n" "$$name" > $$tmpFile; \
 		cat $$i >> $$tmpFile; \
 		lowdown -sT man --nroff-nolinks -M section=1 $$tmpFile -o $(DESTDIR)$$(dirname $@)/$$name.1; \
 		rm $$tmpFile; \
 	done
 	@touch $@
 $(docdir)/manual/index.html: $(MANUAL_SRCS) $(d)/book.toml $(d)/anchors.jq $(d)/custom.css $(d)/src/SUMMARY.md $(d)/src/command-ref/new-cli $(d)/src/contributing/experimental-feature-descriptions.md $(d)/src/command-ref/conf-file.md $(d)/src/language/builtins.md $(d)/src/language/builtin-constants.md $(d)/src/release-notes/rl-next.md $(d)/docroot.py
 	$(trace-gen) \
 		tmp="$$(mktemp -d)"; \
 		cp -r doc/manual "$$tmp"; \
 		find "$$tmp" -name '*.md' | while read -r file; do \
 			doc/manual/process-includes.sh $$file $$file; \
 		done; \
 		set -euo pipefail; \
 		RUST_LOG=warn mdbook build "$$tmp/manual" -d $(DESTDIR)$(docdir)/manual.tmp 2>&1 \
 			| { grep -Fv "because fragment resolution isn't implemented" || :; }; \
 		rm -rf "$$tmp/manual"
 	@rm -rf $(DESTDIR)$(docdir)/manual
 	@mv $(DESTDIR)$(docdir)/manual.tmp/html $(DESTDIR)$(docdir)/manual
 	@rm -rf $(DESTDIR)$(docdir)/manual.tmp
 endif
--- a/doc/manual/meson.build
+++ b/doc/manual/meson.build
@ -1,301 +0,0 @@
 nix_env_for_docs = {
  'HOME': '/dummy',
  'NIX_CONF_DIR': '/dummy',
  'NIX_SSL_CERT_FILE': '/dummy/no-ca-bundle.crt',
  'NIX_STATE_DIR': '/dummy',
  'NIX_CONFIG': 'cores = 0',
 }
 nix_for_docs = [ nix, '--experimental-features', 'nix-command' ]
 nix_eval_for_docs = nix_for_docs + [
  'eval',
  '-I', 'nix/corepkgs=corepkgs',
  '--store', 'dummy://',
  '--impure',
  '--raw',
 ]
 nix_conf_file_json = custom_target(
  command : nix_for_docs + [ 'show-config', '--json' ],
  capture : true,
  output : 'conf-file.json',
  env : nix_env_for_docs,
 )
 nix_conf_file_md_body = custom_target(
  command : nix_eval_for_docs + [
    '--expr',
    '(import @INPUT0@).showSettings { inlineHTML = true; } (builtins.fromJSON (builtins.readFile @INPUT1@))',
  ],
  capture : true,
  input : [
    'utils.nix',
    nix_conf_file_json,
  ],
  output : 'conf-file.md.body',
  env : nix_env_for_docs,
 )
 nix_conf_file_md = custom_target(
  command : [ 'cat', '@INPUT@' ],
  capture : true,
  input : [
    'src/command-ref/conf-file-prefix.md',
    nix_conf_file_md_body,
  ],
  output : 'conf-file.md',
 )
 nix_exp_features_json = custom_target(
  command : [ nix, '__dump-xp-features' ],
  capture : true,
  output : 'xp-features.json',
 )
 nix_exp_feature_shortlist = custom_target(
  command : nix_eval_for_docs + [
    '--expr',
    'import @INPUT0@ (builtins.fromJSON (builtins.readFile @INPUT1@))',
  ],
  input : [
    'generate-xp-features-shortlist.nix',
    nix_exp_features_json,
  ],
  output : 'experimental-features-shortlist.md',
  capture : true,
  env : nix_env_for_docs,
 )
 nix_nested_manpages = [
  [ 'nix-env',
    [
      'delete-generations',
      'install',
      'list-generations',
      'query',
      'rollback',
      'set-flag',
      'set',
      'switch-generation',
      'switch-profile',
      'uninstall',
      'upgrade',
    ],
  ],
  [ 'nix-store',
    [
      'add-fixed',
      'add',
      'delete',
      'dump-db',
      'dump',
      'export',
      'gc',
      'generate-binary-cache-key',
      'import',
      'load-db',
      'optimise',
      'print-env',
      'query',
      'read-log',
      'realise',
      'repair-path',
      'restore',
      'serve',
      'verify',
      'verify-path',
    ],
  ],
 ]
 foreach command : nix_nested_manpages
  foreach page : command[1]
    custom_target(
      command : [
        './render-manpage.sh',
        '--out-no-smarty',
        command[0] + ' --' + page,
        '1',
        '@INPUT@',
        '@OUTPUT@.tmp',
        '@OUTPUT@',
      ],
      input : 'src/command-ref' / command[0] / (page + '.md'),
      output : command[0] + '-' + page + '.1',
      install : true,
      install_dir : mandir / 'man1',
    )
  endforeach
 endforeach
 nix3_cli_json = custom_target(
  command : [ nix, '__dump-cli' ],
  capture : true,
  output : 'nix.json',
 )
 # `nix eval --write-to` is rather picky, and refuses to write to a directory that exists at all.
 # This is fine for clean builds because it creates the directory and then is never run again,
 # but during development if nix.json changes, then using `nix eval --write-to` will error,
 # since that part of the build directory already exists.
 # Thus, another Python script. It runs the relevant `nix eval --write-to` command in a temporary
 # directory, and then copies that tree to our build output directory.
 nix3_cli_files = custom_target(
  command : [
    python,
    '@INPUT0@',
    '--nix=@INPUT1@',
    '--generator=@INPUT2@',
    '--cli-json=@INPUT3@',
    '--output=@OUTPUT@',
  ],
  input : [
    'generate-manpage.py', # INPUT0
    nix, # INPUT1
    'generate-manpage.nix', # INPUT2
    nix3_cli_json, # INPUT3
    'utils.nix',
  ],
  output : 'new-cli',
 )
 nix3_manpages = [
  'nix3-build',
  'nix3-bundle',
  'nix3-copy',
  'nix3-daemon',
  'nix3-derivation-add',
  'nix3-derivation',
  'nix3-derivation-show',
  'nix3-develop',
  'nix3-doctor',
  'nix3-edit',
  'nix3-eval',
  'nix3-flake-archive',
  'nix3-flake-check',
  'nix3-flake-clone',
  'nix3-flake-info',
  'nix3-flake-init',
  'nix3-flake-lock',
  'nix3-flake',
  'nix3-flake-metadata',
  'nix3-flake-new',
  'nix3-flake-prefetch',
  'nix3-flake-show',
  'nix3-flake-update',
  'nix3-fmt',
  'nix3-hash-file',
  'nix3-hash',
  'nix3-hash-path',
  'nix3-hash-to-base16',
  'nix3-hash-to-base32',
  'nix3-hash-to-base64',
  'nix3-hash-to-sri',
  'nix3-help',
  'nix3-help-stores',
  'nix3-key-convert-secret-to-public',
  'nix3-key-generate-secret',
  'nix3-key',
  'nix3-log',
  'nix3-nar-cat',
  'nix3-nar-dump-path',
  'nix3-nar-ls',
  'nix3-nar',
  'nix3-path-info',
  'nix3-print-dev-env',
  'nix3-profile-diff-closures',
  'nix3-profile-history',
  'nix3-profile-install',
  'nix3-profile-list',
  'nix3-profile',
  'nix3-profile-remove',
  'nix3-profile-rollback',
  'nix3-profile-upgrade',
  'nix3-profile-wipe-history',
  'nix3-realisation-info',
  'nix3-realisation',
  'nix3-registry-add',
  'nix3-registry-list',
  'nix3-registry',
  'nix3-registry-pin',
  'nix3-registry-remove',
  'nix3-repl',
  'nix3-run',
  'nix3-search',
  'nix3-shell',
  'nix3-show-config',
  'nix3-store-add-file',
  'nix3-store-add-path',
  'nix3-store-cat',
  'nix3-store-copy-log',
  'nix3-store-copy-sigs',
  'nix3-store-delete',
  'nix3-store-diff-closures',
  'nix3-store-dump-path',
  'nix3-store-gc',
  'nix3-store-ls',
  'nix3-store-make-content-addressed',
  'nix3-store',
  'nix3-store-optimise',
  'nix3-store-path-from-hash-part',
  'nix3-store-ping',
  'nix3-store-prefetch-file',
  'nix3-store-repair',
  'nix3-store-sign',
  'nix3-store-verify',
  'nix3-upgrade-nix',
  'nix3-why-depends',
  'nix',
 ]
 foreach page : nix3_manpages
  custom_target(
    command : [
      './render-manpage.sh',
      page,
      '1',
      '@INPUT0@/' + page + '.md',
      '@OUTPUT@.tmp',
      '@OUTPUT@',
    ],
    input : nix3_cli_files,
    output : page + '.1',
    install : true,
    install_dir : mandir / 'man1',
  )
 endforeach
 nix_manpages = [
  [ 'nix-env', 1 ],
  [ 'nix-store', 1 ],
  [ 'nix-build', 1 ],
  [ 'nix-shell', 1 ],
  [ 'nix-instantiate', 1 ],
  [ 'nix-collect-garbage', 1 ],
  [ 'nix-prefetch-url', 1 ],
  [ 'nix-channel', 1 ],
  [ 'nix-hash', 1 ],
  [ 'nix-copy-closure', 1 ],
  [ 'nix.conf', 5, nix_conf_file_md, nix_exp_feature_shortlist ],
  [ 'nix-daemon', 8 ],
  [ 'nix-profiles', 5, 'src/command-ref/files/profiles.md', nix_exp_feature_shortlist ],
 ]
 foreach entry : nix_manpages
  custom_target(
    command : [
      './render-manpage.sh',
      entry[0],
      entry[1].to_string(),
      '@INPUT0@',
      '@OUTPUT@.tmp',
      '@OUTPUT@',
      meson.current_build_dir(),
    ],
    input : [
      entry.get(2, 'src/command-ref' / (entry[0] + '.md')),
      entry.get(3, []),
    ],
    output : '@0@.@1@'.format(entry[0], entry[1]),
    install : true,
    install_dir : mandir / 'man@0@'.format(entry[1]),
  )
 endforeach
--- a/doc/manual/process-includes.sh
+++ b/doc/manual/process-includes.sh
@ -1,32 +0,0 @@
 #!/bin/sh
 set -euo pipefail
 infile="$1"
 outfile="$2"
 shift 2
 # set a search path for includes. the old makefile-based system splorked
 # everything into the source tree and was thus able to not have a search
 # path, but the meson system generates intermediate files into dedicated
 # directories separate from the source. we still retain the implicit old
 # behavior for now as the base search path, once meson is the default we
 # can revisit this and remove the implicit search path entry. it's fine.
 set -- "$(dirname "$infile")" "$@"
 # re-implement mdBook's include directive to make it usable for terminal output and for proper @docroot@ substitution
 (grep '{{#include' "$infile" || true) | while read -r line; do
    found=false
    include="$(printf "$line" | sed 's/{{#include \(.*\)}}/\1/')"
    for path in "$@"; do
        filename="$path/$include"
        if [ -e "$filename" ]; then
            found=true
            matchline="$(printf "$line" | sed 's|/|\\/|g')"
            sed -i "/$matchline/r $filename" "$outfile"
            sed -i "s/$matchline//" "$outfile"
            break
        fi
    done
    $found || ( echo "#include-d file '$filename' does not exist." >&2; exit 1; )
 done
--- a/doc/manual/quote-literals.xsl
+++ b/doc/manual/quote-literals.xsl
@ -1,40 +0,0 @@
 <?xml version="1.0"?>
 <xsl:stylesheet
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:str="http://exslt.org/strings"
  extension-element-prefixes="str">
  <xsl:output method="xml"/>
  <xsl:template match="function|command|literal|varname|filename|option|quote">`<xsl:apply-templates/>'</xsl:template>
  <xsl:template match="token"><xsl:text>    </xsl:text><xsl:apply-templates /><xsl:text>
 </xsl:text></xsl:template>
  <xsl:template match="screen|programlisting">
    <screen><xsl:apply-templates select="str:split(., '&#xA;')" /></screen>
  </xsl:template>
  <xsl:template match="section[following::section]">
    <section>
      <xsl:apply-templates />
      <screen><xsl:text>
      </xsl:text></screen>
    </section>
  </xsl:template>
  <xsl:template match="*">
    <xsl:element name="{name(.)}" namespace="{namespace-uri(.)}">
      <xsl:copy-of select="namespace::*" />
      <xsl:for-each select="@*">
 	<xsl:attribute name="{name(.)}" namespace="{namespace-uri(.)}">
 	  <xsl:value-of select="."/>
 	</xsl:attribute>
      </xsl:for-each>
      <xsl:apply-templates/>
    </xsl:element>
  </xsl:template>
 </xsl:stylesheet>
--- a/doc/manual/redirects.js
+++ b/doc/manual/redirects.js
@ -1,441 +0,0 @@
 // redirect rules for URL fragments (client-side) to prevent link rot.
 // this must be done on the client side, as web servers do not see the fragment part of the URL.
 // it will only work with JavaScript enabled in the browser, but this is the best we can do here.
 // see ./_redirects for path redirects (client-side)
 // redirects are declared as follows:
 // each entry has as its key a path matching the requested URL path, relative to the mdBook document root.
 //
 //     IMPORTANT: it must specify the full path with file name and suffix
 //
 // each entry is itself a set of key-value pairs, where
 // - keys are anchors on the matched path.
 // - values are redirection targets relative to the current path.
 const redirects = {
 "index.html": {
    "part-advanced-topics": "advanced-topics/advanced-topics.html",
    "chap-tuning-cores-and-jobs": "advanced-topics/cores-vs-jobs.html",
    "chap-diff-hook": "advanced-topics/diff-hook.html",
    "check-dirs-are-unregistered": "advanced-topics/diff-hook.html#check-dirs-are-unregistered",
    "chap-distributed-builds": "advanced-topics/distributed-builds.html",
    "chap-post-build-hook": "advanced-topics/post-build-hook.html",
    "chap-post-build-hook-caveats": "advanced-topics/post-build-hook.html#implementation-caveats",
    "chap-writing-nix-expressions": "language/index.html",
    "part-command-ref": "command-ref/command-ref.html",
    "conf-allow-import-from-derivation": "command-ref/conf-file.html#conf-allow-import-from-derivation",
    "conf-allow-new-privileges": "command-ref/conf-file.html#conf-allow-new-privileges",
    "conf-allowed-uris": "command-ref/conf-file.html#conf-allowed-uris",
    "conf-allowed-users": "command-ref/conf-file.html#conf-allowed-users",
    "conf-auto-optimise-store": "command-ref/conf-file.html#conf-auto-optimise-store",
    "conf-binary-cache-public-keys": "command-ref/conf-file.html#conf-binary-cache-public-keys",
    "conf-binary-caches": "command-ref/conf-file.html#conf-binary-caches",
    "conf-build-compress-log": "command-ref/conf-file.html#conf-build-compress-log",
    "conf-build-cores": "command-ref/conf-file.html#conf-build-cores",
    "conf-build-extra-chroot-dirs": "command-ref/conf-file.html#conf-build-extra-chroot-dirs",
    "conf-build-extra-sandbox-paths": "command-ref/conf-file.html#conf-build-extra-sandbox-paths",
    "conf-build-fallback": "command-ref/conf-file.html#conf-build-fallback",
    "conf-build-max-jobs": "command-ref/conf-file.html#conf-build-max-jobs",
    "conf-build-max-log-size": "command-ref/conf-file.html#conf-build-max-log-size",
    "conf-build-max-silent-time": "command-ref/conf-file.html#conf-build-max-silent-time",
    "conf-build-timeout": "command-ref/conf-file.html#conf-build-timeout",
    "conf-build-use-chroot": "command-ref/conf-file.html#conf-build-use-chroot",
    "conf-build-use-sandbox": "command-ref/conf-file.html#conf-build-use-sandbox",
    "conf-build-use-substitutes": "command-ref/conf-file.html#conf-build-use-substitutes",
    "conf-build-users-group": "command-ref/conf-file.html#conf-build-users-group",
    "conf-builders": "command-ref/conf-file.html#conf-builders",
    "conf-builders-use-substitutes": "command-ref/conf-file.html#conf-builders-use-substitutes",
    "conf-compress-build-log": "command-ref/conf-file.html#conf-compress-build-log",
    "conf-connect-timeout": "command-ref/conf-file.html#conf-connect-timeout",
    "conf-cores": "command-ref/conf-file.html#conf-cores",
    "conf-diff-hook": "command-ref/conf-file.html#conf-diff-hook",
    "conf-env-keep-derivations": "command-ref/conf-file.html#conf-env-keep-derivations",
    "conf-extra-binary-caches": "command-ref/conf-file.html#conf-extra-binary-caches",
    "conf-extra-platforms": "command-ref/conf-file.html#conf-extra-platforms",
    "conf-extra-sandbox-paths": "command-ref/conf-file.html#conf-extra-sandbox-paths",
    "conf-extra-substituters": "command-ref/conf-file.html#conf-extra-substituters",
    "conf-fallback": "command-ref/conf-file.html#conf-fallback",
    "conf-fsync-metadata": "command-ref/conf-file.html#conf-fsync-metadata",
    "conf-gc-keep-derivations": "command-ref/conf-file.html#conf-gc-keep-derivations",
    "conf-gc-keep-outputs": "command-ref/conf-file.html#conf-gc-keep-outputs",
    "conf-hashed-mirrors": "command-ref/conf-file.html#conf-hashed-mirrors",
    "conf-http-connections": "command-ref/conf-file.html#conf-http-connections",
    "conf-keep-build-log": "command-ref/conf-file.html#conf-keep-build-log",
    "conf-keep-derivations": "command-ref/conf-file.html#conf-keep-derivations",
    "conf-keep-env-derivations": "command-ref/conf-file.html#conf-keep-env-derivations",
    "conf-keep-outputs": "command-ref/conf-file.html#conf-keep-outputs",
    "conf-max-build-log-size": "command-ref/conf-file.html#conf-max-build-log-size",
    "conf-max-free": "command-ref/conf-file.html#conf-max-free",
    "conf-max-jobs": "command-ref/conf-file.html#conf-max-jobs",
    "conf-max-silent-time": "command-ref/conf-file.html#conf-max-silent-time",
    "conf-min-free": "command-ref/conf-file.html#conf-min-free",
    "conf-narinfo-cache-negative-ttl": "command-ref/conf-file.html#conf-narinfo-cache-negative-ttl",
    "conf-narinfo-cache-positive-ttl": "command-ref/conf-file.html#conf-narinfo-cache-positive-ttl",
    "conf-netrc-file": "command-ref/conf-file.html#conf-netrc-file",
    "conf-plugin-files": "command-ref/conf-file.html#conf-plugin-files",
    "conf-post-build-hook": "command-ref/conf-file.html#conf-post-build-hook",
    "conf-pre-build-hook": "command-ref/conf-file.html#conf-pre-build-hook",
    "conf-require-sigs": "command-ref/conf-file.html#conf-require-sigs",
    "conf-restrict-eval": "command-ref/conf-file.html#conf-restrict-eval",
    "conf-run-diff-hook": "command-ref/conf-file.html#conf-run-diff-hook",
    "conf-sandbox": "command-ref/conf-file.html#conf-sandbox",
    "conf-sandbox-dev-shm-size": "command-ref/conf-file.html#conf-sandbox-dev-shm-size",
    "conf-sandbox-paths": "command-ref/conf-file.html#conf-sandbox-paths",
    "conf-secret-key-files": "command-ref/conf-file.html#conf-secret-key-files",
    "conf-show-trace": "command-ref/conf-file.html#conf-show-trace",
    "conf-stalled-download-timeout": "command-ref/conf-file.html#conf-stalled-download-timeout",
    "conf-substitute": "command-ref/conf-file.html#conf-substitute",
    "conf-substituters": "command-ref/conf-file.html#conf-substituters",
    "conf-system": "command-ref/conf-file.html#conf-system",
    "conf-system-features": "command-ref/conf-file.html#conf-system-features",
    "conf-tarball-ttl": "command-ref/conf-file.html#conf-tarball-ttl",
    "conf-timeout": "command-ref/conf-file.html#conf-timeout",
    "conf-trace-function-calls": "command-ref/conf-file.html#conf-trace-function-calls",
    "conf-trusted-binary-caches": "command-ref/conf-file.html#conf-trusted-binary-caches",
    "conf-trusted-public-keys": "command-ref/conf-file.html#conf-trusted-public-keys",
    "conf-trusted-substituters": "command-ref/conf-file.html#conf-trusted-substituters",
    "conf-trusted-users": "command-ref/conf-file.html#conf-trusted-users",
    "extra-sandbox-paths": "command-ref/conf-file.html#extra-sandbox-paths",
    "sec-conf-file": "command-ref/conf-file.html",
    "env-NIX_PATH": "command-ref/env-common.html#env-NIX_PATH",
    "env-common": "command-ref/env-common.html",
    "envar-remote": "command-ref/env-common.html#env-NIX_REMOTE",
    "sec-common-env": "command-ref/env-common.html",
    "ch-files": "command-ref/files.html",
    "ch-main-commands": "command-ref/main-commands.html",
    "opt-out-link": "command-ref/nix-build.html#opt-out-link",
    "sec-nix-build": "command-ref/nix-build.html",
    "sec-nix-channel": "command-ref/nix-channel.html",
    "sec-nix-collect-garbage": "command-ref/nix-collect-garbage.html",
    "sec-nix-copy-closure": "command-ref/nix-copy-closure.html",
    "sec-nix-daemon": "command-ref/nix-daemon.html",
    "refsec-nix-env-install-examples": "command-ref/nix-env.html#examples",
    "rsec-nix-env-install": "command-ref/nix-env.html#operation---install",
    "rsec-nix-env-set": "command-ref/nix-env.html#operation---set",
    "rsec-nix-env-set-flag": "command-ref/nix-env.html#operation---set-flag",
    "rsec-nix-env-upgrade": "command-ref/nix-env.html#operation---upgrade",
    "sec-nix-env": "command-ref/nix-env.html",
    "ssec-version-comparisons": "command-ref/nix-env.html#versions",
    "sec-nix-hash": "command-ref/nix-hash.html",
    "sec-nix-instantiate": "command-ref/nix-instantiate.html",
    "sec-nix-prefetch-url": "command-ref/nix-prefetch-url.html",
    "sec-nix-shell": "command-ref/nix-shell.html",
    "ssec-nix-shell-shebang": "command-ref/nix-shell.html#use-as-a--interpreter",
    "nixref-queries": "command-ref/nix-store.html#queries",
    "opt-add-root": "command-ref/nix-store.html#opt-add-root",
    "refsec-nix-store-dump": "command-ref/nix-store.html#operation---dump",
    "refsec-nix-store-export": "command-ref/nix-store.html#operation---export",
    "refsec-nix-store-import": "command-ref/nix-store.html#operation---import",
    "refsec-nix-store-query": "command-ref/nix-store.html#operation---query",
    "refsec-nix-store-verify": "command-ref/nix-store.html#operation---verify",
    "rsec-nix-store-gc": "command-ref/nix-store.html#operation---gc",
    "rsec-nix-store-generate-binary-cache-key": "command-ref/nix-store.html#operation---generate-binary-cache-key",
    "rsec-nix-store-realise": "command-ref/nix-store.html#operation---realise",
    "rsec-nix-store-serve": "command-ref/nix-store.html#operation---serve",
    "sec-nix-store": "command-ref/nix-store.html",
    "opt-I": "command-ref/opt-common.html#opt-I",
    "opt-attr": "command-ref/opt-common.html#opt-attr",
    "opt-common": "command-ref/opt-common.html",
    "opt-cores": "command-ref/opt-common.html#opt-cores",
    "opt-log-format": "command-ref/opt-common.html#opt-log-format",
    "opt-max-jobs": "command-ref/opt-common.html#opt-max-jobs",
    "opt-max-silent-time": "command-ref/opt-common.html#opt-max-silent-time",
    "opt-timeout": "command-ref/opt-common.html#opt-timeout",
    "sec-common-options": "command-ref/opt-common.html",
    "ch-utilities": "command-ref/utilities.html",
    "chap-hacking": "contributing/hacking.html",
    "adv-attr-allowSubstitutes": "language/advanced-attributes.html#adv-attr-allowSubstitutes",
    "adv-attr-allowedReferences": "language/advanced-attributes.html#adv-attr-allowedReferences",
    "adv-attr-allowedRequisites": "language/advanced-attributes.html#adv-attr-allowedRequisites",
    "adv-attr-disallowedReferences": "language/advanced-attributes.html#adv-attr-disallowedReferences",
    "adv-attr-disallowedRequisites": "language/advanced-attributes.html#adv-attr-disallowedRequisites",
    "adv-attr-exportReferencesGraph": "language/advanced-attributes.html#adv-attr-exportReferencesGraph",
    "adv-attr-impureEnvVars": "language/advanced-attributes.html#adv-attr-impureEnvVars",
    "adv-attr-outputHash": "language/advanced-attributes.html#adv-attr-outputHash",
    "adv-attr-outputHashAlgo": "language/advanced-attributes.html#adv-attr-outputHashAlgo",
    "adv-attr-outputHashMode": "language/advanced-attributes.html#adv-attr-outputHashMode",
    "adv-attr-passAsFile": "language/advanced-attributes.html#adv-attr-passAsFile",
    "adv-attr-preferLocalBuild": "language/advanced-attributes.html#adv-attr-preferLocalBuild",
    "fixed-output-drvs": "language/advanced-attributes.html#adv-attr-outputHash",
    "sec-advanced-attributes": "language/advanced-attributes.html",
    "builtin-abort": "language/builtins.html#builtins-abort",
    "builtin-add": "language/builtins.html#builtins-add",
    "builtin-all": "language/builtins.html#builtins-all",
    "builtin-any": "language/builtins.html#builtins-any",
    "builtin-attrNames": "language/builtins.html#builtins-attrNames",
    "builtin-attrValues": "language/builtins.html#builtins-attrValues",
    "builtin-baseNameOf": "language/builtins.html#builtins-baseNameOf",
    "builtin-bitAnd": "language/builtins.html#builtins-bitAnd",
    "builtin-bitOr": "language/builtins.html#builtins-bitOr",
    "builtin-bitXor": "language/builtins.html#builtins-bitXor",
    "builtin-builtins": "language/builtins.html#builtins-builtins",
    "builtin-compareVersions": "language/builtins.html#builtins-compareVersions",
    "builtin-concatLists": "language/builtins.html#builtins-concatLists",
    "builtin-concatStringsSep": "language/builtins.html#builtins-concatStringsSep",
    "builtin-currentSystem": "language/builtins.html#builtins-currentSystem",
    "builtin-deepSeq": "language/builtins.html#builtins-deepSeq",
    "builtin-derivation": "language/builtins.html#builtins-derivation",
    "builtin-dirOf": "language/builtins.html#builtins-dirOf",
    "builtin-div": "language/builtins.html#builtins-div",
    "builtin-elem": "language/builtins.html#builtins-elem",
    "builtin-elemAt": "language/builtins.html#builtins-elemAt",
    "builtin-fetchGit": "language/builtins.html#builtins-fetchGit",
    "builtin-fetchTarball": "language/builtins.html#builtins-fetchTarball",
    "builtin-fetchurl": "language/builtins.html#builtins-fetchurl",
    "builtin-filterSource": "language/builtins.html#builtins-filterSource",
    "builtin-foldl-prime": "language/builtins.html#builtins-foldl-prime",
    "builtin-fromJSON": "language/builtins.html#builtins-fromJSON",
    "builtin-functionArgs": "language/builtins.html#builtins-functionArgs",
    "builtin-genList": "language/builtins.html#builtins-genList",
    "builtin-getAttr": "language/builtins.html#builtins-getAttr",
    "builtin-getEnv": "language/builtins.html#builtins-getEnv",
    "builtin-hasAttr": "language/builtins.html#builtins-hasAttr",
    "builtin-hashFile": "language/builtins.html#builtins-hashFile",
    "builtin-hashString": "language/builtins.html#builtins-hashString",
    "builtin-head": "language/builtins.html#builtins-head",
    "builtin-import": "language/builtins.html#builtins-import",
    "builtin-intersectAttrs": "language/builtins.html#builtins-intersectAttrs",
    "builtin-isAttrs": "language/builtins.html#builtins-isAttrs",
    "builtin-isBool": "language/builtins.html#builtins-isBool",
    "builtin-isFloat": "language/builtins.html#builtins-isFloat",
    "builtin-isFunction": "language/builtins.html#builtins-isFunction",
    "builtin-isInt": "language/builtins.html#builtins-isInt",
    "builtin-isList": "language/builtins.html#builtins-isList",
    "builtin-isNull": "language/builtins.html#builtins-isNull",
    "builtin-isString": "language/builtins.html#builtins-isString",
    "builtin-length": "language/builtins.html#builtins-length",
    "builtin-lessThan": "language/builtins.html#builtins-lessThan",
    "builtin-listToAttrs": "language/builtins.html#builtins-listToAttrs",
    "builtin-map": "language/builtins.html#builtins-map",
    "builtin-match": "language/builtins.html#builtins-match",
    "builtin-mul": "language/builtins.html#builtins-mul",
    "builtin-parseDrvName": "language/builtins.html#builtins-parseDrvName",
    "builtin-path": "language/builtins.html#builtins-path",
    "builtin-pathExists": "language/builtins.html#builtins-pathExists",
    "builtin-placeholder": "language/builtins.html#builtins-placeholder",
    "builtin-readDir": "language/builtins.html#builtins-readDir",
    "builtin-readFile": "language/builtins.html#builtins-readFile",
    "builtin-removeAttrs": "language/builtins.html#builtins-removeAttrs",
    "builtin-replaceStrings": "language/builtins.html#builtins-replaceStrings",
    "builtin-seq": "language/builtins.html#builtins-seq",
    "builtin-sort": "language/builtins.html#builtins-sort",
    "builtin-split": "language/builtins.html#builtins-split",
    "builtin-splitVersion": "language/builtins.html#builtins-splitVersion",
    "builtin-stringLength": "language/builtins.html#builtins-stringLength",
    "builtin-sub": "language/builtins.html#builtins-sub",
    "builtin-substring": "language/builtins.html#builtins-substring",
    "builtin-tail": "language/builtins.html#builtins-tail",
    "builtin-throw": "language/builtins.html#builtins-throw",
    "builtin-toFile": "language/builtins.html#builtins-toFile",
    "builtin-toJSON": "language/builtins.html#builtins-toJSON",
    "builtin-toPath": "language/builtins.html#builtins-toPath",
    "builtin-toString": "language/builtins.html#builtins-toString",
    "builtin-toXML": "language/builtins.html#builtins-toXML",
    "builtin-trace": "language/builtins.html#builtins-trace",
    "builtin-tryEval": "language/builtins.html#builtins-tryEval",
    "builtin-typeOf": "language/builtins.html#builtins-typeOf",
    "ssec-builtins": "language/builtins.html",
    "attr-system": "language/derivations.html#attr-system",
    "ssec-derivation": "language/derivations.html",
    "ch-expression-language": "language/index.html",
    "sec-constructs": "language/constructs.html",
    "sect-let-language": "language/constructs.html#let-language",
    "ss-functions": "language/constructs.html#functions",
    "sec-language-operators": "language/operators.html",
    "table-operators": "language/operators.html",
    "ssec-values": "language/values.html",
    "gloss-closure": "glossary.html#gloss-closure",
    "gloss-derivation": "glossary.html#gloss-derivation",
    "gloss-deriver": "glossary.html#gloss-deriver",
    "gloss-nar": "glossary.html#gloss-nar",
    "gloss-output-path": "glossary.html#gloss-output-path",
    "gloss-profile": "glossary.html#gloss-profile",
    "gloss-reachable": "glossary.html#gloss-reachable",
    "gloss-reference": "glossary.html#gloss-reference",
    "gloss-substitute": "glossary.html#gloss-substitute",
    "gloss-user-env": "glossary.html#gloss-user-env",
    "gloss-validity": "glossary.html#gloss-validity",
    "part-glossary": "glossary.html",
    "sec-building-source": "installation/building-source.html",
    "ch-env-variables": "installation/env-variables.html",
    "sec-installer-proxy-settings": "installation/env-variables.html#proxy-environment-variables",
    "sec-nix-ssl-cert-file": "installation/env-variables.html#nix_ssl_cert_file",
    "sec-nix-ssl-cert-file-with-nix-daemon-and-macos": "installation/env-variables.html#nix_ssl_cert_file-with-macos-and-the-nix-daemon",
    "chap-installation": "installation/installation.html",
    "ch-installing-binary": "installation/installing-binary.html",
    "sect-macos-installation": "installation/installing-binary.html#macos-installation",
    "sect-macos-installation-change-store-prefix": "installation/installing-binary.html#macos-installation",
    "sect-macos-installation-encrypted-volume": "installation/installing-binary.html#macos-installation",
    "sect-macos-installation-recommended-notes": "installation/installing-binary.html#macos-installation",
    "sect-macos-installation-symlink": "installation/installing-binary.html#macos-installation",
    "sect-multi-user-installation": "installation/installing-binary.html#multi-user-installation",
    "sect-nix-install-binary-tarball": "installation/installing-binary.html#installing-from-a-binary-tarball",
    "sect-nix-install-pinned-version-url": "installation/installing-binary.html#installing-a-pinned-nix-version-from-a-url",
    "sect-single-user-installation": "installation/installing-binary.html#single-user-installation",
    "ch-installing-source": "installation/installing-source.html",
    "ssec-multi-user": "installation/multi-user.html",
    "ch-nix-security": "installation/nix-security.html",
    "sec-obtaining-source": "installation/obtaining-source.html",
    "sec-prerequisites-source": "installation/prerequisites-source.html",
    "sec-single-user": "installation/single-user.html",
    "ch-supported-platforms": "installation/supported-platforms.html",
    "ch-upgrading-nix": "installation/upgrading.html",
    "ch-about-nix": "introduction.html",
    "chap-introduction": "introduction.html",
    "ch-basic-package-mgmt": "package-management/basic-package-mgmt.html",
    "ssec-binary-cache-substituter": "package-management/binary-cache-substituter.html",
    "sec-channels": "command-ref/nix-channel.html",
    "ssec-copy-closure": "package-management/copy-closure.html",
    "sec-garbage-collection": "package-management/garbage-collection.html",
    "ssec-gc-roots": "package-management/garbage-collector-roots.html",
    "chap-package-management": "package-management/package-management.html",
    "sec-profiles": "package-management/profiles.html",
    "ssec-s3-substituter": "package-management/s3-substituter.html",
    "ssec-s3-substituter-anonymous-reads": "package-management/s3-substituter.html#anonymous-reads-to-your-s3-compatible-binary-cache",
    "ssec-s3-substituter-authenticated-reads": "package-management/s3-substituter.html#authenticated-reads-to-your-s3-binary-cache",
    "ssec-s3-substituter-authenticated-writes": "package-management/s3-substituter.html#authenticated-writes-to-your-s3-compatible-binary-cache",
    "sec-sharing-packages": "package-management/sharing-packages.html",
    "ssec-ssh-substituter": "package-management/ssh-substituter.html",
    "chap-quick-start": "quick-start.html",
    "sec-relnotes": "release-notes/release-notes.html",
    "ch-relnotes-0.10.1": "release-notes/rl-0.10.1.html",
    "ch-relnotes-0.10": "release-notes/rl-0.10.html",
    "ssec-relnotes-0.11": "release-notes/rl-0.11.html",
    "ssec-relnotes-0.12": "release-notes/rl-0.12.html",
    "ssec-relnotes-0.13": "release-notes/rl-0.13.html",
    "ssec-relnotes-0.14": "release-notes/rl-0.14.html",
    "ssec-relnotes-0.15": "release-notes/rl-0.15.html",
    "ssec-relnotes-0.16": "release-notes/rl-0.16.html",
    "ch-relnotes-0.5": "release-notes/rl-0.5.html",
    "ch-relnotes-0.6": "release-notes/rl-0.6.html",
    "ch-relnotes-0.7": "release-notes/rl-0.7.html",
    "ch-relnotes-0.8.1": "release-notes/rl-0.8.1.html",
    "ch-relnotes-0.8": "release-notes/rl-0.8.html",
    "ch-relnotes-0.9.1": "release-notes/rl-0.9.1.html",
    "ch-relnotes-0.9.2": "release-notes/rl-0.9.2.html",
    "ch-relnotes-0.9": "release-notes/rl-0.9.html",
    "ssec-relnotes-1.0": "release-notes/rl-1.0.html",
    "ssec-relnotes-1.1": "release-notes/rl-1.1.html",
    "ssec-relnotes-1.10": "release-notes/rl-1.10.html",
    "ssec-relnotes-1.11.10": "release-notes/rl-1.11.10.html",
    "ssec-relnotes-1.11": "release-notes/rl-1.11.html",
    "ssec-relnotes-1.2": "release-notes/rl-1.2.html",
    "ssec-relnotes-1.3": "release-notes/rl-1.3.html",
    "ssec-relnotes-1.4": "release-notes/rl-1.4.html",
    "ssec-relnotes-1.5.1": "release-notes/rl-1.5.1.html",
    "ssec-relnotes-1.5.2": "release-notes/rl-1.5.2.html",
    "ssec-relnotes-1.5": "release-notes/rl-1.5.html",
    "ssec-relnotes-1.6.1": "release-notes/rl-1.6.1.html",
    "ssec-relnotes-1.6.0": "release-notes/rl-1.6.html",
    "ssec-relnotes-1.7": "release-notes/rl-1.7.html",
    "ssec-relnotes-1.8": "release-notes/rl-1.8.html",
    "ssec-relnotes-1.9": "release-notes/rl-1.9.html",
    "ssec-relnotes-2.0": "release-notes/rl-2.0.html",
    "ssec-relnotes-2.1": "release-notes/rl-2.1.html",
    "ssec-relnotes-2.2": "release-notes/rl-2.2.html",
    "ssec-relnotes-2.3": "release-notes/rl-2.3.html",
  },
  "language/values.html": {
    "simple-values": "#primitives",
    "lists": "#list",
    "strings": "#string",
    "lists": "#list",
    "attribute-sets": "#attribute-set",
  },
  "installation/installing-binary.html": {
    "linux": "uninstall.html#linux",
    "macos": "uninstall.html#macos",
    "uninstalling": "uninstall.html",
  }
  "contributing/hacking.html": {
    "nix-with-flakes": "#building-nix-with-flakes",
    "classic-nix": "#building-nix",
    "running-tests": "testing.html#running-tests",
    "unit-tests": "testing.html#unit-tests",
    "functional-tests": "testing.html#functional-tests",
    "debugging-failing-functional-tests": "testing.html#debugging-failing-functional-tests",
    "integration-tests": "testing.html#integration-tests",
    "installer-tests": "testing.html#installer-tests",
    "one-time-setup": "testing.html#one-time-setup",
    "using-the-ci-generated-installer-for-manual-testing": "testing.html#using-the-ci-generated-installer-for-manual-testing",
  }
 };
 // the following code matches the current page's URL against the set of redirects.
 //
 // it is written to minimize the latency between page load and redirect.
 // therefore we avoid function calls, copying data, and unnecessary loops.
 // IMPORTANT: we use stateful array operations and their order matters!
 //
 // matching URLs is more involved than it should be:
 //
 // 1. `document.location.pathname` can have an arbitrary prefix.
 //
 // 2. `path_to_root` is set by mdBook. it consists only of `../`s and
 //    determines the depth of `<path>` relative to the prefix:
 //
 //          `document.location.pathname`
 //        |------------------------------|
 //        /<prefix>/<path>/[<file>[.html]][#<anchor>]
 //                  |----|
 //              `path_to_root` has same number of path segments
 //
 //    source: https://phaiax.github.io/mdBook/format/theme/index-hbs.html#data
 //
 // 3. the following paths are equivalent:
 //
 //        /foo/bar/
 //        /foo/bar/index.html
 //        /foo/bar/index
 //
 //  4. the following paths are also equivalent:
 //
 //        /foo/bar/baz
 //        /foo/bar/baz.html
 //
 let segments = document.location.pathname.split('/');
 let file = segments.pop();
 // normalize file name
 if (file === '') { file = "index.html"; }
 else if (!file.endsWith('.html')) { file = file + '.html'; }
 segments.push(file);
 // use `path_to_root` to discern prefix from path.
 const depth = path_to_root.split('/').length;
 // remove segments containing prefix. the following works because
 // 1. the original `document.location.pathname` is absolute,
 //    hence first element of `segments` is always empty.
 // 2. last element of splitting `path_to_root` is also always empty.
 // 3. last element of `segments` is the file name.
 //
 // visual example:
 //
 //     '/foo/bar/baz.html'.split('/') -> [ '', 'foo', 'bar', 'baz.html' ]
 //          '../'.split('/')          -> [ '..', '' ]
 //
 // the following operations will then result in
 //
 //     path = 'bar/baz.html'
 //
 segments.splice(0, segments.length - depth);
 const path = segments.join('/');
 // anchor starts with the hash character (`#`),
 // but our redirect declarations don't, so we strip it.
 // example:
 //     document.location.hash -> '#foo'
 //     document.location.hash.substring(1) -> 'foo'
 const anchor = document.location.hash.substring(1);
 const redirect = redirects[path];
 if (redirect) {
  const target = redirect[anchor];
  if (target) {
    document.location.href = target;
  }
 }
--- a/doc/manual/render-manpage.sh
+++ b/doc/manual/render-manpage.sh
@ -1,22 +0,0 @@
 #!/bin/sh
 set -euo pipefail
 lowdown_args=
 if [ "$1" = --out-no-smarty ]; then
    lowdown_args=--out-no-smarty
    shift
 fi
 title="$1"
 section="$2"
 infile="$3"
 tmpfile="$4"
 outfile="$5"
 printf "Title: %s\n\n" "$title" > "$tmpfile"
 cat "$infile" >> "$tmpfile"
 "$(dirname "$0")"/process-includes.sh "$infile" "$tmpfile"
 lowdown -sT man --nroff-nolinks $lowdown_args -M section="$section" "$tmpfile" -o "$outfile"
 rm "$tmpfile"
--- a/doc/manual/rl-next-dev/build-timing-analysis.md
+++ b/doc/manual/rl-next-dev/build-timing-analysis.md
@ -1,15 +0,0 @@
 ---
 synopsis: Clang build timing analysis
 cls: 587
 ---
 We now have Clang build profiling available, which generates Chrome
 tracing files for each compilation unit. To enable it, run `meson configure
 build -Dprofile-build=enabled` then rerun the compilation.
 If you want to make the build go faster, do a clang build with meson, then run
 `maintainers/buildtime_report.sh build`, then contemplate how to improve the
 build time.
 You can also look at individual object files' traces in
 <https://ui.perfetto.dev>.
--- a/doc/manual/rl-next/better-errors-in-nix-repl.md
+++ b/doc/manual/rl-next/better-errors-in-nix-repl.md
@ -1,39 +0,0 @@
 ---
 synopsis: Concise error printing in `nix repl`
 prs: 9928
 ---
 Previously, if an element of a list or attribute set threw an error while
 evaluating, `nix repl` would print the entire error (including source location
 information) inline. This output was clumsy and difficult to parse:
 ```
 nix-repl> { err = builtins.throw "uh oh!"; }
 { err = «error:
       … while calling the 'throw' builtin
         at «string»:1:9:
            1| { err = builtins.throw "uh oh!"; }
             |         ^
       error: uh oh!»; }
 ```
 Now, only the error message is displayed, making the output much more readable.
 ```
 nix-repl> { err = builtins.throw "uh oh!"; }
 { err = «error: uh oh!»; }
 ```
 However, if the whole expression being evaluated throws an error, source
 locations and (if applicable) a stack trace are printed, just like you'd expect:
 ```
 nix-repl> builtins.throw "uh oh!"
 error:
       … while calling the 'throw' builtin
         at «string»:1:1:
            1| builtins.throw "uh oh!"
             | ^
       error: uh oh!
 ```
--- a/doc/manual/rl-next/debugger-locals-for-let-expressions.md
+++ b/doc/manual/rl-next/debugger-locals-for-let-expressions.md
@ -1,9 +0,0 @@
 ---
 synopsis: "`--debugger` can now access bindings from `let` expressions"
 prs: 9918
 issues: 8827
 ---
 Breakpoints and errors in the bindings of a `let` expression can now access
 those bindings in the debugger. Previously, only the body of `let` expressions
 could access those bindings.
--- a/doc/manual/rl-next/debugger-on-trace.md
+++ b/doc/manual/rl-next/debugger-on-trace.md
@ -1,9 +0,0 @@
 ---
 synopsis: Enter the `--debugger` when `builtins.trace` is called if `debugger-on-trace` is set
 prs: 9914
 ---
 If the `debugger-on-trace` option is set and `--debugger` is given,
 `builtins.trace` calls will behave similarly to `builtins.break` and will enter
 the debug REPL. This is useful for determining where warnings are being emitted
 from.
--- a/doc/manual/rl-next/drop-vendored-toml11.md
+++ b/doc/manual/rl-next/drop-vendored-toml11.md
@ -1,7 +0,0 @@
 ---
 synopsis: Stop vendoring toml11
 cls: 675
 ---
 We don't apply any patches to it, and vendoring it locks users into
 bugs (it hasn't been updated since its introduction in late 2021).
--- a/doc/manual/rl-next/drv-string-parse-hang.md
+++ b/doc/manual/rl-next/drv-string-parse-hang.md
@ -1,6 +0,0 @@
 ---
 synopsis: Fix handling of truncated `.drv` files.
 prs: 9673
 ---
 Previously a `.drv` that was truncated in the middle of a string would case nix to enter an infinite loop, eventually exhausting all memory and crashing.
--- a/doc/manual/rl-next/dup-attr-errors.md
+++ b/doc/manual/rl-next/dup-attr-errors.md
@ -1,22 +0,0 @@
 ---
 synopsis: Duplicate attribute reports are more accurate
 cls: 557
 ---
 Duplicate attribute errors are now more accurate, showing the path at which an error was detected rather than the full, possibly longer, path that caused the error.
 Error reports are now
 ```ShellSession
 $ nix eval --expr '{ a.b = 1; a.b.c.d = 1; }'
 error: attribute 'a.b' already defined at «string»:1:3
       at «string»:1:12:
            1| { a.b = 1; a.b.c.d = 1;
             |            ^
 ```
 instead of
 ```ShellSession
 $ nix eval --expr '{ a.b = 1; a.b.c.d = 1; }'
 error: attribute 'a.b.c.d' already defined at «string»:1:3
       at «string»:1:12:
            1| { a.b = 1; a.b.c.d = 1;
             |            ^
 ```
--- a/doc/manual/rl-next/empty-search-regex.md
+++ b/doc/manual/rl-next/empty-search-regex.md
@ -1,6 +0,0 @@
 ---
 synopsis: Disallow empty search regex in `nix search`
 prs: 9481
 ---
 [`nix search`](@docroot@/command-ref/new-cli/nix3-search.md) now requires a search regex to be passed. To show all packages, use `^`.
--- a/doc/manual/rl-next/enter-debugger-more-reliably-in-let-and-calls.md
+++ b/doc/manual/rl-next/enter-debugger-more-reliably-in-let-and-calls.md
@ -1,25 +0,0 @@
 ---
 synopsis: The `--debugger` will start more reliably in `let` expressions and function calls
 prs: 9917
 issues: 6649
 ---
 Previously, if you attempted to evaluate this file with the debugger:
 ```nix
 let
  a = builtins.trace "before inner break" (
    builtins.break "hello"
  );
  b = builtins.trace "before outer break" (
    builtins.break a
  );
 in
  b
 ```
 Nix would correctly enter the debugger at `builtins.break a`, but if you asked
 it to `:continue`, it would skip over the `builtins.break "hello"` expression
 entirely.
 Now, Nix will correctly enter the debugger at both breakpoints.
--- a/doc/manual/rl-next/env-size-reduction.md
+++ b/doc/manual/rl-next/env-size-reduction.md
@ -1,7 +0,0 @@
 ---
 synopsis: Reduce eval memory usage and wall time
 prs: 9658
 ---
 Reduce the size of the `Env` struct used in the evaluator by a pointer, or 8 bytes on most modern machines.
 This reduces memory usage during eval by around 2% and wall time by around 3%.
--- a/doc/manual/rl-next/eval-system.md
+++ b/doc/manual/rl-next/eval-system.md
@ -1,12 +0,0 @@
 ---
 synopsis: Add new `eval-system` setting
 prs: 4093
 ---
 Add a new `eval-system` option.
 Unlike `system`, it just overrides the value of `builtins.currentSystem`.
 This is more useful than overriding `system`, because you can build these derivations on remote builders which can work on the given system.
 In contrast, `system` also effects scheduling which will cause Nix to build those derivations locally even if that doesn't make sense.
 `eval-system` only takes effect if it is non-empty.
 If empty (the default) `system` is used as before, so there is no breakage.
--- a/doc/manual/rl-next/forbid-nested-debuggers.md
+++ b/doc/manual/rl-next/forbid-nested-debuggers.md
@ -1,32 +0,0 @@
 ---
 synopsis: Nested debuggers are no longer supported
 prs: 9920
 ---
 Previously, evaluating an expression that throws an error in the debugger would
 enter a second, nested debugger:
 ```
 nix-repl> builtins.throw "what"
 error: what
 Starting REPL to allow you to inspect the current state of the evaluator.
 Welcome to Nix 2.18.1. Type :? for help.
 nix-repl>
 ```
 Now, it just prints the error message like `nix repl`:
 ```
 nix-repl> builtins.throw "what"
 error:
       … while calling the 'throw' builtin
         at «string»:1:1:
            1| builtins.throw "what"
             | ^
       error: what
 ```
--- a/doc/manual/rl-next/formal-order.md
+++ b/doc/manual/rl-next/formal-order.md
@ -1,7 +0,0 @@
 ---
 synopsis: consistent order of lambda formals in printed expressions
 prs: 9874
 ---
 Always print lambda formals in lexicographic order rather than the internal, creation-time based symbol order.
 This makes printed formals independent of the context they appear in.
--- a/doc/manual/rl-next/inherit-error-positions.md
+++ b/doc/manual/rl-next/inherit-error-positions.md
@ -1,6 +0,0 @@
 ---
 synopsis: fix duplicate attribute error positions for `inherit`
 prs: 9874
 ---
 When an inherit caused a duplicate attribute error the position of the error was not reported correctly, placing the error with the inherit itself or at the start of the bindings block instead of the offending attribute name.
--- a/doc/manual/rl-next/inherit-from-by-need.md
+++ b/doc/manual/rl-next/inherit-from-by-need.md
@ -1,7 +0,0 @@
 ---
 synopsis: "`inherit (x) ...` evaluates `x` only once"
 prs: 9847
 ---
 `inherit (x) a b ...` now evaluates the expression `x` only once for all inherited attributes rather than once for each inherited attribute.
 This does not usually have a measurable impact, but side-effects (such as `builtins.trace`) would be duplicated and expensive expressions (such as derivations) could cause a measurable slowdown.
--- a/doc/manual/rl-next/nix-env-json-drv-path.md
+++ b/doc/manual/rl-next/nix-env-json-drv-path.md
@ -1,6 +0,0 @@
 ---
 synopsis: Fix `nix-env --query --drv-path --json`
 prs: 9257
 ---
 Fixed a bug where `nix-env --query` ignored `--drv-path` when `--json` was set.
--- a/doc/manual/rl-next/nix-flake-check-logs-actions.md
+++ b/doc/manual/rl-next/nix-flake-check-logs-actions.md
@ -1,33 +0,0 @@
 ---
 synopsis: "`nix flake check` logs the checks"
 issues: 8882
 prs: 8893
 ---
 `nix flake check` now logs the checks it runs and the derivations it evaluates:
 ```
 $ nix flake check -v
 evaluating flake...
 checking flake output 'checks'...
 checking derivation 'checks.aarch64-darwin.ghciwatch-tests'...
 derivation evaluated to /nix/store/nh7dlvsrhds4cxl91mvgj4h5cbq6skmq-ghciwatch-test-0.3.0.drv
 checking derivation 'checks.aarch64-darwin.ghciwatch-clippy'...
 derivation evaluated to /nix/store/9cb5a6wmp6kf6hidqw9wphidvb8bshym-ghciwatch-clippy-0.3.0.drv
 checking derivation 'checks.aarch64-darwin.ghciwatch-doc'...
 derivation evaluated to /nix/store/8brdd3jbawfszpbs7vdpsrhy80as1il8-ghciwatch-doc-0.3.0.drv
 checking derivation 'checks.aarch64-darwin.ghciwatch-fmt'...
 derivation evaluated to /nix/store/wjhs0l1njl5pyji53xlmfjrlya0wmz8p-ghciwatch-fmt-0.3.0.drv
 checking derivation 'checks.aarch64-darwin.ghciwatch-audit'...
 derivation evaluated to /nix/store/z0mps8dyj2ds7c0fn0819y5h5611033z-ghciwatch-audit-0.3.0.drv
 checking flake output 'packages'...
 checking derivation 'packages.aarch64-darwin.default'...
 derivation evaluated to /nix/store/41abbdyglw5x9vcsvd89xan3ydjf8d7r-ghciwatch-0.3.0.drv
 checking flake output 'apps'...
 checking flake output 'devShells'...
 checking derivation 'devShells.aarch64-darwin.default'...
 derivation evaluated to /nix/store/bc935gz7dylzmcpdb5cczr8gngv8pmdb-nix-shell.drv
 running 5 flake checks...
 warning: The check omitted these incompatible systems: aarch64-linux, x86_64-darwin, x86_64-linux
 Use '--all-systems' to check all.
 ```
--- a/doc/manual/rl-next/nix-flake-update-ux.md
+++ b/doc/manual/rl-next/nix-flake-update-ux.md
@ -1,17 +0,0 @@
 ---
 synopsis: "`Overhaul `nix flake update` and `nix flake lock` UX"
 prs: 8817
 ---
 The interface for creating and updating lock files has been overhauled:
 - [`nix flake lock`](@docroot@/command-ref/new-cli/nix3-flake-lock.md) only creates lock files and adds missing inputs now.
 It will *never* update existing inputs.
 - [`nix flake update`](@docroot@/command-ref/new-cli/nix3-flake-update.md) does the same, but *will* update inputs.
 - Passing no arguments will update all inputs of the current flake, just like it already did.
 - Passing input names as arguments will ensure only those are updated. This replaces the functionality of `nix flake lock --update-input`
 - To operate on a flake outside the current directory, you must now pass `--flake path/to/flake`.
 - The flake-specific flags `--recreate-lock-file` and `--update-input` have been removed from all commands operating on installables.
 They are superceded by `nix flake update`.
--- a/doc/manual/rl-next/nixversion-fake.md
+++ b/doc/manual/rl-next/nixversion-fake.md
@ -1,11 +0,0 @@
 ---
 synopsis: "`builtins.nixVersion` now returns a fixed value \"2.18.3-lix\""
 cls: 558
 ---
 `builtins.nixVersion` now returns a fixed value `"2.18.3-lix"`. This prevents
 feature detection assuming that features that exist in Nix post-Lix-branch-off
 might exist, even though the Lix version is greater than the Nix version.
 In the future, check for builtins for feature detection. If a feature cannot be
 detected by *those* means, please file a Lix bug.
--- a/doc/manual/rl-next/no-cache-eval-errors.md
+++ b/doc/manual/rl-next/no-cache-eval-errors.md
@ -1,8 +0,0 @@
 ---
 synopsis: re-evaluate cached evaluation errors
 cls: 771
 ---
 "cached failure of [expr]" errors have been removed: expressions already in the
 eval cache as a failure will now simply be re-evaluated, removing the need to
 set `--no-eval-cache` or similar to see the error.
--- a/doc/manual/rl-next/print-value-in-coercion-error.md
+++ b/doc/manual/rl-next/print-value-in-coercion-error.md
@ -1,24 +0,0 @@
 ---
 synopsis: Coercion errors include the failing value
 issues: 561
 prs: 9754
 ---
 The `error: cannot coerce a <TYPE> to a string` message now includes the value
 which caused the error.
 Before:
 ```
       error: cannot coerce a set to a string
 ```
 After:
 ```
       error: cannot coerce a set to a string: { aesSupport = «thunk»;
       avx2Support = «thunk»; avx512Support = «thunk»; avxSupport = «thunk»;
       canExecute = «thunk»; config = «thunk»; darwinArch = «thunk»; darwinMinVersion
       = «thunk»; darwinMinVersionVariable = «thunk»; darwinPlatform = «thunk»; «84
       attributes elided»}
 ```
--- a/doc/manual/rl-next/print-value-in-type-error.md
+++ b/doc/manual/rl-next/print-value-in-type-error.md
@ -1,23 +0,0 @@
 ---
 synopsis: Type errors include the failing value
 issues: 561
 prs: 9753
 ---
 In errors like `value is an integer while a list was expected`, the message now
 includes the failing value.
 Before:
 ```
       error: value is a set while a string was expected
 ```
 After:
 ```
       error: expected a string but found a set: { ghc810 = «thunk»;
       ghc8102Binary = «thunk»; ghc8107 = «thunk»; ghc8107Binary = «thunk»;
       ghc865Binary = «thunk»; ghc90 = «thunk»; ghc902 = «thunk»; ghc92 = «thunk»;
       ghc924Binary = «thunk»; ghc925 = «thunk»;  «17 attributes elided»}
 ```
--- a/doc/manual/rl-next/reduce-debugger-clutter.md
+++ b/doc/manual/rl-next/reduce-debugger-clutter.md
@ -1,37 +0,0 @@
 ---
 synopsis: "Visual clutter in `--debugger` is reduced"
 prs: 9919
 ---
 Before:
 ```
 info: breakpoint reached
 Starting REPL to allow you to inspect the current state of the evaluator.
 Welcome to Nix 2.20.0pre20231222_dirty. Type :? for help.
 nix-repl> :continue
 error: uh oh
 Starting REPL to allow you to inspect the current state of the evaluator.
 Welcome to Nix 2.20.0pre20231222_dirty. Type :? for help.
 nix-repl>
 ```
 After:
 ```
 info: breakpoint reached
 Nix 2.20.0pre20231222_dirty debugger
 Type :? for help.
 nix-repl> :continue
 error: uh oh
 nix-repl>
 ```
--- a/doc/manual/rl-next/repl-doc-command.md
+++ b/doc/manual/rl-next/repl-doc-command.md
@ -1,13 +0,0 @@
 ---
 synopsis: Experimental REPL support for documentation comments using `:doc`
 cls: 564
 ---
 Using `:doc` in the REPL now supports showing documentation comments when defined on a function.
 Previously this was only able to document builtins, however it now will show comments defined on a lambda as well.
 This support is experimental and relies on an embedded version of [nix-doc](https://github.com/lf-/nix-doc).
 The logic also supports limited Markdown formatting of doccomments and should easily support any [RFC 145](https://github.com/NixOS/rfcs/blob/master/rfcs/0145-doc-strings.md)
 compatible documentation comments in addition to simple commented documentation.
--- a/doc/manual/rl-next/short-expr-flag.md
+++ b/doc/manual/rl-next/short-expr-flag.md
@ -1,14 +0,0 @@
 ---
 synopsis: reintroduce shortened `-E` form for `--expr` to new CLI
 cls: 605
 ---
 In the past, it was possible to supply a shorter `-E` flag instead of fully
 specifying `--expr` every time you wished to provide an expression that would
 be evaluated to produce the given command's input. This was retained for the
 `--file` flag when the new CLI utilities were written with `-f`, but `-E` was
 dropped.
 We now restore the `-E` short form for better UX. This is most useful for
 `nix eval` but most any command that takes an Installable argument should benefit
 from it as well.
--- a/doc/manual/rl-next/source-location-in-while-evaluating-attribute.md
+++ b/doc/manual/rl-next/source-location-in-while-evaluating-attribute.md
@ -1,23 +0,0 @@
 ---
 synopsis: "In the debugger, `while evaluating the attribute` errors now include position information"
 prs: 9915
 ---
 Before:
 ```
 0: while evaluating the attribute 'python311.pythonForBuild.pkgs'
 0x600001522598
 ```
 After:
 ```
 0: while evaluating the attribute 'python311.pythonForBuild.pkgs'
 /nix/store/hg65h51xnp74ikahns9hyf3py5mlbbqq-source/overrides/default.nix:132:27
   131|
   132|       bootstrappingBase = pkgs.${self.python.pythonAttr}.pythonForBuild.pkgs;
      |                           ^
   133|     in
 ```
--- a/doc/manual/rl-next/source-positions-in-errors.md
+++ b/doc/manual/rl-next/source-positions-in-errors.md
@ -1,42 +0,0 @@
 ---
 synopsis: Source locations are printed more consistently in errors
 issues: 561
 prs: 9555
 ---
 Source location information is now included in error messages more
 consistently. Given this code:
 ```nix
 let
  attr = {foo = "bar";};
  key = {};
 in
  attr.${key}
 ```
 Previously, Nix would show this unhelpful message when attempting to evaluate
 it:
 ```
 error:
       … while evaluating an attribute name
       error: value is a set while a string was expected
 ```
 Now, the error message displays where the problematic value was found:
 ```
 error:
       … while evaluating an attribute name
         at bad.nix:4:11:
            3|   key = {};
            4| in attr.${key}
             |           ^
            5|
       error: expected a string but found a set: { }
 ```
--- a/doc/manual/rl-next/stack-overflow-segfaults.md
+++ b/doc/manual/rl-next/stack-overflow-segfaults.md
@ -1,32 +0,0 @@
 ---
 synopsis: Some stack overflow segfaults are fixed
 issues: 9616
 prs: 9617
 ---
 The number of nested function calls has been restricted, to detect and report
 infinite function call recursions. The default maximum call depth is 10,000 and
 can be set with [the `max-call-depth`
 option](@docroot@/command-ref/conf-file.md#conf-max-call-depth).
 This fixes segfaults or the following unhelpful error message in many cases:
    error: stack overflow (possible infinite recursion)
 Before:
 ```
 $ nix-instantiate --eval --expr '(x: x x) (x: x x)'
 Segmentation fault: 11
 ```
 After:
 ```
 $ nix-instantiate --eval --expr '(x: x x) (x: x x)'
 error: stack overflow
       at «string»:1:14:
            1| (x: x x) (x: x x)
             |              ^
 ```
--- a/doc/manual/rl-next/upstart-removal.md
+++ b/doc/manual/rl-next/upstart-removal.md
@ -1,8 +0,0 @@
 ---
 synopsis: Upstart scripts removed
 cls: 574
 ---
 Upstart scripts have been removed from Lix, since Upstart is obsolete and has
 not been shipped by any major distributions for many years. If these are
 necessary to your use case, please back port them to your packaging.
--- a/doc/manual/rl-next/with-error-reporting.md
+++ b/doc/manual/rl-next/with-error-reporting.md
@ -1,31 +0,0 @@
 ---
 synopsis: Better error reporting for `with` expressions
 prs: 9658
 ---
 `with` expressions using non-attrset values to resolve variables are now reported with proper positions.
 Previously an incorrect `with` expression would report no position at all, making it hard to determine where the error originated:
 ```
 nix-repl> with 1; a
 error:
       … <borked>
         at «none»:0: (source not available)
       error: value is an integer while a set was expected
 ```
 Now position information is preserved and reported as with most other errors:
 ```
 nix-repl> with 1; a
 error:
       … while evaluating the first subexpression of a with expression
         at «string»:1:1:
            1| with 1; a
             | ^
       error: expected a set but found an integer: 1
 ```
--- a/doc/manual/src/SUMMARY.md.in
+++ b/doc/manual/src/SUMMARY.md.in
@ -1,162 +0,0 @@
 # Table of Contents
 - [Introduction](introduction.md)
 - [Quick Start](quick-start.md)
 - [Installation](installation/installation.md)
  - [Supported Platforms](installation/supported-platforms.md)
  - [Installing a Binary Distribution](installation/installing-binary.md)
  - [Installing Nix from Source](installation/installing-source.md)
    - [Prerequisites](installation/prerequisites-source.md)
    - [Obtaining a Source Distribution](installation/obtaining-source.md)
    - [Building Nix from Source](installation/building-source.md)
  - [Using Nix within Docker](installation/installing-docker.md)
  - [Security](installation/nix-security.md)
    - [Single-User Mode](installation/single-user.md)
    - [Multi-User Mode](installation/multi-user.md)
  - [Environment Variables](installation/env-variables.md)
  - [Upgrading Nix](installation/upgrading.md)
  - [Uninstalling Nix](installation/uninstall.md)
 - [Package Management](package-management/package-management.md)
  - [Basic Package Management](package-management/basic-package-mgmt.md)
  - [Profiles](package-management/profiles.md)
  - [Garbage Collection](package-management/garbage-collection.md)
    - [Garbage Collector Roots](package-management/garbage-collector-roots.md)
  - [Sharing Packages Between Machines](package-management/sharing-packages.md)
    - [Serving a Nix store via HTTP](package-management/binary-cache-substituter.md)
    - [Copying Closures via SSH](package-management/copy-closure.md)
    - [Serving a Nix store via SSH](package-management/ssh-substituter.md)
    - [Serving a Nix store via S3](package-management/s3-substituter.md)
 - [Nix Language](language/index.md)
  - [Data Types](language/values.md)
  - [Language Constructs](language/constructs.md)
    - [String interpolation](language/string-interpolation.md)
  - [Operators](language/operators.md)
  - [Derivations](language/derivations.md)
    - [Advanced Attributes](language/advanced-attributes.md)
  - [Built-in Constants](language/builtin-constants.md)
  - [Built-in Functions](language/builtins.md)
 - [Advanced Topics](advanced-topics/advanced-topics.md)
  - [Remote Builds](advanced-topics/distributed-builds.md)
  - [Tuning Cores and Jobs](advanced-topics/cores-vs-jobs.md)
  - [Verifying Build Reproducibility](advanced-topics/diff-hook.md)
  - [Using the `post-build-hook`](advanced-topics/post-build-hook.md)
 - [Command Reference](command-ref/command-ref.md)
  - [Common Options](command-ref/opt-common.md)
  - [Common Environment Variables](command-ref/env-common.md)
  - [Main Commands](command-ref/main-commands.md)
    - [nix-build](command-ref/nix-build.md)
    - [nix-shell](command-ref/nix-shell.md)
    - [nix-store](command-ref/nix-store.md)
      - [nix-store --add-fixed](command-ref/nix-store/add-fixed.md)
      - [nix-store --add](command-ref/nix-store/add.md)
      - [nix-store --delete](command-ref/nix-store/delete.md)
      - [nix-store --dump-db](command-ref/nix-store/dump-db.md)
      - [nix-store --dump](command-ref/nix-store/dump.md)
      - [nix-store --export](command-ref/nix-store/export.md)
      - [nix-store --gc](command-ref/nix-store/gc.md)
      - [nix-store --generate-binary-cache-key](command-ref/nix-store/generate-binary-cache-key.md)
      - [nix-store --import](command-ref/nix-store/import.md)
      - [nix-store --load-db](command-ref/nix-store/load-db.md)
      - [nix-store --optimise](command-ref/nix-store/optimise.md)
      - [nix-store --print-env](command-ref/nix-store/print-env.md)
      - [nix-store --query](command-ref/nix-store/query.md)
      - [nix-store --read-log](command-ref/nix-store/read-log.md)
      - [nix-store --realise](command-ref/nix-store/realise.md)
      - [nix-store --repair-path](command-ref/nix-store/repair-path.md)
      - [nix-store --restore](command-ref/nix-store/restore.md)
      - [nix-store --serve](command-ref/nix-store/serve.md)
      - [nix-store --verify-path](command-ref/nix-store/verify-path.md)
      - [nix-store --verify](command-ref/nix-store/verify.md)
    - [nix-env](command-ref/nix-env.md)
      - [nix-env --delete-generations](command-ref/nix-env/delete-generations.md)
      - [nix-env --install](command-ref/nix-env/install.md)
      - [nix-env --list-generations](command-ref/nix-env/list-generations.md)
      - [nix-env --query](command-ref/nix-env/query.md)
      - [nix-env --rollback](command-ref/nix-env/rollback.md)
      - [nix-env --set-flag](command-ref/nix-env/set-flag.md)
      - [nix-env --set](command-ref/nix-env/set.md)
      - [nix-env --switch-generation](command-ref/nix-env/switch-generation.md)
      - [nix-env --switch-profile](command-ref/nix-env/switch-profile.md)
      - [nix-env --uninstall](command-ref/nix-env/uninstall.md)
      - [nix-env --upgrade](command-ref/nix-env/upgrade.md)
  - [Utilities](command-ref/utilities.md)
    - [nix-channel](command-ref/nix-channel.md)
    - [nix-collect-garbage](command-ref/nix-collect-garbage.md)
    - [nix-copy-closure](command-ref/nix-copy-closure.md)
    - [nix-daemon](command-ref/nix-daemon.md)
    - [nix-hash](command-ref/nix-hash.md)
    - [nix-instantiate](command-ref/nix-instantiate.md)
    - [nix-prefetch-url](command-ref/nix-prefetch-url.md)
  - [Experimental Commands](command-ref/experimental-commands.md)
 {{#include ./command-ref/new-cli/SUMMARY.md}}
  - [Files](command-ref/files.md)
    - [nix.conf](command-ref/conf-file.md)
    - [Profiles](command-ref/files/profiles.md)
      - [manifest.nix](command-ref/files/manifest.nix.md)
      - [manifest.json](command-ref/files/manifest.json.md)
    - [Channels](command-ref/files/channels.md)
    - [Default Nix expression](command-ref/files/default-nix-expression.md)
 - [Architecture and Design](architecture/architecture.md)
  - [File System Object](architecture/file-system-object.md)
 - [Protocols](protocols/protocols.md)
  - [Serving Tarball Flakes](protocols/tarball-fetcher.md)
  - [Derivation "ATerm" file format](protocols/derivation-aterm.md)
 - [Glossary](glossary.md)
 - [Contributing](contributing/contributing.md)
  - [Hacking](contributing/hacking.md)
  - [Testing](contributing/testing.md)
  - [Experimental Features](contributing/experimental-features.md)
  - [CLI guideline](contributing/cli-guideline.md)
  - [C++ style guide](contributing/cxx.md)
 - [Release Notes](release-notes/release-notes.md)
 {{#include ./SUMMARY-rl-next.md}}
  - [Release 2.18 (2023-09-20)](release-notes/rl-2.18.md)
  - [Release 2.17 (2023-07-24)](release-notes/rl-2.17.md)
  - [Release 2.16 (2023-05-31)](release-notes/rl-2.16.md)
  - [Release 2.15 (2023-04-11)](release-notes/rl-2.15.md)
  - [Release 2.14 (2023-02-28)](release-notes/rl-2.14.md)
  - [Release 2.13 (2023-01-17)](release-notes/rl-2.13.md)
  - [Release 2.12 (2022-12-06)](release-notes/rl-2.12.md)
  - [Release 2.11 (2022-08-25)](release-notes/rl-2.11.md)
  - [Release 2.10 (2022-07-11)](release-notes/rl-2.10.md)
  - [Release 2.9 (2022-05-30)](release-notes/rl-2.9.md)
  - [Release 2.8 (2022-04-19)](release-notes/rl-2.8.md)
  - [Release 2.7 (2022-03-07)](release-notes/rl-2.7.md)
  - [Release 2.6 (2022-01-24)](release-notes/rl-2.6.md)
  - [Release 2.5 (2021-12-13)](release-notes/rl-2.5.md)
  - [Release 2.4 (2021-11-01)](release-notes/rl-2.4.md)
  - [Release 2.3 (2019-09-04)](release-notes/rl-2.3.md)
  - [Release 2.2 (2019-01-11)](release-notes/rl-2.2.md)
  - [Release 2.1 (2018-09-02)](release-notes/rl-2.1.md)
  - [Release 2.0 (2018-02-22)](release-notes/rl-2.0.md)
  - [Release 1.11.10 (2017-06-12)](release-notes/rl-1.11.10.md)
  - [Release 1.11 (2016-01-19)](release-notes/rl-1.11.md)
  - [Release 1.10 (2015-09-03)](release-notes/rl-1.10.md)
  - [Release 1.9 (2015-06-12)](release-notes/rl-1.9.md)
  - [Release 1.8 (2014-12-14)](release-notes/rl-1.8.md)
  - [Release 1.7 (2014-04-11)](release-notes/rl-1.7.md)
  - [Release 1.6.1 (2013-10-28)](release-notes/rl-1.6.1.md)
  - [Release 1.6 (2013-09-10)](release-notes/rl-1.6.md)
  - [Release 1.5.2 (2013-05-13)](release-notes/rl-1.5.2.md)
  - [Release 1.5 (2013-02-27)](release-notes/rl-1.5.md)
  - [Release 1.4 (2013-02-26)](release-notes/rl-1.4.md)
  - [Release 1.3 (2013-01-04)](release-notes/rl-1.3.md)
  - [Release 1.2 (2012-12-06)](release-notes/rl-1.2.md)
  - [Release 1.1 (2012-07-18)](release-notes/rl-1.1.md)
  - [Release 1.0 (2012-05-11)](release-notes/rl-1.0.md)
  - [Release 0.16 (2010-08-17)](release-notes/rl-0.16.md)
  - [Release 0.15 (2010-03-17)](release-notes/rl-0.15.md)
  - [Release 0.14 (2010-02-04)](release-notes/rl-0.14.md)
  - [Release 0.13 (2009-11-05)](release-notes/rl-0.13.md)
  - [Release 0.12 (2008-11-20)](release-notes/rl-0.12.md)
  - [Release 0.11 (2007-12-31)](release-notes/rl-0.11.md)
  - [Release 0.10.1 (2006-10-11)](release-notes/rl-0.10.1.md)
  - [Release 0.10 (2006-10-06)](release-notes/rl-0.10.md)
  - [Release 0.9.2 (2005-09-21)](release-notes/rl-0.9.2.md)
  - [Release 0.9.1 (2005-09-20)](release-notes/rl-0.9.1.md)
  - [Release 0.9 (2005-09-16)](release-notes/rl-0.9.md)
  - [Release 0.8.1 (2005-04-13)](release-notes/rl-0.8.1.md)
  - [Release 0.8 (2005-04-11)](release-notes/rl-0.8.md)
  - [Release 0.7 (2005-01-12)](release-notes/rl-0.7.md)
  - [Release 0.6 (2004-11-14)](release-notes/rl-0.6.md)
  - [Release 0.5 and earlier](release-notes/rl-0.5.md)
--- a/doc/manual/src/_redirects
+++ b/doc/manual/src/_redirects
@ -1,29 +0,0 @@
 # redirect rules for paths (server-side) to prevent link rot.
 # see ./redirects.js for redirects based on URL fragments (client-side)
 #
 # concrete user story this supports:
 # - user finds URL to the manual for Nix x.y
 # - Nix x.z (z > y) is the most recent release
 # - updating the version in the URL will show the right thing
 #
 # format documentation:
 # - https://docs.netlify.com/routing/redirects/#syntax-for-the-redirects-file
 # - https://docs.netlify.com/routing/redirects/redirect-options/
 #
 # conventions:
 # - always force (<CODE>!) since this allows re-using file names
 # - group related paths to ease readability
 # - always append new redirects to the end of the file
 # - redirects that should have been there but are missing can be inserted where they belong
 /expressions/expression-language /language/ 301!
 /expressions/language-values /language/values 301!
 /expressions/language-constructs /language/constructs 301!
 /expressions/language-operators /language/operators 301!
 /expressions/* /language/:splat 301!
 /package-management/basic-package-mgmt /command-ref/nix-env 301!
 /package-management/channels* /command-ref/nix-channel 301!
 /package-management/s3-substituter* /command-ref/new-cli/nix3-help-stores#s3-binary-cache-store 301!
--- a/doc/manual/src/advanced-topics/advanced-topics.md
+++ b/doc/manual/src/advanced-topics/advanced-topics.md
@ -1 +0,0 @@
 This section lists advanced topics related to builds and builds performance
--- a/doc/manual/src/advanced-topics/cores-vs-jobs.md
+++ b/doc/manual/src/advanced-topics/cores-vs-jobs.md
@ -1,39 +0,0 @@
 # Tuning Cores and Jobs
 Nix has two relevant settings with regards to how your CPU cores will
 be utilized: `cores` and `max-jobs`. This chapter will talk about what
 they are, how they interact, and their configuration trade-offs.
  - `max-jobs`\
    Dictates how many separate derivations will be built at the same
    time. If you set this to zero, the local machine will do no
    builds.  Nix will still substitute from binary caches, and build
    remotely if remote builders are configured.
  - `cores`\
    Suggests how many cores each derivation should use. Similar to
    `make -j`.
 The `cores` setting determines the value of
 `NIX_BUILD_CORES`. `NIX_BUILD_CORES` is equal to `cores`, unless
 `cores` equals `0`, in which case `NIX_BUILD_CORES` will be the total
 number of cores in the system.
 The maximum number of consumed cores is a simple multiplication,
 `max-jobs` \* `NIX_BUILD_CORES`.
 The balance on how to set these two independent variables depends upon
 each builder's workload and hardware. Here are a few example scenarios
 on a machine with 24 cores:
 | `max-jobs` | `cores` | `NIX_BUILD_CORES` | Maximum Processes | Result                                                                                                                                                                                                                                                                                 |
 | --------------------- | ------------------ | ----------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | 1                     | 24                 | 24                | 24                | One derivation will be built at a time, each one can use 24 cores. Undersold if a job can’t use 24 cores.                                                                                                                                                                              |
 | 4                     | 6                  | 6                 | 24                | Four derivations will be built at once, each given access to six cores.                                                                                                                                                                                                                |
 | 12                    | 6                  | 6                 | 72                | 12 derivations will be built at once, each given access to six cores. This configuration is over-sold. If all 12 derivations being built simultaneously try to use all six cores, the machine's performance will be degraded due to extensive context switching between the 12 builds. |
 | 24                    | 1                  | 1                 | 24                | 24 derivations can build at the same time, each using a single core. Never oversold, but derivations which require many cores will be very slow to compile.                                                                                                                            |
 | 24                    | 0                  | 24                | 576               | 24 derivations can build at the same time, each using all the available cores of the machine. Very likely to be oversold, and very likely to suffer context switches.                                                                                                                  |
 It is up to the derivations' build script to respect host's requested
 cores-per-build by following the value of the `NIX_BUILD_CORES`
 environment variable.
--- a/doc/manual/src/advanced-topics/diff-hook.md
+++ b/doc/manual/src/advanced-topics/diff-hook.md
@ -1,123 +0,0 @@
 # Verifying Build Reproducibility
 You can use Nix's `diff-hook` setting to compare build results. Note
 that this hook is only executed if the results differ; it is not used
 for determining if the results are the same.
 For purposes of demonstration, we'll use the following Nix file,
 `deterministic.nix` for testing:
 ```nix
 let
  inherit (import <nixpkgs> {}) runCommand;
 in {
  stable = runCommand "stable" {} ''
    touch $out
  '';
  unstable = runCommand "unstable" {} ''
    echo $RANDOM > $out
  '';
 }
 ```
 Additionally, `nix.conf` contains:
    diff-hook = /etc/nix/my-diff-hook
    run-diff-hook = true
 where `/etc/nix/my-diff-hook` is an executable file containing:
 ```bash
 #!/bin/sh
 exec >&2
 echo "For derivation $3:"
 /run/current-system/sw/bin/diff -r "$1" "$2"
 ```
 The diff hook is executed by the same user and group who ran the build.
 However, the diff hook does not have write access to the store path just
 built.
 # Spot-Checking Build Determinism
 Verify a path which already exists in the Nix store by passing `--check`
 to the build command.
 If the build passes and is deterministic, Nix will exit with a status
 code of 0:
 ```console
 $ nix-build ./deterministic.nix --attr stable
 this derivation will be built:
  /nix/store/z98fasz2jqy9gs0xbvdj939p27jwda38-stable.drv
 building '/nix/store/z98fasz2jqy9gs0xbvdj939p27jwda38-stable.drv'...
 /nix/store/yyxlzw3vqaas7wfp04g0b1xg51f2czgq-stable
 $ nix-build ./deterministic.nix --attr stable --check
 checking outputs of '/nix/store/z98fasz2jqy9gs0xbvdj939p27jwda38-stable.drv'...
 /nix/store/yyxlzw3vqaas7wfp04g0b1xg51f2czgq-stable
 ```
 If the build is not deterministic, Nix will exit with a status code of
 1:
 ```console
 $ nix-build ./deterministic.nix --attr unstable
 this derivation will be built:
  /nix/store/cgl13lbj1w368r5z8gywipl1ifli7dhk-unstable.drv
 building '/nix/store/cgl13lbj1w368r5z8gywipl1ifli7dhk-unstable.drv'...
 /nix/store/krpqk0l9ib0ibi1d2w52z293zw455cap-unstable
 $ nix-build ./deterministic.nix --attr unstable --check
 checking outputs of '/nix/store/cgl13lbj1w368r5z8gywipl1ifli7dhk-unstable.drv'...
 error: derivation '/nix/store/cgl13lbj1w368r5z8gywipl1ifli7dhk-unstable.drv' may
 not be deterministic: output '/nix/store/krpqk0l9ib0ibi1d2w52z293zw455cap-unstable' differs
 ```
 In the Nix daemon's log, we will now see:
 ```
 For derivation /nix/store/cgl13lbj1w368r5z8gywipl1ifli7dhk-unstable.drv:
 1c1
 < 8108
 ---
 > 30204
 ```
 Using `--check` with `--keep-failed` will cause Nix to keep the second
 build's output in a special, `.check` path:
 ```console
 $ nix-build ./deterministic.nix --attr unstable --check --keep-failed
 checking outputs of '/nix/store/cgl13lbj1w368r5z8gywipl1ifli7dhk-unstable.drv'...
 note: keeping build directory '/tmp/nix-build-unstable.drv-0'
 error: derivation '/nix/store/cgl13lbj1w368r5z8gywipl1ifli7dhk-unstable.drv' may
 not be deterministic: output '/nix/store/krpqk0l9ib0ibi1d2w52z293zw455cap-unstable' differs
 from '/nix/store/krpqk0l9ib0ibi1d2w52z293zw455cap-unstable.check'
 ```
 In particular, notice the
 `/nix/store/krpqk0l9ib0ibi1d2w52z293zw455cap-unstable.check` output. Nix
 has copied the build results to that directory where you can examine it.
 > []{#check-dirs-are-unregistered} **Note**
 >
 > Check paths are not protected against garbage collection, and this
 > path will be deleted on the next garbage collection.
 >
 > The path is guaranteed to be alive for the duration of
 > the `diff-hook`'s execution, but may be deleted any time after.
 >
 > If the comparison is performed as part of automated tooling, please
 > use the diff-hook or author your tooling to handle the case where the
 > build was not deterministic and also a check path does not exist.
 `--check` is only usable if the derivation has been built on the system
 already. If the derivation has not been built Nix will fail with the
 error:
    error: some outputs of '/nix/store/hzi1h60z2qf0nb85iwnpvrai3j2w7rr6-unstable.drv'
    are not valid, so checking is not possible
 Run the build without `--check`, and then try with `--check` again.
--- a/doc/manual/src/advanced-topics/distributed-builds.md
+++ b/doc/manual/src/advanced-topics/distributed-builds.md
@ -1,156 +0,0 @@
 # Remote Builds
 Nix supports remote builds, where a local Nix installation can forward
 Nix builds to other machines. This allows multiple builds to be
 performed in parallel and allows Nix to perform multi-platform builds in
 a semi-transparent way. For instance, if you perform a build for a
 `x86_64-darwin` on an `i686-linux` machine, Nix can automatically
 forward the build to a `x86_64-darwin` machine, if available.
 To forward a build to a remote machine, it’s required that the remote
 machine is accessible via SSH and that it has Nix installed. You can
 test whether connecting to the remote Nix instance works, e.g.
 ```console
 $ nix store ping --store ssh://mac
 ```
 will try to connect to the machine named `mac`. It is possible to
 specify an SSH identity file as part of the remote store URI, e.g.
 ```console
 $ nix store ping --store ssh://mac?ssh-key=/home/alice/my-key
 ```
 Since builds should be non-interactive, the key should not have a
 passphrase. Alternatively, you can load identities ahead of time into
 `ssh-agent` or `gpg-agent`.
 If you get the error
 ```console
 bash: nix-store: command not found
 error: cannot connect to 'mac'
 ```
 then you need to ensure that the `PATH` of non-interactive login shells
 contains Nix.
 > **Warning**
 >
 > If you are building via the Nix daemon, it is the Nix daemon user account (that is, `root`) that should have SSH access to a user (not necessarily `root`) on the remote machine.
 >
 > If you can’t or don’t want to configure `root` to be able to access the remote machine, you can use a private Nix store instead by passing e.g. `--store ~/my-nix` when running a Nix command from the local machine.
 The list of remote machines can be specified on the command line or in
 the Nix configuration file. The former is convenient for testing. For
 example, the following command allows you to build a derivation for
 `x86_64-darwin` on a Linux machine:
 ```console
 $ uname
 Linux
 $ nix build --impure \
  --expr '(with import <nixpkgs> { system = "x86_64-darwin"; }; runCommand "foo" {} "uname > $out")' \
  --builders 'ssh://mac x86_64-darwin'
 [1/0/1 built, 0.0 MiB DL] building foo on ssh://mac
 $ cat ./result
 Darwin
 ```
 It is possible to specify multiple builders separated by a semicolon or
 a newline, e.g.
 ```console
  --builders 'ssh://mac x86_64-darwin ; ssh://beastie x86_64-freebsd'
 ```
 Each machine specification consists of the following elements, separated
 by spaces. Only the first element is required. To leave a field at its
 default, set it to `-`.
 1.  The URI of the remote store in the format
    `ssh://[username@]hostname`, e.g. `ssh://nix@mac` or `ssh://mac`.
    For backward compatibility, `ssh://` may be omitted. The hostname
    may be an alias defined in your `~/.ssh/config`.
 2.  A comma-separated list of Nix platform type identifiers, such as
    `x86_64-darwin`. It is possible for a machine to support multiple
    platform types, e.g., `i686-linux,x86_64-linux`. If omitted, this
    defaults to the local platform type.
 3.  The SSH identity file to be used to log in to the remote machine. If
    omitted, SSH will use its regular identities.
 4.  The maximum number of builds that Nix will execute in parallel on
    the machine. Typically this should be equal to the number of CPU
    cores. For instance, the machine `itchy` in the example will execute
    up to 8 builds in parallel.
 5.  The “speed factor”, indicating the relative speed of the machine. If
    there are multiple machines of the right type, Nix will prefer the
    fastest, taking load into account.
 6.  A comma-separated list of *supported features*. If a derivation has
    the `requiredSystemFeatures` attribute, then Nix will only perform
    the derivation on a machine that has the specified features. For
    instance, the attribute
    ```nix
    requiredSystemFeatures = [ "kvm" ];
    ```
    will cause the build to be performed on a machine that has the `kvm`
    feature.
 7.  A comma-separated list of *mandatory features*. A machine will only
    be used to build a derivation if all of the machine’s mandatory
    features appear in the derivation’s `requiredSystemFeatures`
    attribute.
 8.  The (base64-encoded) public host key of the remote machine. If omitted, SSH
    will use its regular known-hosts file. Specifically, the field is calculated
    via `base64 -w0 /etc/ssh/ssh_host_ed25519_key.pub`.
 For example, the machine specification
    nix@scratchy.labs.cs.uu.nl  i686-linux      /home/nix/.ssh/id_scratchy_auto        8 1 kvm
    nix@itchy.labs.cs.uu.nl     i686-linux      /home/nix/.ssh/id_scratchy_auto        8 2
    nix@poochie.labs.cs.uu.nl   i686-linux      /home/nix/.ssh/id_scratchy_auto        1 2 kvm benchmark
 specifies several machines that can perform `i686-linux` builds.
 However, `poochie` will only do builds that have the attribute
 ```nix
 requiredSystemFeatures = [ "benchmark" ];
 ```
 or
 ```nix
 requiredSystemFeatures = [ "benchmark" "kvm" ];
 ```
 `itchy` cannot do builds that require `kvm`, but `scratchy` does support
 such builds. For regular builds, `itchy` will be preferred over
 `scratchy` because it has a higher speed factor.
 Remote builders can also be configured in `nix.conf`, e.g.
    builders = ssh://mac x86_64-darwin ; ssh://beastie x86_64-freebsd
 Finally, remote builders can be configured in a separate configuration
 file included in `builders` via the syntax `@file`. For example,
    builders = @/etc/nix/machines
 causes the list of machines in `/etc/nix/machines` to be included. (This
 is the default.)
 If you want the builders to use caches, you likely want to set the
 option `builders-use-substitutes` in your local `nix.conf`.
 To build only on remote builders and disable building on the local
 machine, you can use the option `--max-jobs 0`.
--- a/doc/manual/src/advanced-topics/post-build-hook.md
+++ b/doc/manual/src/advanced-topics/post-build-hook.md
@ -1,126 +0,0 @@
 # Using the `post-build-hook`
 # Implementation Caveats
 Here we use the post-build hook to upload to a binary cache. This is a
 simple and working example, but it is not suitable for all use cases.
 The post build hook program runs after each executed build, and blocks
 the build loop. The build loop exits if the hook program fails.
 Concretely, this implementation will make Nix slow or unusable when the
 internet is slow or unreliable.
 A more advanced implementation might pass the store paths to a
 user-supplied daemon or queue for processing the store paths outside of
 the build loop.
 # Prerequisites
 This tutorial assumes you have [configured an S3-compatible binary
 cache](../package-management/s3-substituter.md), and that the `root`
 user's default AWS profile can upload to the bucket.
 # Set up a Signing Key
 Use `nix-store --generate-binary-cache-key` to create our public and
 private signing keys. We will sign paths with the private key, and
 distribute the public key for verifying the authenticity of the paths.
 ```console
 # nix-store --generate-binary-cache-key example-nix-cache-1 /etc/nix/key.private /etc/nix/key.public
 # cat /etc/nix/key.public
 example-nix-cache-1:1/cKDz3QCCOmwcztD2eV6Coggp6rqc9DGjWv7C0G+rM=
 ```
 Then update [`nix.conf`](../command-ref/conf-file.md) on any machine that will access the cache.
 Add the cache URL to [`substituters`](../command-ref/conf-file.md#conf-substituters) and the public key to [`trusted-public-keys`](../command-ref/conf-file.md#conf-trusted-public-keys):
    substituters = https://cache.nixos.org/ s3://example-nix-cache
    trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= example-nix-cache-1:1/cKDz3QCCOmwcztD2eV6Coggp6rqc9DGjWv7C0G+rM=
 Machines that build for the cache must sign derivations using the private key.
 On those machines, add the path to the key file to the [`secret-key-files`](../command-ref/conf-file.md#conf-secret-key-files) field in their [`nix.conf`](../command-ref/conf-file.md):
    secret-key-files = /etc/nix/key.private
 We will restart the Nix daemon in a later step.
 # Implementing the build hook
 Write the following script to `/etc/nix/upload-to-cache.sh`:
 ```bash
 #!/bin/sh
 set -eu
 set -f # disable globbing
 export IFS=' '
 echo "Uploading paths" $OUT_PATHS
 exec nix copy --to "s3://example-nix-cache" $OUT_PATHS
 ```
 > **Note**
 >
 > The `$OUT_PATHS` variable is a space-separated list of Nix store
 > paths. In this case, we expect and want the shell to perform word
 > splitting to make each output path its own argument to `nix
 > store sign`. Nix guarantees the paths will not contain any spaces,
 > however a store path might contain glob characters. The `set -f`
 > disables globbing in the shell.
 Then make sure the hook program is executable by the `root` user:
 ```console
 # chmod +x /etc/nix/upload-to-cache.sh
 ```
 # Updating Nix Configuration
 Edit `/etc/nix/nix.conf` to run our hook, by adding the following
 configuration snippet at the end:
    post-build-hook = /etc/nix/upload-to-cache.sh
 Then, restart the `nix-daemon`.
 # Testing
 Build any derivation, for example:
 ```console
 $ nix-build --expr '(import <nixpkgs> {}).writeText "example" (builtins.toString builtins.currentTime)'
 this derivation will be built:
  /nix/store/s4pnfbkalzy5qz57qs6yybna8wylkig6-example.drv
 building '/nix/store/s4pnfbkalzy5qz57qs6yybna8wylkig6-example.drv'...
 running post-build-hook '/home/grahamc/projects/github.com/NixOS/nix/post-hook.sh'...
 post-build-hook: Signing paths /nix/store/ibcyipq5gf91838ldx40mjsp0b8w9n18-example
 post-build-hook: Uploading paths /nix/store/ibcyipq5gf91838ldx40mjsp0b8w9n18-example
 /nix/store/ibcyipq5gf91838ldx40mjsp0b8w9n18-example
 ```
 Then delete the path from the store, and try substituting it from the
 binary cache:
 ```console
 $ rm ./result
 $ nix-store --delete /nix/store/ibcyipq5gf91838ldx40mjsp0b8w9n18-example
 ```
 Now, copy the path back from the cache:
 ```console
 $ nix-store --realise /nix/store/ibcyipq5gf91838ldx40mjsp0b8w9n18-example
 copying path '/nix/store/m8bmqwrch6l3h8s0k3d673xpmipcdpsa-example from 's3://example-nix-cache'...
 warning: you did not specify '--add-root'; the result might be removed by the garbage collector
 /nix/store/m8bmqwrch6l3h8s0k3d673xpmipcdpsa-example
 ```
 # Conclusion
 We now have a Nix installation configured to automatically sign and
 upload every local build to a remote binary cache.
 Before deploying this to production, be sure to consider the
 [implementation caveats](#implementation-caveats).
--- a/doc/manual/src/architecture/architecture.md
+++ b/doc/manual/src/architecture/architecture.md
@ -1,114 +0,0 @@
 # Architecture
 This chapter describes how Nix works.
 It should help users understand why Nix behaves as it does, and it should help developers understand how to modify Nix and how to write similar tools.
 ## Overview
 Nix consists of [hierarchical layers].
 [hierarchical layers]: https://en.wikipedia.org/wiki/Multitier_architecture#Layers
 The following [concept map] shows its main components (rectangles), the objects they operate on (rounded rectangles), and their interactions (connecting phrases):
 [concept map]: https://en.wikipedia.org/wiki/Concept_map
 ```
   .----------------.
   | Nix expression |----------.
   '----------------'          |
           |              passed to
           |                   |
 +----------|-------------------|--------------------------------+
 | Nix      |                   V                                |
 |          |      +-------------------------+                   |
 |          |      | commmand line interface |------.            |
 |          |      +-------------------------+      |            |
 |          |                   |                   |            |
 |    evaluated by            calls              manages         |
 |          |                   |                   |            |
 |          |                   V                   |            |
 |          |         +--------------------+        |            |
 |          '-------->| language evaluator |        |            |
 |                    +--------------------+        |            |
 |                              |                   |            |
 |                           produces               |            |
 |                              |                   V            |
 | +----------------------------|------------------------------+ |
 | | store                      |                              | |
 | |            referenced by   V       builds                 | |
 | | .-------------.      .------------.      .--------------. | |
 | | | build input |----->| build plan |----->| build result | | |
 | | '-------------'      '------------'      '--------------' | |
 | +-------------------------------------------------|---------+ |
 +---------------------------------------------------|-----------+
                                                    |
                                              represented as
                                                    |
                                                    V
                                            .---------------.
                                            |     file      |
                                            '---------------'
 ```
 At the top is the [command line interface](../command-ref/command-ref.md) that drives the underlying layers.
 The [Nix language](../language/index.md) evaluator transforms Nix expressions into self-contained *build plans*, which are used to derive *build results* from referenced *build inputs*.
 The command line interface and Nix expressions are what users deal with most.
 > **Note**
 > The Nix language itself does not have a notion of *packages* or *configurations*.
 > As far as we are concerned here, the inputs and results of a build plan are just data.
 Underlying the command line interface and the Nix language evaluator is the [Nix store](../glossary.md#gloss-store), a mechanism to keep track of build plans, data, and references between them.
 It can also execute build plans to produce new data, which are made available to the operating system as files.
 A build plan itself is a series of *build tasks*, together with their build inputs.
 > **Important**
 > A build task in Nix is called [derivation](../glossary.md#gloss-derivation).
 Each build task has a special build input executed as *build instructions* in order to perform the build.
 The result of a build task can be input to another build task.
 The following [data flow diagram] shows a build plan for illustration.
 Build inputs used as instructions to a build task are marked accordingly:
 [data flow diagram]: https://en.wikipedia.org/wiki/Data-flow_diagram
 ```
 +--------------------------------------------------------------------+
 | build plan                                                         |
 |                                                                    |
 | .-------------.                                                    |
 | | build input |---------.                                          |
 | '-------------'         |                                          |
 |                    instructions                                    |
 |                         |                                          |
 |                         v                                          |
 | .-------------.    .----------.                                    |
 | | build input |-->( build task )-------.                           |
 | '-------------'    '----------'        |                           |
 |                                  instructions                      |
 |                                        |                           |
 |                                        v                           |
 | .-------------.                  .----------.     .--------------. |
 | | build input |---------.       ( build task )--->| build result | |
 | '-------------'         |        '----------'     '--------------' |
 |                    instructions        ^                           |
 |                         |              |                           |
 |                         v              |                           |
 | .-------------.    .----------.        |                           |
 | | build input |-->( build task )-------'                           |
 | '-------------'    '----------'                                    |
 |                         ^                                          |
 |                         |                                          |
 |                         |                                          |
 | .-------------.         |                                          |
 | | build input |---------'                                          |
 | '-------------'                                                    |
 |                                                                    |
 +--------------------------------------------------------------------+
 ```
--- a/doc/manual/src/architecture/file-system-object.md
+++ b/doc/manual/src/architecture/file-system-object.md
@ -1,64 +0,0 @@
 # File System Object
 Nix uses a simplified model of the file system, which consists of file system objects.
 Every file system object is one of the following:
 - File
   - A possibly empty sequence of bytes for contents
   - A single boolean representing the [executable](https://en.m.wikipedia.org/wiki/File-system_permissions#Permissions) permission
 - Directory
   Mapping of names to child file system objects
 - [Symbolic link](https://en.m.wikipedia.org/wiki/Symbolic_link)
   An arbitrary string.
   Nix does not assign any semantics to symbolic links.
 File system objects and their children form a tree.
 A bare file or symlink can be a root file system object.
 Nix does not encode any other file system notions such as [hard links](https://en.m.wikipedia.org/wiki/Hard_link), [permissions](https://en.m.wikipedia.org/wiki/File-system_permissions), timestamps, or other metadata.
 ## Examples of file system objects
 A plain file:
 ```
 50 B, executable: false
 ```
 An executable file:
 ```
 122 KB, executable: true
 ```
 A symlink:
 ```
 -> /usr/bin/sh
 ```
 A directory with contents:
 ```
 ├── bin
 │   └── hello: 35 KB, executable: true
 └── share
    ├── info
    │   └── hello.info: 36 KB, executable: false
    └── man
        └── man1
            └── hello.1.gz: 790 B, executable: false
 ```
 A directory that contains a symlink and other directories:
 ```
 ├── bin -> share/go/bin
 ├── nix-support/
 └── share/
 ```
--- a/doc/manual/src/command-ref/command-ref.md
+++ b/doc/manual/src/command-ref/command-ref.md
@ -1,2 +0,0 @@
 This section lists commands and options that you can use when you work
 with Nix.
--- a/Show more
+++ b/Show more
Author	SHA1	Message	Date
Qyriad	1ea2486d19	just use fileset from lib	2024-04-07 15:11:03 -06:00
Qyriad	ca770da474	package: just use fileset from lib The following command is now sufficient to build Lix from outside of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: `Ie6b14b446480ac07c7266d4fba20042b04cc35b9`	2024-04-07 15:10:44 -06:00
Qyriad	52d7f56838	fix infinite recursion from prev	2024-04-07 15:10:02 -06:00
Qyriad	cad59ae345	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in in package.nix in some way. These patches aren't just for performance or something -- Lix flat out doesn't build without these patches. (Arguably that makes them a buildsystem responsibility as well, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson.) This is a step towards making `package.nix` more self-sufficient and `callPackage`able without excessive external logic. With this change the following command is enough to build Lix from out of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; inherit (pkgs.lib) fileset; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-07 15:09:39 -06:00
Qyriad	c0d2e2a55b	package: default fileset to lib.fileset The following command is now sufficient to build Lix from outside of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: `Ie6b14b446480ac07c7266d4fba20042b04cc35b9`	2024-04-07 15:09:39 -06:00
Qyriad	e1eb50c8ab	export boehmgc-nix through passthru instead	2024-04-07 14:30:07 -06:00
Qyriad	1227def2b0	package: default fileset to lib.fileset The following command is now sufficient to build Lix from outside of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: `Ie6b14b446480ac07c7266d4fba20042b04cc35b9`	2024-04-07 14:29:38 -06:00
Qyriad	bb3cd88671	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in in package.nix in some way. These patches aren't just for performance or something -- Lix flat out doesn't build without these patches. (Arguably that makes them a buildsystem responsibility as well, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson.) This is a step towards making `package.nix` more self-sufficient and `callPackage`able without excessive external logic. With this change the following command is enough to build Lix from out of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; inherit (pkgs.lib) fileset; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-07 14:29:38 -06:00
Qyriad	9939620ab5	add lib.fileset commit	2024-04-06 18:22:06 -06:00
Qyriad	393b0a240e	package: default fileset to lib.fileset The following command is now sufficient to build Lix from outside of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: `Ie6b14b446480ac07c7266d4fba20042b04cc35b9`	2024-04-06 18:12:35 -06:00
Qyriad	d934c1c3f8	rebase onto main	2024-04-06 18:08:06 -06:00
Qyriad	4968e9364b	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in in package.nix in some way. These patches aren't just for performance or something -- Lix flat out doesn't build without these patches. (Arguably that makes them a buildsystem responsibility as well, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson.) This is a step towards making `package.nix` more self-sufficient and `callPackage`able without excessive external logic. With this change the following command is enough to build Lix from out of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; inherit (pkgs.lib) fileset; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-06 18:07:59 -06:00
Qyriad	fbde57daae	msg: note what the callPackage can now look like	2024-04-06 18:04:47 -06:00
Qyriad	209ac742d1	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in in package.nix in some way. These patches aren't just for performance or something -- Lix flat out doesn't build without these patches. (Arguably that makes them a buildsystem responsibility as well, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson.) This is a step towards making `package.nix` more self-sufficient and `callPackage`able without excessive external logic. With this change the following command is enough to build Lix from out of the flake: nix-build -E 'let pkgs = import <nixpkgs> { }; in pkgs.callPackage ./package.nix { build-release-notes = false; inherit (pkgs.lib) fileset; nix-doc = pkgs.callPackage ./nix-doc/package.nix { }; }' Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-06 18:02:52 -06:00
Qyriad	197ac1b3a6	remove unncessary parens	2024-04-06 18:02:09 -06:00
Qyriad	e1be45ebec	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in in package.nix in some way. These patches aren't just for performance or something -- Lix flat out doesn't build without these patches. (Arguably that makes them a buildsystem responsibility as well, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson.) This is a step towards making `package.nix` more self-sufficient and `callPackage`able without excessive external logic. Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-06 18:02:02 -06:00
Qyriad	099a435cf0	(hopefully) finalize commit message	2024-04-06 17:57:23 -06:00
Qyriad	af8d544527	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in in package.nix in some way. These patches aren't just for performance or something -- Lix flat out doesn't build without these patches. (Arguably that makes them a buildsystem responsibility as well, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson.) This is a step towards making `package.nix` more self-sufficient and `callPackage`able without excessive external logic. Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-06 17:55:47 -06:00
Qyriad	f182aac378	clear up the comment in package.nix on patches a little more	2024-04-06 17:55:22 -06:00
Qyriad	e8dd427fa9	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in some way. These patches aren't just for performance or something -- Lix just doesn't build without these patches. Arguably this should also be optionally implemented in the buildsystem, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson. This is a step towards making `package.nix` more self-sufficient and `callPackage`able without excessive external logic. XXX: commit msg WIP Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-06 17:55:08 -06:00
Qyriad	c28ddfefca	msg: note what effort this is working towards	2024-04-06 15:50:30 -06:00
Qyriad	4dda6ce4f2	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in some way. These patches aren't just for performance or something -- Lix just doesn't build without these patches. Arguably this should also be optionally implemented in the buildsystem, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson. This is a step towards making `package.nix` more self-sufficient and `callPackage`able without excessive external logic. XXX: commit msg WIP Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-06 15:49:43 -06:00
Qyriad	d42e22acd8	init	2024-04-06 15:46:55 -06:00
Qyriad	b5e812a93b	package: put boehmgc patch logic in package.nix In our view it really doesn't make sense to not have this in some way. These patches aren't just for performance or something -- Lix just doesn't build without these patches. Arguably this should also be optionally implemented in the buildsystem, but that can wait for when we're ready to start adding subproject fallback dependency resolution to Meson. XXX: commit msg WIP Change-Id: `Ia37fe8171f87d3293033de8be07d9bab12716f1d`	2024-04-06 15:44:27 -06:00
		`@ -0,0 +1 @@`
							`Subproject commit 08713d5a15799b4bd099e702a407c37c9bf78663`
		`@ -1 +0,0 @@`
			`This section lists advanced topics related to builds and builds performance`
		`@ -1,2 +0,0 @@`
			`This section lists commands and options that you can use when you work`
			`with Nix.`