feat: profile sharing via X25519 envelope (Phase B, #3)

An owner can now share a profile with another account; the recipient
reads the profile's metadata AND its data (medications, appointments,
health stats) under their own login. The server stays a blind store:
sharing uses an X25519 envelope — the owner wraps the profile DEK to
the recipient's identity public key via ECDH (fresh ephemeral key per
share), the recipient unwraps it with their identity private key.

Backend:
- models/profile_share.rs: ProfileShare + ProfileShareRepository
  (find_for_recipient, find_for_profile, find_active [checks active +
  expiry], delete, upsert). Indexed on (profileId, recipientUserId) and
  recipientUserId.
- handlers/profile_share.rs: POST/GET /profiles/:id/shares,
  DELETE /profiles/:id/shares/:recipient, GET /profiles/shared-with-me,
  GET /users/public-key (public), and authorize_profile_read — the
  share-gate that admits owner OR active-share recipient.
- The share-gate is wired into list/get for medications, appointments,
  and health stats: when profile_id is specified, resolve the owner via
  the gate and query as them. Data repos stay ownership-scoped.
- Removed the legacy Share system (ADR Open Q5): models/{share,
  permission}.rs, handlers/{shares,permissions}.rs, middleware/
  permission.rs (dead), the shares collection field + methods in
  mongodb_impl.rs, the shares index, and the 5 /api/shares +
  /api/permissions routes.
- share_tests.rs: full owner→recipient→revoke flow, ownership
  isolation, share-to-self/nonexistent/keyless rejections, expired
  share treated as absent.

Frontend:
- crypto/keys.ts: wrapProfileDekToRecipient /
  unwrapProfileDekFromShare (ECDH envelope, ephemeral key per share).
- useProfileStore: loadSharedWithMe (unwrap each share's DEK with the
  identity private key), shareProfile, revokeShare, loadProfileShares.
  Shared profiles merge into the list with is_shared=true.
- ProfileSwitcher: shows shared profiles with a 'shared' chip.
- ProfileSharing (new) + ProfileEditor: owner UI to add a recipient by
  email and revoke; shared profiles render read-only with owner info.
- ECDH round-trip test (owner wraps, recipient unwraps, stranger can't).

Verification: backend cargo build/clippy (-D warnings)/fmt clean, tests
compile (integration tests run in CI — Mongo is fixed there). Frontend
tsc clean, 31/31 tests pass.

⚠️ Backend integration tests not run locally (no Mongo/Docker in this
sandbox); CI will run them — I'll fix any failures immediately.

Phases C (hard revoke / re-key) and D (graduation) remain. Refs #3.

web/normogen-web/src/services/api.ts

@@ -20,6 +20,10 @@ import {
   ProfileWireResponse,
   CreateProfileRequest,
   UpdateProfileRequest,
+  SharedProfileWireResponse,
+  CreateProfileShareRequest,
+  ProfileShareListing,
+  PublicKeyResponse,
   HealthStatWireResponse,
   UpdateHealthStatRequest,
   EncryptedFieldWire,
@@ -260,6 +264,50 @@ class ApiService {
     await this.client.delete(`/profiles/${profileId}`);
   }
 
+  // ---- Profile sharing (Phase B: X25519 envelope) ----
+
+  /** Public endpoint — recipient identity public key lookup by email. */
+  async getUserPublicKey(email: string): Promise<PublicKeyResponse> {
+    const response = await this.client.get<PublicKeyResponse>('/users/public-key', {
+      params: { email },
+    });
+    return response.data;
+  }
+
+  /** Profiles shared TO the current user. Carries ECDH-wrapped profile DEKs. */
+  async listSharedWithMe(): Promise<SharedProfileWireResponse[]> {
+    const response = await this.client.get<SharedProfileWireResponse[]>(
+      '/profiles/shared-with-me',
+    );
+    return response.data;
+  }
+
+  /** Owner: list who a profile has been shared with. */
+  async listProfileShares(profileId: string): Promise<ProfileShareListing[]> {
+    const response = await this.client.get<ProfileShareListing[]>(
+      `/profiles/${profileId}/shares`,
+    );
+    return response.data;
+  }
+
+  /** Owner: share a profile. The wrapped DEK + ephemeral pubkey are produced
+   *  client-side via wrapProfileDekToRecipient. */
+  async createProfileShare(
+    profileId: string,
+    req: CreateProfileShareRequest,
+  ): Promise<ProfileShareListing> {
+    const response = await this.client.post<ProfileShareListing>(
+      `/profiles/${profileId}/shares`,
+      req,
+    );
+    return response.data;
+  }
+
+  /** Owner: revoke a share (soft revoke — server deletes the share record). */
+  async deleteProfileShare(profileId: string, recipientUserId: string): Promise<void> {
+    await this.client.delete(`/profiles/${profileId}/shares/${recipientUserId}`);
+  }
+
   // ---- Medications (zero-knowledge: opaque encrypted blobs) ----
 
   async getMedications(profileId?: string): Promise<MedicationWireResponse[]> {