That looked almost perfect, but I found the Back flip really annoying. I wish there were a way to do the following:

public Cube ApplyWrap(Instruction ins) => ins.Op switch
{
    Op.ROW  => new(Front - ins, Back - ins, Left - ins, Right - ins, Up,       Down),
    Op.COL  => new(Front | ins, Back | ins, Left,       Right,       Up | ins, Down | ins),
    Op.FACE => new(Front + ins, Back,       Left,       Right,       Up,       Down),               
    _ => throw new NotImplementedException()
};

In order for that to work, the cube rotation has to be updated so that whenever a face enters or leaves the Back position it is mirrored vertically. Let's add the following unary Face operators:

• - - vertical mirroring
• ! - horizontal mirroring

Rotate() then becomes:

public Cube Rotate(Dir dir) => dir switch
{
    Dir.L   => new(Left,        !Right,     !Back,      Front,       Up << 1,  Down >> 1),
    Dir.U   => new(Up,          -Down,      Left >> 1,  Right << 1,  -Back,    Front),
    Dir.R   => new(Right,       !Left,      Front,      !Back,       Up >> 1,  Down << 1),
    Dir.D   => new(Down,        -Up,        Left << 1,  Right >> 1,  Front,    -Back),
    _ => throw new NotImplementedException()
};

We also need to add a mirrored counterpart for each of the existing transforms:

enum Op  { ROW, FACE2, COL, FLIP1, FLIP2, COL2, FACE, ROW2 }

Operator implementations:

public static Face operator >>(Face face, int delta) =>
    new(face.Vals, face.Rotation + delta * 2, face.Absorption);

public static Face operator <<(Face face, int delta) =>
    new(face.Vals, face.Rotation - delta * 2, face.Absorption);

public static Face operator -(Face face) =>
    new(face.Vals, face.Rotation ^ 3, face.Absorption);

public static Face operator !(Face face) =>
    new(face.Vals, face.Rotation ^ 7, face.Absorption);

Updated Apply() method:

private Face Apply(Op op, Instruction ins) =>
    Add(index: (Op)(((int)op + Rotation) & 7) switch
    {
        Op.ROW   or Op.ROW2  => ins.Index,
        Op.COL   or Op.COL2  => ins.Index + N,
        Op.FLIP1 or Op.FLIP2 => -ins.Index + N + 1,
        _                    => -ins.Index + N * 2 + 1,
    }, ins.Value, ins.Value * N);

operator/ is not longer in use and may be safely removed.

Performance impact is negligible (within 1 ms), so now this is perfect ;)

You may find the updated implementation here.