@gallop.software/studio 2.1.5 → 2.1.6

package/dist/server/index.js

@@ -891,9 +891,35 @@ async function handleFolderImages(request) {
 }
 
 // src/handlers/files.ts
+import { promises as fs6 } from "fs";
+import path6 from "path";
+import sharp2 from "sharp";
+
+// src/handlers/utils/folders.ts
 import { promises as fs5 } from "fs";
 import path5 from "path";
-import sharp2 from "sharp";
+async function deleteEmptyFolders(folderPath) {
+  const publicPath = getPublicPath();
+  const normalizedFolder = path5.resolve(folderPath);
+  const normalizedPublic = path5.resolve(publicPath);
+  if (normalizedFolder === normalizedPublic) {
+    return;
+  }
+  if (!normalizedFolder.startsWith(normalizedPublic)) {
+    return;
+  }
+  try {
+    const entries = await fs5.readdir(folderPath);
+    if (entries.length === 0) {
+      await fs5.rmdir(folderPath);
+      const parentFolder = path5.dirname(folderPath);
+      await deleteEmptyFolders(parentFolder);
+    }
+  } catch {
+  }
+}
+
+// src/handlers/files.ts
 async function handleUpload(request) {
   try {
     const formData = await request.formData();
@@ -905,7 +931,7 @@ async function handleUpload(request) {
     const bytes = await file.arrayBuffer();
     const buffer = Buffer.from(bytes);
     const fileName = file.name;
-    const ext = path5.extname(fileName).toLowerCase();
+    const ext = path6.extname(fileName).toLowerCase();
     const isImage = isImageFile(fileName);
     const isMedia = isMediaFile(fileName);
     const meta = await loadMeta();
@@ -923,7 +949,7 @@ async function handleUpload(request) {
     }
     let imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
     if (meta[imageKey]) {
-      const baseName = path5.basename(fileName, ext);
+      const baseName = path6.basename(fileName, ext);
       let counter = 1;
       let newFileName = `${baseName}-${counter}${ext}`;
       let newKey = "/" + (relativeDir ? `${relativeDir}/${newFileName}` : newFileName);
@@ -934,10 +960,10 @@ async function handleUpload(request) {
       }
       imageKey = newKey;
     }
-    const actualFileName = path5.basename(imageKey);
+    const actualFileName = path6.basename(imageKey);
     const uploadDir = getPublicPath(relativeDir);
-    await fs5.mkdir(uploadDir, { recursive: true });
-    await fs5.writeFile(path5.join(uploadDir, actualFileName), buffer);
+    await fs6.mkdir(uploadDir, { recursive: true });
+    await fs6.writeFile(path6.join(uploadDir, actualFileName), buffer);
     if (!isMedia) {
       return jsonResponse({
         success: true,
@@ -978,6 +1004,7 @@ async function handleDelete(request) {
     const meta = await loadMeta();
     const deleted = [];
     const errors = [];
+    const sourceFolders = /* @__PURE__ */ new Set();
     for (const itemPath of paths) {
       try {
         if (!itemPath.startsWith("public/")) {
@@ -986,12 +1013,13 @@ async function handleDelete(request) {
         }
         const absolutePath = getWorkspacePath(itemPath);
         const imageKey = "/" + itemPath.replace(/^public\//, "");
+        sourceFolders.add(path6.dirname(absolutePath));
         const entry = meta[imageKey];
         const isPushedToCloud = entry?.c !== void 0;
         try {
-          const stats = await fs5.stat(absolutePath);
+          const stats = await fs6.stat(absolutePath);
           if (stats.isDirectory()) {
-            await fs5.rm(absolutePath, { recursive: true });
+            await fs6.rm(absolutePath, { recursive: true });
             const prefix = imageKey + "/";
             for (const key of Object.keys(meta)) {
               if (key.startsWith(prefix) || key === imageKey) {
@@ -1000,7 +1028,7 @@ async function handleDelete(request) {
                   for (const thumbPath of getAllThumbnailPaths(key)) {
                     const absoluteThumbPath = getPublicPath(thumbPath);
                     try {
-                      await fs5.unlink(absoluteThumbPath);
+                      await fs6.unlink(absoluteThumbPath);
                     } catch {
                     }
                   }
@@ -1009,14 +1037,14 @@ async function handleDelete(request) {
               }
             }
           } else {
-            await fs5.unlink(absolutePath);
+            await fs6.unlink(absolutePath);
             const isInImagesFolder = itemPath.startsWith("public/images/");
             if (!isInImagesFolder && entry) {
               if (!isPushedToCloud) {
                 for (const thumbPath of getAllThumbnailPaths(imageKey)) {
                   const absoluteThumbPath = getPublicPath(thumbPath);
                   try {
-                    await fs5.unlink(absoluteThumbPath);
+                    await fs6.unlink(absoluteThumbPath);
                   } catch {
                   }
                 }
@@ -1049,6 +1077,9 @@ async function handleDelete(request) {
       }
     }
     await saveMeta(meta);
+    for (const folder of sourceFolders) {
+      await deleteEmptyFolders(folder);
+    }
     return jsonResponse({
       success: true,
       deleted,
@@ -1075,12 +1106,12 @@ async function handleCreateFolder(request) {
       return jsonResponse({ error: "Invalid path" }, { status: 400 });
     }
     try {
-      await fs5.access(folderPath);
+      await fs6.access(folderPath);
       return jsonResponse({ error: "A folder with this name already exists" }, { status: 400 });
     } catch {
     }
-    await fs5.mkdir(folderPath, { recursive: true });
-    return jsonResponse({ success: true, path: path5.join(safePath, sanitizedName) });
+    await fs6.mkdir(folderPath, { recursive: true });
+    return jsonResponse({ success: true, path: path6.join(safePath, sanitizedName) });
   } catch (error) {
     console.error("Failed to create folder:", error);
     return jsonResponse({ error: "Failed to create folder" }, { status: 500 });
@@ -1098,29 +1129,29 @@ async function handleRename(request) {
     }
     const safePath = oldPath.replace(/\.\./g, "");
     const absoluteOldPath = getWorkspacePath(safePath);
-    const parentDir = path5.dirname(absoluteOldPath);
-    const absoluteNewPath = path5.join(parentDir, sanitizedName);
+    const parentDir = path6.dirname(absoluteOldPath);
+    const absoluteNewPath = path6.join(parentDir, sanitizedName);
     if (!absoluteOldPath.startsWith(getPublicPath())) {
       return jsonResponse({ error: "Invalid path" }, { status: 400 });
     }
     try {
-      await fs5.access(absoluteOldPath);
+      await fs6.access(absoluteOldPath);
     } catch {
       return jsonResponse({ error: "File or folder not found" }, { status: 404 });
     }
     try {
-      await fs5.access(absoluteNewPath);
+      await fs6.access(absoluteNewPath);
       return jsonResponse({ error: "An item with this name already exists" }, { status: 400 });
     } catch {
     }
-    const stats = await fs5.stat(absoluteOldPath);
+    const stats = await fs6.stat(absoluteOldPath);
     const isFile = stats.isFile();
-    const isImage = isFile && isImageFile(path5.basename(oldPath));
-    await fs5.rename(absoluteOldPath, absoluteNewPath);
+    const isImage = isFile && isImageFile(path6.basename(oldPath));
+    await fs6.rename(absoluteOldPath, absoluteNewPath);
     if (isImage) {
       const meta = await loadMeta();
       const oldRelativePath = safePath.replace(/^public\//, "");
-      const newRelativePath = path5.join(path5.dirname(oldRelativePath), sanitizedName);
+      const newRelativePath = path6.join(path6.dirname(oldRelativePath), sanitizedName);
       const oldKey = "/" + oldRelativePath;
       const newKey = "/" + newRelativePath;
       if (meta[oldKey]) {
@@ -1130,9 +1161,9 @@ async function handleRename(request) {
         for (let i = 0; i < oldThumbPaths.length; i++) {
           const oldThumbPath = getPublicPath(oldThumbPaths[i]);
           const newThumbPath = getPublicPath(newThumbPaths[i]);
-          await fs5.mkdir(path5.dirname(newThumbPath), { recursive: true });
+          await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
           try {
-            await fs5.rename(oldThumbPath, newThumbPath);
+            await fs6.rename(oldThumbPath, newThumbPath);
           } catch {
           }
         }
@@ -1141,7 +1172,7 @@ async function handleRename(request) {
       }
       await saveMeta(meta);
     }
-    const newPath = path5.join(path5.dirname(safePath), sanitizedName);
+    const newPath = path6.join(path6.dirname(safePath), sanitizedName);
     return jsonResponse({ success: true, newPath });
   } catch (error) {
     console.error("Failed to rename:", error);
@@ -1176,21 +1207,22 @@ async function handleMoveStream(request) {
           controller.close();
           return;
         }
-        await fs5.mkdir(absoluteDestination, { recursive: true });
+        await fs6.mkdir(absoluteDestination, { recursive: true });
         const meta = await loadMeta();
         const cdnUrls = getCdnUrls(meta);
         const r2PublicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "") || "";
         const moved = [];
         const errors = [];
+        const sourceFolders = /* @__PURE__ */ new Set();
         const total = paths.length;
         sendEvent({ type: "start", total });
         for (let i = 0; i < paths.length; i++) {
           const itemPath = paths[i];
           const safePath = itemPath.replace(/\.\./g, "");
-          const itemName = path5.basename(safePath);
-          const newAbsolutePath = path5.join(absoluteDestination, itemName);
+          const itemName = path6.basename(safePath);
+          const newAbsolutePath = path6.join(absoluteDestination, itemName);
           const oldRelativePath = safePath.replace(/^public\//, "");
-          const newRelativePath = path5.join(safeDestination.replace(/^public\//, ""), itemName);
+          const newRelativePath = path6.join(safeDestination.replace(/^public\//, ""), itemName);
           const oldKey = "/" + oldRelativePath;
           const newKey = "/" + newRelativePath;
           sendEvent({
@@ -1212,11 +1244,13 @@ async function handleMoveStream(request) {
           const isPushedToR2 = isInCloud && r2PublicUrl && fileCdnUrl === r2PublicUrl;
           const hasProcessedThumbnails = isProcessed(entry);
           try {
+            const sourceFolder = path6.dirname(getWorkspacePath(safePath));
+            sourceFolders.add(sourceFolder);
             if (isRemote && isImage) {
               const remoteUrl = `${fileCdnUrl}${oldKey}`;
               const buffer = await downloadFromRemoteUrl(remoteUrl);
-              await fs5.mkdir(path5.dirname(newAbsolutePath), { recursive: true });
-              await fs5.writeFile(newAbsolutePath, buffer);
+              await fs6.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+              await fs6.writeFile(newAbsolutePath, buffer);
               const newEntry = {
                 o: entry?.o,
                 b: entry?.b
@@ -1226,8 +1260,8 @@ async function handleMoveStream(request) {
               moved.push(itemPath);
             } else if (isPushedToR2 && isImage) {
               const buffer = await downloadFromCdn(oldKey);
-              await fs5.mkdir(path5.dirname(newAbsolutePath), { recursive: true });
-              await fs5.writeFile(newAbsolutePath, buffer);
+              await fs6.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+              await fs6.writeFile(newAbsolutePath, buffer);
               let newEntry = {
                 o: entry?.o,
                 b: entry?.b
@@ -1242,7 +1276,7 @@ async function handleMoveStream(request) {
               }
               await deleteFromCdn(oldKey, hasProcessedThumbnails);
               try {
-                await fs5.unlink(newAbsolutePath);
+                await fs6.unlink(newAbsolutePath);
               } catch {
               }
               if (hasProcessedThumbnails) {
@@ -1254,33 +1288,34 @@ async function handleMoveStream(request) {
               moved.push(itemPath);
             } else {
               const absolutePath = getWorkspacePath(safePath);
-              if (absoluteDestination.startsWith(absolutePath + path5.sep)) {
+              if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
                 errors.push(`Cannot move ${itemName} into itself`);
                 continue;
               }
               try {
-                await fs5.access(absolutePath);
+                await fs6.access(absolutePath);
               } catch {
                 errors.push(`${itemName} not found`);
                 continue;
               }
               try {
-                await fs5.access(newAbsolutePath);
+                await fs6.access(newAbsolutePath);
                 errors.push(`${itemName} already exists in destination`);
                 continue;
               } catch {
               }
-              await fs5.rename(absolutePath, newAbsolutePath);
-              const stats = await fs5.stat(newAbsolutePath);
+              await fs6.rename(absolutePath, newAbsolutePath);
+              const stats = await fs6.stat(newAbsolutePath);
               if (stats.isFile() && isImage && entry) {
                 const oldThumbPaths = getAllThumbnailPaths(oldKey);
                 const newThumbPaths = getAllThumbnailPaths(newKey);
                 for (let j = 0; j < oldThumbPaths.length; j++) {
                   const oldThumbPath = getPublicPath(oldThumbPaths[j]);
                   const newThumbPath = getPublicPath(newThumbPaths[j]);
-                  await fs5.mkdir(path5.dirname(newThumbPath), { recursive: true });
+                  sourceFolders.add(path6.dirname(oldThumbPath));
+                  await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
                   try {
-                    await fs5.rename(oldThumbPath, newThumbPath);
+                    await fs6.rename(oldThumbPath, newThumbPath);
                   } catch {
                   }
                 }
@@ -1305,6 +1340,9 @@ async function handleMoveStream(request) {
           }
         }
         await saveMeta(meta);
+        for (const folder of sourceFolders) {
+          await deleteEmptyFolders(folder);
+        }
         sendEvent({
           type: "complete",
           moved: moved.length,
@@ -1329,8 +1367,8 @@ async function handleMoveStream(request) {
 }
 
 // src/handlers/images.ts
-import { promises as fs6 } from "fs";
-import path6 from "path";
+import { promises as fs7 } from "fs";
+import path7 from "path";
 import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2 } from "@aws-sdk/client-s3";
 async function handleSync(request) {
   const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
@@ -1360,6 +1398,7 @@ async function handleSync(request) {
     const pushed = [];
     const errors = [];
     const urlsToPurge = [];
+    const sourceFolders = /* @__PURE__ */ new Set();
     for (let imageKey of imageKeys) {
       if (!imageKey.startsWith("/")) {
         imageKey = `/${imageKey}`;
@@ -1384,7 +1423,7 @@ async function handleSync(request) {
         } else {
           const originalLocalPath = getPublicPath(imageKey);
           try {
-            originalBuffer = await fs6.readFile(originalLocalPath);
+            originalBuffer = await fs7.readFile(originalLocalPath);
           } catch {
             errors.push(`Original file not found: ${imageKey}`);
             continue;
@@ -1403,7 +1442,7 @@ async function handleSync(request) {
           for (const thumbPath of getAllThumbnailPaths(imageKey)) {
             const localPath = getPublicPath(thumbPath);
             try {
-              const fileBuffer = await fs6.readFile(localPath);
+              const fileBuffer = await fs7.readFile(localPath);
               await r2.send(
                 new PutObjectCommand2({
                   Bucket: bucketName,
@@ -1420,15 +1459,17 @@ async function handleSync(request) {
         entry.c = cdnIndex;
         if (!isRemote) {
           const originalLocalPath = getPublicPath(imageKey);
+          sourceFolders.add(path7.dirname(originalLocalPath));
           for (const thumbPath of getAllThumbnailPaths(imageKey)) {
             const localPath = getPublicPath(thumbPath);
+            sourceFolders.add(path7.dirname(localPath));
             try {
-              await fs6.unlink(localPath);
+              await fs7.unlink(localPath);
             } catch {
             }
           }
           try {
-            await fs6.unlink(originalLocalPath);
+            await fs7.unlink(originalLocalPath);
           } catch {
           }
         }
@@ -1439,6 +1480,9 @@ async function handleSync(request) {
       }
     }
     await saveMeta(meta);
+    for (const folder of sourceFolders) {
+      await deleteEmptyFolders(folder);
+    }
     if (urlsToPurge.length > 0) {
       await purgeCloudflareCache(urlsToPurge);
     }
@@ -1610,32 +1654,32 @@ async function handleReprocessStream(request) {
             const isRemote = existingCdnIndex !== void 0 && !isInOurR2;
             const originalPath = getPublicPath(imageKey);
             try {
-              buffer = await fs6.readFile(originalPath);
+              buffer = await fs7.readFile(originalPath);
             } catch {
               if (isInOurR2) {
                 buffer = await downloadFromCdn(imageKey);
-                const dir = path6.dirname(originalPath);
-                await fs6.mkdir(dir, { recursive: true });
-                await fs6.writeFile(originalPath, buffer);
+                const dir = path7.dirname(originalPath);
+                await fs7.mkdir(dir, { recursive: true });
+                await fs7.writeFile(originalPath, buffer);
               } else if (isRemote && existingCdnUrl) {
                 const remoteUrl = `${existingCdnUrl}${imageKey}`;
                 buffer = await downloadFromRemoteUrl(remoteUrl);
-                const dir = path6.dirname(originalPath);
-                await fs6.mkdir(dir, { recursive: true });
-                await fs6.writeFile(originalPath, buffer);
+                const dir = path7.dirname(originalPath);
+                await fs7.mkdir(dir, { recursive: true });
+                await fs7.writeFile(originalPath, buffer);
               } else {
                 throw new Error(`File not found: ${imageKey}`);
               }
             }
-            const ext = path6.extname(imageKey).toLowerCase();
+            const ext = path7.extname(imageKey).toLowerCase();
             const isSvg = ext === ".svg";
             if (isSvg) {
-              const imageDir = path6.dirname(imageKey.slice(1));
+              const imageDir = path7.dirname(imageKey.slice(1));
               const imagesPath = getPublicPath("images", imageDir === "." ? "" : imageDir);
-              await fs6.mkdir(imagesPath, { recursive: true });
-              const fileName = path6.basename(imageKey);
-              const destPath = path6.join(imagesPath, fileName);
-              await fs6.writeFile(destPath, buffer);
+              await fs7.mkdir(imagesPath, { recursive: true });
+              const fileName = path7.basename(imageKey);
+              const destPath = path7.join(imagesPath, fileName);
+              await fs7.writeFile(destPath, buffer);
               meta[imageKey] = {
                 ...entry,
                 o: { w: 0, h: 0 },
@@ -1655,7 +1699,7 @@ async function handleReprocessStream(request) {
                 }
                 await deleteLocalThumbnails(imageKey);
                 try {
-                  await fs6.unlink(originalPath);
+                  await fs7.unlink(originalPath);
                 } catch {
                 }
               }
@@ -1734,8 +1778,8 @@ async function handleDownloadStream(request) {
           try {
             const imageBuffer = await downloadFromCdn(imageKey);
             const localPath = getPublicPath(imageKey.replace(/^\//, ""));
-            await fs6.mkdir(path6.dirname(localPath), { recursive: true });
-            await fs6.writeFile(localPath, imageBuffer);
+            await fs7.mkdir(path7.dirname(localPath), { recursive: true });
+            await fs7.writeFile(localPath, imageBuffer);
             await deleteThumbnailsFromCdn(imageKey);
             const wasProcessed = isProcessed(entry);
             delete entry.c;
@@ -1797,8 +1841,8 @@ async function handleDownloadStream(request) {
 }
 
 // src/handlers/scan.ts
-import { promises as fs7 } from "fs";
-import path7 from "path";
+import { promises as fs8 } from "fs";
+import path8 from "path";
 import sharp3 from "sharp";
 import { encode as encode2 } from "blurhash";
 async function handleScanStream() {
@@ -1821,10 +1865,10 @@ async function handleScanStream() {
         const allFiles = [];
         async function scanDir(dir, relativePath = "") {
           try {
-            const entries = await fs7.readdir(dir, { withFileTypes: true });
+            const entries = await fs8.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".")) continue;
-              const fullPath = path7.join(dir, entry.name);
+              const fullPath = path8.join(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (relPath === "images" || relPath.startsWith("images/")) continue;
               if (entry.isDirectory()) {
@@ -1854,7 +1898,7 @@ async function handleScanStream() {
             continue;
           }
           if (meta[imageKey]) {
-            const ext = path7.extname(relativePath);
+            const ext = path8.extname(relativePath);
             const baseName = relativePath.slice(0, -ext.length);
             let counter = 1;
             let newKey = `/${baseName}-${counter}${ext}`;
@@ -1865,7 +1909,7 @@ async function handleScanStream() {
             const newRelativePath = `${baseName}-${counter}${ext}`;
             const newFullPath = getPublicPath(newRelativePath);
             try {
-              await fs7.rename(fullPath, newFullPath);
+              await fs8.rename(fullPath, newFullPath);
               renamed.push({ from: relativePath, to: newRelativePath });
               relativePath = newRelativePath;
               fullPath = newFullPath;
@@ -1879,12 +1923,12 @@ async function handleScanStream() {
           try {
             const isImage = isImageFile(relativePath);
             if (isImage) {
-              const ext = path7.extname(relativePath).toLowerCase();
+              const ext = path8.extname(relativePath).toLowerCase();
               if (ext === ".svg") {
                 meta[imageKey] = { o: { w: 0, h: 0 }, b: "" };
               } else {
                 try {
-                  const buffer = await fs7.readFile(fullPath);
+                  const buffer = await fs8.readFile(fullPath);
                   const metadata = await sharp3(buffer).metadata();
                   const { data, info } = await sharp3(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
                   const blurhash = encode2(new Uint8ClampedArray(data), info.width, info.height, 4, 4);
@@ -1918,10 +1962,10 @@ async function handleScanStream() {
         }
         async function findOrphans(dir, relativePath = "") {
           try {
-            const entries = await fs7.readdir(dir, { withFileTypes: true });
+            const entries = await fs8.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".")) continue;
-              const fullPath = path7.join(dir, entry.name);
+              const fullPath = path8.join(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 await findOrphans(fullPath, relPath);
@@ -1981,7 +2025,7 @@ async function handleDeleteOrphans(request) {
       }
       const fullPath = getPublicPath(orphanPath);
       try {
-        await fs7.unlink(fullPath);
+        await fs8.unlink(fullPath);
         deleted.push(orphanPath);
       } catch (err) {
         console.error(`Failed to delete ${orphanPath}:`, err);
@@ -1991,18 +2035,18 @@ async function handleDeleteOrphans(request) {
     const imagesDir = getPublicPath("images");
     async function removeEmptyDirs(dir) {
       try {
-        const entries = await fs7.readdir(dir, { withFileTypes: true });
+        const entries = await fs8.readdir(dir, { withFileTypes: true });
         let isEmpty = true;
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const subDirEmpty = await removeEmptyDirs(path7.join(dir, entry.name));
+            const subDirEmpty = await removeEmptyDirs(path8.join(dir, entry.name));
             if (!subDirEmpty) isEmpty = false;
           } else {
             isEmpty = false;
           }
         }
-        if (isEmpty && dir !== imagesDir) {
-          await fs7.rmdir(dir);
+        if (isEmpty) {
+          await fs8.rmdir(dir);
         }
         return isEmpty;
       } catch {
@@ -2030,8 +2074,8 @@ import { encode as encode3 } from "blurhash";
 function parseImageUrl(url) {
   const parsed = new URL(url);
   const base = `${parsed.protocol}//${parsed.host}`;
-  const path9 = parsed.pathname;
-  return { base, path: path9 };
+  const path10 = parsed.pathname;
+  return { base, path: path10 };
 }
 async function processRemoteImage(url) {
   const response = await fetch(url);
@@ -2080,20 +2124,20 @@ async function handleImportUrls(request) {
             currentFile: url
           });
           try {
-            const { base, path: path9 } = parseImageUrl(url);
-            const existingEntry = getMetaEntry(meta, path9);
+            const { base, path: path10 } = parseImageUrl(url);
+            const existingEntry = getMetaEntry(meta, path10);
             if (existingEntry) {
-              skipped.push(path9);
+              skipped.push(path10);
               continue;
             }
             const cdnIndex = getOrAddCdnIndex(meta, base);
             const imageData = await processRemoteImage(url);
-            setMetaEntry(meta, path9, {
+            setMetaEntry(meta, path10, {
               o: imageData.o,
               b: imageData.b,
               c: cdnIndex
             });
-            added.push(path9);
+            added.push(path10);
           } catch (error) {
             console.error(`Failed to import ${url}:`, error);
             errors.push(url);
@@ -2150,8 +2194,8 @@ async function handleUpdateCdns(request) {
 
 // src/handlers/favicon.ts
 import sharp5 from "sharp";
-import path8 from "path";
-import fs8 from "fs/promises";
+import path9 from "path";
+import fs9 from "fs/promises";
 var FAVICON_CONFIGS = [
   { name: "favicon.ico", size: 48 },
   { name: "icon.png", size: 32 },
@@ -2169,7 +2213,7 @@ async function handleGenerateFavicon(request) {
   } catch {
     return jsonResponse({ error: "Invalid request body" }, { status: 400 });
   }
-  const fileName = path8.basename(imagePath).toLowerCase();
+  const fileName = path9.basename(imagePath).toLowerCase();
   if (fileName !== "favicon.png" && fileName !== "favicon.jpg") {
     return jsonResponse({
       error: "Source file must be named favicon.png or favicon.jpg"
@@ -2177,7 +2221,7 @@ async function handleGenerateFavicon(request) {
   }
   const sourcePath = getPublicPath(imagePath.replace(/^\//, ""));
   try {
-    await fs8.access(sourcePath);
+    await fs9.access(sourcePath);
   } catch {
     return jsonResponse({ error: "Source file not found" }, { status: 404 });
   }
@@ -2189,7 +2233,7 @@ async function handleGenerateFavicon(request) {
   }
   const outputDir = getSrcAppPath();
   try {
-    await fs8.access(outputDir);
+    await fs9.access(outputDir);
   } catch {
     return jsonResponse({
       error: "Output directory src/app/ not found"
@@ -2221,7 +2265,7 @@ async function handleGenerateFavicon(request) {
             message: `Generating ${config.name} (${config.size}x${config.size})...`
           });
           try {
-            const outputPath = path8.join(outputDir, config.name);
+            const outputPath = path9.join(outputDir, config.name);
             await sharp5(sourcePath).resize(config.size, config.size, {
               fit: "cover",
               position: "center"