Write a radiation-hardened irradiator The task is to write a radiation-hardened irradiator. What do I mean by that, exactly?

An irradiator is a program that, when given a string as input, will output all possible versions of the string with one character removed. For example, given the input Hello, world!, the program should output:

ello, world!
Hllo, world!
Helo, world!
Helo, world!
Hell, world!
Hello world!
Hello,world!
Hello, orld!
Hello, wrld!
Hello, wold!
Hello, word!
Hello, worl!
Hello, world


An irradiator, however, must be protected from its radiation, so the irradiator you write must also survive when put through itself. That is, when any single byte of your program is removed, the program must still function properly.

Test cases

abc -&gt; bc; ac; ab
foo bar -&gt; oo bar:fo bar:fo bar:foobar:foo ar:foo br:foo ba
source -&gt; ource;surce;sorce;souce;soure;sourc;


Specifications


You may take input by any acceptable method by our Standard I/O rules
The output may be either a list of strings or a printed list delimited by a character or group of characters. A trailing delimiter is acceptable
The output may be in any order as long as it contains all of the possible versions
Duplicate entries (such as the two Helo, world!s in the first example) may be filtered out, but this is not necessary
As this is code-golf, the smallest program, in bytes, wins
05AB1E, 29 26 bytes

æIg&lt;ùˆ\æIg&lt;ùˆ\æIg&lt;ùˆ¯¯{Å`s


Try it online!, or try all irradiated versions.

The shortest irradiator I could find is 5 bytes:

æ        # powerset of the input
 Ig      # length of the input
   &lt;     # - 1
    ù    # elements of a with length b


The idea is to repeat that 3 times, then do majority voting:

æIg&lt;ù         # irradiate
     ˆ        # add the result to the global array
      \       # pop (in case the above instruction gets irradiated)
æIg&lt;ùˆ\       # idem
æIg&lt;ùˆ        # no pop, it's okay to dirty the stack at this point
¯             # push global array
 ¯            # and again, so at least one goes through
  {           # sort
   Å          # conveniently ignored by the parser
    `         # dump
     s        # swap
              # and implicitly output


Å is a prefix for 2-byte commands, but there's no Å` command, which is why the Å gets ignored. We'll need it later, though.

Sorting makes sure the majority vote is in the middle of the array. Dumping then swapping gets that value to the top of the stack.

Any irradiation in the initial part only results in an error in the global array, which gets solved by the majority vote. Irradiations in the final {Å`s bit are much trickier to reason about:


Å is ignored anyway, so it's okay to irradiate it
If the backtick is irradiated, Å`s becomes Ås, which is the "get middle of the array" extended command.
If { or s are irradiated, that means nothing else is, so the global array is the same value three times. In that case we don't need sorting/swapping, any value will work.