update frontend-v2 graphql schema

frontend-v2/schema.graphql

···
 }
 
 type BlobUploadResponse {
-  blob: JSON!
+  blob: Blob!
 }
 
 type CollectionStats {

frontend-v2/server/profile-init.ts

···
 export async function initializeUserProfile(
   userDid: string,
   userHandle: string,
-  tokens: TokenInfo
+  tokens: TokenInfo,
 ): Promise<void> {
   if (!API_URL || !SLICE_URI) {
     console.error("Missing API_URL or VITE_SLICE_URI environment variables");
···
   }
 
   try {
-    const graphqlUrl = `${API_URL}/graphql?slice=${encodeURIComponent(SLICE_URI)}`;
+    const graphqlUrl = `${API_URL}/graphql?slice=${
+      encodeURIComponent(SLICE_URI)
+    }`;
     const authHeader = `${tokens.tokenType} ${tokens.accessToken}`;
 
     // 1. Check if profile already exists
···
     });
 
     if (!bskyResponse.ok) {
-      throw new Error(`Fetch Bluesky profile failed: ${bskyResponse.statusText}`);
+      throw new Error(
+        `Fetch Bluesky profile failed: ${bskyResponse.statusText}`,
+      );
     }
 
     const bskyData = await bskyResponse.json();
···
     ) {
       // Reconstruct blob format for AT Protocol
       profileInput.avatar = {
-        $type: "blob",
-        ref: {
-          $link: bskyProfile.avatar.ref,
-        },
+        ref: bskyProfile.avatar.ref,
         mimeType: bskyProfile.avatar.mimeType,
         size: bskyProfile.avatar.size,
       };

frontend-v2/src/__generated__/ProfileSettingsUploadBlobMutation.graphql.ts

···
 /**
- * @generated SignedSource<<a2334c7e93bb6d5b4748df1211a418ae>>
+ * @generated SignedSource<<728b9a3525f975b6c58a5cdcd323f89e>>
  * @lightSyntaxTransform
  * @nogrep
  */
···
 };
 export type ProfileSettingsUploadBlobMutation$data = {
   readonly uploadBlob: {
-    readonly blob: any;
+    readonly blob: {
+      readonly mimeType: string;
+      readonly ref: string;
+      readonly size: number;
+    };
   };
 };
 export type ProfileSettingsUploadBlobMutation = {
···
       {
         "alias": null,
         "args": null,
-        "kind": "ScalarField",
+        "concreteType": "Blob",
+        "kind": "LinkedField",
         "name": "blob",
+        "plural": false,
+        "selections": [
+          {
+            "alias": null,
+            "args": null,
+            "kind": "ScalarField",
+            "name": "ref",
+            "storageKey": null
+          },
+          {
+            "alias": null,
+            "args": null,
+            "kind": "ScalarField",
+            "name": "mimeType",
+            "storageKey": null
+          },
+          {
+            "alias": null,
+            "args": null,
+            "kind": "ScalarField",
+            "name": "size",
+            "storageKey": null
+          }
+        ],
         "storageKey": null
       }
     ],
···
     "selections": (v1/*: any*/)
   },
   "params": {
-    "cacheID": "3a4a6b19d2898f14635b098941614cab",
+    "cacheID": "afd8db2ee7590308e81afc0b0e5c86dd",
     "id": null,
     "metadata": {},
     "name": "ProfileSettingsUploadBlobMutation",
     "operationKind": "mutation",
-    "text": "mutation ProfileSettingsUploadBlobMutation(\n  $data: String!\n  $mimeType: String!\n) {\n  uploadBlob(data: $data, mimeType: $mimeType) {\n    blob\n  }\n}\n"
+    "text": "mutation ProfileSettingsUploadBlobMutation(\n  $data: String!\n  $mimeType: String!\n) {\n  uploadBlob(data: $data, mimeType: $mimeType) {\n    blob {\n      ref\n      mimeType\n      size\n    }\n  }\n}\n"
   }
 };
 })();
 
-(node as any).hash = "76da65b07a282ed7f2dee12b4cac82d6";
+(node as any).hash = "74a3a8bf43181cd62d2e81c45be384e5";
 
 export default node;

frontend-v2/src/pages/ProfileSettings.tsx

···
-import { useParams, Link } from "react-router-dom";
+import { Link, useParams } from "react-router-dom";
 import { useState } from "react";
 import { graphql, useLazyLoadQuery, useMutation } from "react-relay";
 import type { ProfileSettingsQuery } from "../__generated__/ProfileSettingsQuery.graphql.ts";
···
       where: {
         actorHandle: { eq: handle },
       },
-    }
+    },
   );
 
   const profile = data.networkSlicesActorProfiles.edges[0]?.node;
···
     graphql`
       mutation ProfileSettingsUploadBlobMutation($data: String!, $mimeType: String!) {
         uploadBlob(data: $data, mimeType: $mimeType) {
-          blob
+          blob {
+            ref
+            mimeType
+            size
+          }
         }
       }
-    `
+    `,
   );
 
   const [commitUpdateProfile, isUpdatingProfile] = useMutation(
···
           }
         }
       }
-    `
+    `,
   );
 
   const [commitCreateProfile, isCreatingProfile] = useMutation(
···
           }
         }
       }
-    `
+    `,
   );
 
   // Helper to convert File to base64
···
       reader.onload = () => {
         const arrayBuffer = reader.result as ArrayBuffer;
         const bytes = new Uint8Array(arrayBuffer);
-        const binary = Array.from(bytes).map(b => String.fromCharCode(b)).join('');
+        const binary = Array.from(bytes).map((b) => String.fromCharCode(b))
+          .join("");
         resolve(btoa(binary));
       };
       reader.onerror = reject;
···
         // Upload new avatar
         const base64Data = await fileToBase64(avatarFile);
 
-        const uploadResult = await new Promise<{ uploadBlob: { blob: unknown } }>((resolve, reject) => {
+        const uploadResult = await new Promise<
+          { uploadBlob: { blob: unknown } }
+        >((resolve, reject) => {
           commitUploadBlob({
             variables: {
               data: base64Data,
               mimeType: avatarFile.type,
             },
-            onCompleted: (data) => resolve(data as { uploadBlob: { blob: unknown } }),
+            onCompleted: (data) =>
+              resolve(data as { uploadBlob: { blob: unknown } }),
             onError: (error) => reject(error),
           });
         });
···
       } else if (profile?.avatar) {
         // Keep existing avatar - reconstruct blob with $type field for AT Protocol
         avatarBlob = {
-          $type: "blob",
-          ref: {
-            $link: profile.avatar.ref,
-          },
+          ref: profile.avatar.ref,
           mimeType: profile.avatar.mimeType,
           size: profile.avatar.size,
         };