refactor: trim comments to only add context not evident from code

Remove inline comments and JSDoc prose that restate the code or can be
inferred from implementation. Keep minimal @param/@return type blocks.

Author: Nixxx19

server/controllers/project.controller.js

@@ -167,7 +167,7 @@ export async function projectExists(projectId) {
 
 /**
  * @param {string} username
- * @param {string} projectId - the database id or the slug or the project
+ * @param {string} projectId
  * @return {Promise<boolean>}
  */
 export async function projectForUserExists(username, projectId) {
@@ -198,15 +198,12 @@ export async function getProjectForUser(username, projectId) {
 }
 
 /**
- * Adds URLs referenced in <script> tags to the `files` array of the project
- * so that they can be downloaded along with other remote files from S3.
  * @param {object} project
- * @void - modifies the `project` parameter
  */
 function bundleExternalLibs(project) {
   const indexHtml = project.files.find((file) => file.name === 'index.html');
   if (!indexHtml || !indexHtml.content) {
-    return; // Gracefully handle missing index.html
+    return;
   }
 
   const { window } = new JSDOM(indexHtml.content);
@@ -218,7 +215,6 @@ function bundleExternalLibs(project) {
     const path = src.split('/');
     const filename = path[path.length - 1];
 
-    // Prevent duplicate external libs if downloaded multiple times
     if (project.files.some((f) => f.name === filename && f.url === src)) {
       return;
     }
@@ -234,42 +230,29 @@ function bundleExternalLibs(project) {
 }
 
 /**
- * Helper function to get a readable stream from an S3 URL
- * Optimized to return stream handle quickly without waiting for data
  * @param {string} url - S3 URL
  * @return {Promise<Readable>}
  */
 async function getStreamFromS3Url(url) {
-  // Parse the S3 URL to get bucket and key
   const urlObj = new URL(url);
   let bucket;
   let key;
 
-  // Support different S3 URL formats
   if (urlObj.hostname.includes('s3')) {
-    // Format: https://bucket-name.s3.region.amazonaws.com/key
-    // or https://s3.region.amazonaws.com/bucket-name/key
     if (urlObj.hostname.startsWith('s3')) {
-      // https://s3.region.amazonaws.com/bucket-name/key
       const pathParts = urlObj.pathname.split('/').filter(Boolean);
       [bucket] = pathParts;
       key = pathParts.slice(1).join('/');
     } else {
-      // https://bucket-name.s3.region.amazonaws.com/key
       [bucket] = urlObj.hostname.split('.');
       key = urlObj.pathname.substring(1);
     }
 
-    // by nityam, Get S3 object stream - returns immediately with stream handle
-    // Data is only fetched when the stream is consumed (by JSZip)
     const command = new GetObjectCommand({ Bucket: bucket, Key: key });
     const response = await s3Client.send(command);
-
-    // Ensure we return the stream, not buffer the response
     return response.Body;
   }
 
-  // Not an S3 URL, fall back to axios with streaming
   const response = await axios.get(url, {
     responseType: 'stream',
     timeout: 30000
@@ -278,32 +261,25 @@ async function getStreamFromS3Url(url) {
 }
 
 /**
- * Recursively adds a file and all of its children to the JSZip instance using streaming.
- * Files are fetched sequentially to avoid memory overload.
  * @param {object} file
  * @param {Array<object>} files
  * @param {JSZip} zip
- * @return {Promise<void>} - modifies the `zip` parameter
+ * @return {Promise<void>}
  */
 async function addFileToZip(file, files, zip) {
   if (file.fileType === 'folder') {
     const folderZip = file.name === 'root' ? zip : zip.folder(file.name);
-    // Process children sequentially to avoid fetching all files upfront
     await file.children.reduce(async (previousPromise, fileId) => {
       await previousPromise;
       const childFile = files.find((f) => f.id === fileId);
       return addFileToZip(childFile, files, folderZip);
     }, Promise.resolve());
   } else if (file.url) {
     try {
-      // Check if this is an S3 URL
       if (file.url.includes('s3') && file.url.includes('amazonaws.com')) {
-        // Use S3 streaming for S3 URLs
-        // This gets the stream handle quickly - actual data is fetched by JSZip during generation
         const stream = await getStreamFromS3Url(file.url);
         zip.file(file.name, stream, { binary: true });
       } else {
-        // For external URLs, use axios with streaming
         const response = await axios.get(file.url, {
           responseType: 'stream',
           timeout: 30000
@@ -312,11 +288,9 @@ async function addFileToZip(file, files, zip) {
       }
     } catch (e) {
       console.warn(`Failed to fetch file from ${file.url}:`, e.message);
-      // Add empty file on error to prevent ZIP corruption
       zip.file(file.name, Buffer.alloc(0));
     }
   } else {
-    // Regular file with inline content
     zip.file(file.name, file.content);
   }
 }
@@ -340,51 +314,39 @@ async function buildZip(project, req, res) {
 
     bundleExternalLibs(project);
 
-    // Send headers immediately to prevent gateway timeout
     res.writeHead(200, {
       'Content-Type': 'application/zip',
       'Content-disposition': `attachment; filename=${zipFileName}`,
       'Transfer-Encoding': 'chunked'
     });
 
-    // Send periodic keepalive comments to prevent gateway timeout
-    // while we're building the file list. ZIP format allows for this.
     let keepaliveCounter = 0;
     keepaliveInterval = setInterval(() => {
-      // Write a comment to keep connection alive without corrupting ZIP
-      // This prevents 60s gateway timeouts during file list building
       if (!res.writableEnded) {
-        res.write(Buffer.alloc(0)); // Empty write to keep connection alive
+        res.write(Buffer.alloc(0));
         keepaliveCounter++;
         if (keepaliveCounter % 10 === 0) {
           console.log(
             `Keepalive: Building ZIP file list (${keepaliveCounter}s elapsed)...`
           );
         }
       }
-    }, 1000); // Every second
+    }, 1000);
 
-    // Sequentially add files - this avoids parallel S3 connection storms
-    // but still requires getting all file references before streaming begins
     await addFileToZip(root, files, zip);
 
-    // Clear keepalive now that we're about to start streaming real data
     clearInterval(keepaliveInterval);
     keepaliveInterval = null;
 
-    // Generate ZIP stream with true end-to-end streaming
-    // streamFiles: true means JSZip reads from our S3 streams on-demand
     const zipStream = zip.generateNodeStream({
       type: 'nodebuffer',
       streamFiles: true,
       compression: 'DEFLATE',
       compressionOptions: { level: 6 }
     });
 
-    // Pipe the ZIP stream to response - handles backpressure automatically
     zipStream.pipe(res);
 
-    // Handle stream errors
     zipStream.on('error', (err) => {
       console.error('Error streaming zip file:', err);
       if (!res.headersSent) {
@@ -397,25 +359,19 @@ async function buildZip(project, req, res) {
       }
     });
 
-    // Wait for the stream to finish
     await new Promise((resolve, reject) => {
       zipStream.on('end', resolve);
       zipStream.on('error', reject);
       res.on('error', reject);
-      res.on('close', () => {
-        // Client disconnected
-        reject(new Error('Client disconnected'));
-      });
+      res.on('close', () => reject(new Error('Client disconnected')));
     });
   } catch (err) {
     console.error('Error building zip file:', err);
 
-    // Clean up keepalive if still running
     if (keepaliveInterval) {
       clearInterval(keepaliveInterval);
     }
 
-    // Only send error if response hasn't been sent yet
     if (!res.headersSent) {
       res.status(500).json({
         success: false,
@@ -434,11 +390,9 @@ export async function downloadProjectAsZip(req, res) {
       res.status(404).send({ message: 'Project with that id does not exist' });
       return;
     }
-    // Await buildZip to ensure it completes before the function returns
     await buildZip(project, req, res);
   } catch (err) {
     console.error('Error in downloadProjectAsZip:', err);
-    // Only send error if response hasn't been sent yet
     if (!res.headersSent) {
       res.status(500).json({
         success: false,