@xuda.io/drive_module 1.1.1492 → 1.1.1494

package/index.mjs

@@ -2223,33 +2223,39 @@ export const copy_file_to_another_bucket = async (source_region, target_region,
 const get_folder_size = async (dir, drive_type, app_id, uid) => {
   let totalSize = 0;
 
-  const calculateSizeFs = async (dirPath) => {
-    let entries;
-    try {
-      entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
-    } catch (err) {
-      return;
-    }
-    const subdirs = [];
-    const file_stats = [];
-    for (const entry of entries) {
-      const childPath = path.join(dirPath, entry.name);
-      if (entry.isDirectory()) {
-        subdirs.push(childPath);
-      } else if (entry.isFile()) {
-        file_stats.push(
-          fs.promises
-            .stat(childPath)
-            .then((s) => {
-              totalSize += s.size;
-            })
-            .catch(() => {}),
-        );
+  // Iterative walk (explicit stack) instead of deep async recursion. The old
+  // `await calculateSizeFs(d)` self-recursion built an unbounded async call chain
+  // on deeply-nested drives and blew the async stack (async_hooks promiseInit at
+  // the readdir) inside get_folder_size. This keeps async depth O(1) regardless of
+  // tree depth. Dirent.isDirectory() is false for symlinks, so symlinked dirs are
+  // never followed here — no cycle risk.
+  const calculateSizeFs = async (rootPath) => {
+    const stack = [rootPath];
+    while (stack.length) {
+      const dirPath = stack.pop();
+      let entries;
+      try {
+        entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+      } catch (err) {
+        continue;
       }
-    }
-    await Promise.all(file_stats);
-    for (const d of subdirs) {
-      await calculateSizeFs(d);
+      const file_stats = [];
+      for (const entry of entries) {
+        const childPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          stack.push(childPath);
+        } else if (entry.isFile()) {
+          file_stats.push(
+            fs.promises
+              .stat(childPath)
+              .then((s) => {
+                totalSize += s.size;
+              })
+              .catch(() => {}),
+          );
+        }
+      }
+      await Promise.all(file_stats);
     }
   };
 
@@ -2669,6 +2675,9 @@ export default {
 
     doc.vite_build_res = vite_build_res;
     doc.scriptData.dependencies = devDependencies;
+    // build_error parity with the (former) blocking client flow: a clean build
+    // clears any stale error so the editor stops flagging the doc.
+    delete doc.build_error;
 
     db_module.save_app_couch_doc(app_id, doc);
   } catch (err) {
@@ -2680,6 +2689,10 @@ export default {
       src_hash: js_src_hash(doc.scriptData?.value || ''),
       data: err.message,
     };
+    // Stamp build_error on the doc itself (same contract as save_prog): the
+    // studio save flow no longer blocks on the build, so editors learn of
+    // failures from this self-saved rev replicating back.
+    doc.build_error = { message: err?.message || 'Compilation error', ts: Date.now() };
     console.error(doc._id, 'js compile failed:', String(err.message).slice(0, 300));
     if (job_id || req.return_result) {
       return doc.vite_build_res;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/drive_module",
-  "version": "1.1.1492",
+  "version": "1.1.1494",
   "description": "Xuda Drive Server Module",
   "main": "index.mjs",
   "dependencies": {