feat: zero-knowledge encryption Phase 1 — backend opaque + crypto module (WIP)

Backend: server can no longer read user data. All data blobs (medication,
appointment, profile name) are now opaque client-encrypted ciphertext — the
server stores and returns them verbatim, never deserializing the contents.

- Medication: removed MedicationData + flat MedicationResponse; new
  MedicationResponse echoes metadata + encrypted_data blob. Create/update
  accept opaque blobs (whole-blob replace). Update is no longer load-mutate-
  reserialize (server can't read the data).
- Appointment: same opaque treatment; status moved to a top-level document
  field so it remains filterable without decryption.
- Profile: name is now an opaque encrypted blob (name_data/name_iv). Auto-
  created profile on register starts with an empty name; client sets it.
- EncryptedFieldWire type shared across medication/appointment.

Frontend (partial): crypto module using Web Crypto API —
- crypto/keys.ts: double-PBKDF2 derivation (auth secret sent to server +
  encryption key kept in memory); in-memory key store (set/get/clear).
- crypto/cipher.ts: AES-GCM encrypt/decrypt + JSON convenience wrappers.
- crypto/index.ts: re-exports.

NOT YET DONE (frontend integration): auth store key derivation on login/register,
stores decrypt-on-load/encrypt-on-write, types update, UI components wired,
crypto round-trip tests, ADR. This commit is a verified checkpoint — backend
builds clean (21 tests, 0 warnings); frontend crypto module exists but is not
yet wired into the data flow.

web/normogen-web/src/crypto/cipher.ts

@@ -0,0 +1,81 @@
+/**
+ * AES-GCM encrypt/decrypt over the Web Crypto API (no dependencies).
+ *
+ * Ciphertext and IV are returned as base64 strings so they map directly onto
+ * the backend's `EncryptedField { data, iv, auth_tag }` wire shape.
+ */
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const b64 = {
+  encode(bytes: Uint8Array): string {
+    let bin = '';
+    for (const b of bytes) bin += String.fromCharCode(b);
+    return btoa(bin);
+  },
+  decode(str: string): Uint8Array {
+    const bin = atob(str);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+    return bytes;
+  },
+};
+
+/** Random 12-byte IV for AES-GCM. */
+function randomIv(): Uint8Array {
+  return crypto.getRandomValues(new Uint8Array(12));
+}
+
+export interface CipherPayload {
+  /** base64 ciphertext */
+  data: string;
+  /** base64 12-byte IV */
+  iv: string;
+}
+
+/** Encrypt a UTF-8 string under the given AES-GCM key. */
+export async function encrypt(
+  plaintext: string,
+  key: CryptoKey,
+): Promise<CipherPayload> {
+  const iv = randomIv();
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: 'AES-GCM', iv },
+    key,
+    encoder.encode(plaintext),
+  );
+  return {
+    data: b64.encode(new Uint8Array(ciphertext)),
+    iv: b64.encode(iv),
+  };
+}
+
+/** Decrypt a base64 payload. Throws on tamper / wrong key. */
+export async function decrypt(
+  payload: CipherPayload,
+  key: CryptoKey,
+): Promise<string> {
+  const iv = b64.decode(payload.iv);
+  const plaintext = await crypto.subtle.decrypt(
+    { name: 'AES-GCM', iv },
+    key,
+    b64.decode(payload.data),
+  );
+  return decoder.decode(plaintext);
+}
+
+/** Encrypt a JSON-serializable object. */
+export async function encryptJson<T>(
+  obj: T,
+  key: CryptoKey,
+): Promise<CipherPayload> {
+  return encrypt(JSON.stringify(obj), key);
+}
+
+/** Decrypt a payload and JSON.parse into T. Throws on tamper / wrong key / bad JSON. */
+export async function decryptJson<T>(
+  payload: CipherPayload,
+  key: CryptoKey,
+): Promise<T> {
+  return JSON.parse(await decrypt(payload, key)) as T;
+}