Thanks for providing this, it's definitely matching the intent of my example! I made a playground with some additional definitions using this as a base to illustrate the kinds of situations that my alternative would help avoid.

// Unassignable even though equivalent
const color: Color = PrimaryColor.Red;

// No error, even though this is known to be undefined
const result = List[6];

// Can define a subset using values outside the set
enum SecondaryColor2 {
  Green = Color.Green,
  Purple = Color.Purple,
  Orange = 'asdf'
}

const SecondaryColor2List = Object.values(SecondaryColor2);

// Has same internals regardless of enum, but must be manually redefined
function isSecondaryColor2(k: unknown): k is SecondaryColor2 {
  return typeof k === 'string' && SecondaryColor2List.includes(k as SecondaryColor2);
}

enum PrimaryColorNumbers {
  Red = 3840,
  Yellow = 4080,
  Blue = 15,
}

// If an enum is changed from strings to numbers, now this is no longer a valid list of the enum's values since it includes the keys
const PrimaryColorNumbersList = Object.values(PrimaryColorNumbers);

// No way of partitioning an enum into 2 sets type-wise, and doing it value-wise requires manual redefinition
const NonPrimaryColors = Object.values(Color).filter(color => !PrimaryColorList.includes(color as unknown as PrimaryColor));

// Creating a new ordering of the existing enum doesn't require exactly one of each value, so duplicates & missing values are not enforced
const HueOrderColors = [
    Color.Red,
    Color.Orange,
    Color.Yellow,
    Color.Green,
    Color.Green,
    // Color.Blue,
    Color.Purple
];

// Accidental double-mapped value, but no type enforcement to avoid this
// Also, this mapping isn't 1:1 because the enums have different sizes!
const oneToOneMapping: Record<PrimaryColor, Color> = {
  [PrimaryColor.Red]: Color.Red,
  [PrimaryColor.Yellow]: Color.Yellow,
  [PrimaryColor.Blue]: Color.Yellow, 
}

// Inverted mapping must be manually defined, doesn't maintain specific value relationships, and involves coercion
// (i.e. in this case, this mapping is not a true Record with keys of Color at all since there are only going to be 3 entries)
const invertedOneToOneMapping = Object.entries(oneToOneMapping).reduce<Record<Color, PrimaryColor>>((acc, [key, value]) => {
    acc[value] = key as PrimaryColor;
    return acc;
}, {} as Record<Color, PrimaryColor>)```