We're all unique in our own way This is an answer-chaining challenge where every part of your answer should aim to be unique from every other answer.
This question will work in the following way:

I will post the first answer. The next answer will stem from that, and all other answers will originate from it.
In this answer I will include a program and specify three things:

The language the program is written in
The integer it outputs
The bytes the next program must use


The next user will then write an answer, and specify the same three things - the language they used, the integer they output and the bytes the next program must use
And so on, until the chain ends.

Each answer will do the following:

It will include a program, written in a language that hasn't been used by any previous answer.

The program outputs an integer, through one of our standard I/O formats, that no previous answer in the chain has outputted before. This integer must be deterministic and consistent between executions, and may be positive, negative or \$0\$.

It will take either no input, or an empty input if necessary, and will output nothing more than the integer to a standard output method (STDOUT, function return, Javascript's alert etc.)

It only uses the bytes allowed to it by the previous answer. It may use each byte as many times as it likes, but each byte must be used at least once.

The answer will specify a set of bytes (containing no duplicates) that the next answer must use. This set of bytes may not have been used by any previous answer, and can be any subset of the integers between \$0\$ and \$255\$. There must be a minimum of 1 and a maximum of 256 bytes in this subset, and the number of bytes must be unique of all existing answers (i.e. if one answer allows the next to use 120 bytes, no other answer may allow 120 bytes).


Through this, each new answer will determine how difficult (or easy) the next answer is; only allowing a small subset of bytes will make it substantially more difficult than if allowing a larger set. &quot;Bytes&quot; means that you may use languages with non-UTF-8 encodings, by simply taking the characters those bytes represent in that code page.
For the sake of fairness, the first answer (which I'll post) will have all 256 bytes available to it, so that the answers truly are unique in all the specified ways.
Scoring
Your score is the number of answers you have in the chain, with a higher score being better.
Formatting
Please format your answer in the following way:
# [N]. [Language], [# of bytes available] available bytes

    [program]

This outputs [output]

This uses the characters [characters/bytes], allowed by [previous answer](link)

The next answer may use the following bytes:

    [list of bytes]

Rules

You must wait an hour between posting two answers
You may not post two answers in a row
So long as they're unique, the language, integer and bytes are up to your choice
You are under no obligation to golf your code
You may submit either a full program or function
Different versions of languages (e.g Python 2 and Python 3) are not considered separate languages. As a general rule, if the only way the language names differ is by a version number, or if the languages are usually thought of as versions of each other, they are considered the same language.
You may use any language that wasn't specifically invented to answer this challenge
The chain ends when 14 days pass with no new answers being posted or after 256 answers have been posted (as no new byte sets will be available).

Good luck!
5. Retina 0.8.2 -m, 8 available bytes
The code is given as three separate files. Here are their hexdumps:
00000000: 002a 0f2a 062a 092a 042a 142a            .*.*.*.*.*.*
00000000: 4545 4545 4545                           EEEEEE
00000000: 45                                       E

This outputs 6. Try it online!
The first file uses bytes 0, 15, 6, 9, 4, 20, and 42, and the other two files consist entirely of E (byte 69), covering the list specified by the previous answer.

Normally, Retina takes patterns and replacements in a single file separated by newlines, but we don't have newlines available. Fortunately, Retina 0.8.2 still makes available the language's original multi-file code format.* This program has two stages, a replacement stage and a count stage:

Find all regex matches of _*_*_*_*_*_* in the input, where _ represents the various unprintable characters. Since the input is empty, this matches once. Replace that match with EEEEEE.
In the resulting string, count the number of matches of E (six).

* IIRC, Retina was originally designed this way to take advantage of a PPCG scoring loophole. Now I'm using it to take advantage of a different kind of loophole. Seems appropriate.

The next answer may use the 54 bytes whose codepoints are prime numbers:
2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251