{
  description = "Glint — a Gleam-inspired typed configuration language (POC)";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    systems.url = "github:nix-systems/default";

    # Wasm-capable Gleam (Zed extension export). Override locally with:
    #   nix build --override-input gleam path:../gleam
    gleam = {
      url = "git+https://tangled.org/nandi.uk/gleam?ref=wasm";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs =
    {
      self,
      nixpkgs,
      systems,
      gleam,
      ...
    }:
    let
      forEachSystem = nixpkgs.lib.genAttrs (import systems);
    in
    {
      packages = forEachSystem (
        system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
          inherit (pkgs) lib;

          gleamToml = lib.importTOML ./gleam.toml;
          manifestToml = lib.importTOML ./manifest.toml;

          hexPackages = builtins.filter (p: p.source == "hex") manifestToml.packages;

          packagesTOML = lib.concatStringsSep "\n" (
            [ "[packages]" ] ++ map (p: "${p.name} = \"${p.version}\"") hexPackages
          );

          # Wasm-capable gleam from the flake input.
          gleamBin = gleam.packages.${system}.gleam;

          # Self-contained store package: Erlang shipment + fixed-path wrapper.
          glint = pkgs.stdenv.mkDerivation {
            pname = "glint";
            version = gleamToml.version;

            src = lib.cleanSourceWith {
              src = ./.;
              filter =
                path: type:
                let
                  base = baseNameOf path;
                in
                lib.cleanSourceFilter path type
                && base != "build"
                && base != "result"
                && base != "result-zed"
                && base != "erl_crash.dump"
                && base != "editors"
                && !(lib.hasSuffix ".escript" base);
            };

            nativeBuildInputs = [
              pkgs.gleam
              pkgs.beamPackages.erlang
              pkgs.rebar3
              pkgs.beamPackages.hex
              pkgs.rsync
            ];

            configurePhase = ''
              runHook preConfigure

              mkdir -p build/packages
              cat <<EOF > build/packages/packages.toml
              ${packagesTOML}
              EOF

              # Vendor Hex deps so the pure Nix build never hits the network.
              ${lib.concatMapStringsSep "\n" (p: ''
                rsync --chmod=Du=rwx,Dg=rx,Do=rx,Fu=rw,Fg=r,Fo=r -r ${
                  pkgs.fetchHex {
                    pkg = p.name;
                    version = p.version;
                    sha256 = p.outer_checksum;
                  }
                }/* build/packages/${p.name}/
              '') hexPackages}

              runHook postConfigure
            '';

            buildPhase = ''
              runHook preBuild
              export REBAR_CACHE_DIR="$TMP/.rebar-cache"
              gleam export erlang-shipment
              runHook postBuild
            '';

            installPhase = ''
              runHook preInstall

              mkdir -p $out/{bin,lib/glint}
              rsync --exclude=entrypoint.sh --exclude=entrypoint.ps1 \
                -r build/erlang-shipment/* $out/lib/glint/

              # Bake -pa paths at install time (each ebin needs its own -pa).
              ebin_args=()
              for d in $out/lib/glint/*/ebin; do
                ebin_args+=(-pa "$d")
              done

              {
                echo "#!${pkgs.runtimeShell}"
                echo "set -eu"
                echo "exec ${pkgs.beamPackages.erlang}/bin/erl ''${ebin_args[*]} -eval \"glint@@main:run(glint)\" -noshell -extra \"\$@\""
              } > $out/bin/glint
              chmod +x $out/bin/glint

              runHook postInstall
            '';

            meta = {
              description = gleamToml.description;
              mainProgram = "glint";
              license = lib.licenses.asl20;
            };
          };

          # Prebuilt Glint Zed extension (Gleam guest). Point Install Dev
          # Extension at a *writable copy* of this dir, or use `nix run .#install-zed-extension`.
          zed-extension = pkgs.stdenv.mkDerivation {
            pname = "glint-zed-extension";
            version = gleamToml.version;

            src = lib.cleanSourceWith {
              src = ./editors/zed;
              filter =
                path: type:
                let
                  base = baseNameOf path;
                in
                lib.cleanSourceFilter path type
                && base != "target"
                && base != "build"
                && base != "grammars"
                && !(lib.hasSuffix ".wasm" base)
                && base != "Cargo.lock";
            };

            nativeBuildInputs = [
              gleamBin
            ];

            buildPhase = ''
              runHook preBuild
              export HOME=$TMPDIR
              # `gleam export zed-extension` writes extension.wasm in the package root.
              gleam export zed-extension
              runHook postBuild
            '';

            installPhase = ''
              runHook preInstall
              mkdir -p $out
              cp extension.wasm $out/
              cp -r languages $out/

              # No [lib] section: Install Dev Extension must not run cargo.
              # Prebuilt extension.wasm is the Gleam guest.
              cat > $out/extension.toml <<'EOF'
              id = "glint"
              name = "Glint"
              version = "0.1.0"
              schema_version = 1
              authors = ["nandi"]
              description = "Glint language support — highlighting and glint LSP (Gleam Wasm guest)"
              repository = "https://tangled.org/nandi.uk/glint"

              [language_servers.glint]
              name = "Glint LSP"
              languages = ["Glint"]

              [language_servers.glint.language_ids]
              Glint = "glint"

              [grammars.gleam]
              repository = "https://github.com/gleam-lang/tree-sitter-gleam"
              rev = "6ea757f7eb8d391dbf24dbb9461990757946dd5e"
              EOF

              cat > $out/README.txt <<EOF
              Glint Zed extension (Gleam Wasm guest)
              Built with: ${gleamBin}

              Install:
                nix run .#install-zed-extension -- ~/glint-zed-dev
                # then Zed → Extensions → Install Dev Extension → ~/glint-zed-dev
              EOF
              runHook postInstall
            '';

            meta = {
              description = "Prebuilt Glint Zed extension (extension.wasm from Gleam)";
              license = lib.licenses.asl20;
            };
          };
        in
        {
          default = glint;
          inherit glint;
          inherit gleamBin;
          gleam = gleamBin;
          inherit zed-extension;
        }
      );

      apps = forEachSystem (
        system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
          zed = self.packages.${system}.zed-extension;
          installScript = pkgs.writeShellApplication {
            name = "install-zed-extension";
            text = ''
              set -euo pipefail
              dest="''${1:-$HOME/glint-zed-dev}"
              echo "Installing Glint Zed extension → $dest"
              mkdir -p "$dest"
              # Store path is immutable; copy so Zed can re-scan / write if needed.
              cp -a ${zed}/. "$dest/"
              chmod -R u+w "$dest"
              echo "Done. In Zed: Extensions → Install Dev Extension → $dest"
              echo "  (prebuilt extension.wasm; no cargo rebuild required if Zed accepts the tree)"
            '';
          };
        in
        {
          default = {
            type = "app";
            program = "${self.packages.${system}.glint}/bin/glint";
          };
          install-zed-extension = {
            type = "app";
            program = "${installScript}/bin/install-zed-extension";
          };
        }
      );

      devShells = forEachSystem (
        system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
          gleamBin = self.packages.${system}.gleam;
        in
        {
          default = pkgs.mkShell {
            packages = with pkgs; [
              # Stock gleam for normal package work, plus wasm-capable gleam as GLEAM.
              gleam
              gleamBin
              beamPackages.erlang
              rebar3
              nodejs
              rustc
              cargo
            ];
            GLEAM = "${gleamBin}/bin/gleam";
            shellHook = ''
              echo "glint dev shell"
              echo "  GLEAM=$GLEAM  (wasm-capable, for editors/zed cargo driver)"
              echo "  gleam run -- check examples/hello.glint"
              echo "  nix build .#zed-extension"
              echo "  nix run .#install-zed-extension"
            '';
          };
        }
      );

      checks = forEachSystem (system: {
        package = self.packages.${system}.glint;
        # zed-extension is heavier (builds gleam); enable when CI can afford it.
      });

      formatter = forEachSystem (system: nixpkgs.legacyPackages.${system}.nixfmt-rfc-style);
    };
}