refine enum code style guidance

Author: audreyality

docs/contributing/code-style/enums.md

@@ -10,7 +10,7 @@ use [constant objects][constant-object-pattern] instead of introducing a new enu
 - Avoid asserting the type of an enum-like. Use explicit types instead.
 - Create utilities to convert and identify enums modelled as primitives.
 
-### Example
+### Numeric enum-likes
 
 Given the following enum:
 
@@ -58,6 +58,29 @@ type CipherContent =
   | { type: typeof CipherType.SecureNote, note: EncString, ... }
 ```
 
+:::warning
+
+Unlike an enum, TypeScript lifts the type of the members of `const CipherType` to `number`. Code
+like the following requires you explicitly type your variables:
+
+```ts
+// ✅ Do: strongly type enum-likes
+let value: CipherType = CipherType.Login;
+const array: CipherType[] = [CipherType.Login];
+const subject = new Subject<CipherType>();
+
+// ❌ Do not: use type inference
+let value = CipherType.Login; // infers `1`
+const array = [CipherType.Login]; // infers `number[]`
+
+// ❌ Do not: use type assertions
+let value = CipherType.Login as CipherType; // this operation is unsafe
+```
+
+:::
+
+### String enum-likes
+
 The above pattern also works with string-typed enum members:
 
 ```ts
@@ -73,31 +96,26 @@ export const CredentialType = Object.freeze({
 export type CredentialType = CredentialType[keyof typeof CredentialType];
 ```
 
-:::warning
+:::note[Enum-likes are structural types!]
 
-Unlike an enum, TypeScript lifts the type of the members of `const CipherType` to `number`. Code
-like the following requires you explicitly type your variables:
+Unlike string-typed enums, enum-likes do not reify a type for each member. This means that you can
+use their string value or their enum member interchangeably.
 
 ```ts
-// ✅ Do: strongly type enum-likes
-let value: CipherType = CipherType.Login;
-const array: CipherType[] = [CipherType.Login];
-const subject = new Subject<CipherType>();
+let value: CredentialType = CredentialType.Username;
 
-// ❌ Do not: use type inference
-let value = CipherType.Login; // infers `1`
-const array = [CipherType.Login]; // infers `number[]`
-
-// ❌ Do not: use type assertions
-let value = CipherType.Login as CipherType; // this operation is unsafe
+// this is typesafe!
+value = "email";
 ```
 
+However, the string-typed values are not always identified as enum members. Thus, when the const
+object is in scope, prefer it to the literal value.
+
 :::
 
 ## Utilities
 
-The following utilities can be used to maintain type safety after compilation. This code assumes
-`const CipherType` is frozen.
+The following utilities can be used to maintain type safety at runtime.
 
 ```ts
 import { CipherType } from "./cipher-type";