@gallop.software/studio 0.1.88 → 0.1.89

package/dist/handlers/index.js

@@ -1,6 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkCN5NRNWBjs = require('../chunk-CN5NRNWB.js');
+
+var _chunkHE2DOD2Kjs = require('../chunk-HE2DOD2K.js');
 
 // src/handlers/index.ts
 var _server = require('next/server');
@@ -9,7 +10,6 @@ var _server = require('next/server');
 
 var _fs = require('fs');
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-var _sharp = require('sharp'); var _sharp2 = _interopRequireDefault(_sharp);
 
 // src/handlers/utils/meta.ts
 
@@ -32,7 +32,6 @@ async function saveMeta(meta) {
 
 // src/handlers/utils/files.ts
 
-
 function isImageFile(filename) {
   const ext = _path2.default.extname(filename).toLowerCase();
   return [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".ico", ".bmp", ".tiff", ".tif"].includes(ext);
@@ -63,34 +62,11 @@ function getContentType(filePath) {
       return "application/octet-stream";
   }
 }
-async function getFolderStats(folderPath) {
-  let fileCount = 0;
-  let totalSize = 0;
-  async function scanFolder(dir) {
-    try {
-      const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name.startsWith(".")) continue;
-        const fullPath = _path2.default.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          await scanFolder(fullPath);
-        } else if (isMediaFile(entry.name)) {
-          fileCount++;
-          const stats = await _fs.promises.stat(fullPath);
-          totalSize += stats.size;
-        }
-      }
-    } catch (e2) {
-    }
-  }
-  await scanFolder(folderPath);
-  return { fileCount, totalSize };
-}
 
 // src/handlers/utils/thumbnails.ts
 
 
-
+var _sharp = require('sharp'); var _sharp2 = _interopRequireDefault(_sharp);
 var _blurhash = require('blurhash');
 var DEFAULT_SIZES = {
   small: { width: 300, suffix: "-sm" },
@@ -180,7 +156,7 @@ async function uploadToCdn(imageKey) {
   const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
   if (!bucketName) throw new Error("R2 bucket not configured");
   const r2 = getR2Client();
-  for (const thumbPath of _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+  for (const thumbPath of _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, imageKey)) {
     const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
     try {
       const fileBuffer = await _fs.promises.readFile(localPath);
@@ -192,16 +168,16 @@ async function uploadToCdn(imageKey) {
           ContentType: getContentType(thumbPath)
         })
       );
-    } catch (e3) {
+    } catch (e2) {
     }
   }
 }
 async function deleteLocalThumbnails(imageKey) {
-  for (const thumbPath of _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+  for (const thumbPath of _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, imageKey)) {
     const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
     try {
       await _fs.promises.unlink(localPath);
-    } catch (e4) {
+    } catch (e3) {
     }
   }
 }
@@ -211,70 +187,85 @@ async function handleList(request) {
   const searchParams = request.nextUrl.searchParams;
   const requestedPath = searchParams.get("path") || "public";
   try {
-    const safePath = requestedPath.replace(/\.\./g, "");
-    const absolutePath = _path2.default.join(process.cwd(), safePath);
-    if (!absolutePath.startsWith(process.cwd())) {
-      return _server.NextResponse.json({ error: "Invalid path" }, { status: 400 });
+    const meta = await loadMeta();
+    const metaKeys = Object.keys(meta);
+    if (metaKeys.length === 0) {
+      return _server.NextResponse.json({ items: [], isEmpty: true });
     }
+    const relativePath = requestedPath.replace(/^public\/?/, "");
+    const pathPrefix = relativePath ? `/${relativePath}/` : "/";
     const items = [];
-    const entries = await _fs.promises.readdir(absolutePath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue;
-      const itemPath = _path2.default.join(safePath, entry.name);
-      if (entry.isDirectory()) {
-        const folderStats = await getFolderStats(_path2.default.join(absolutePath, entry.name));
-        items.push({
-          name: entry.name,
-          path: itemPath,
-          type: "folder",
-          fileCount: folderStats.fileCount,
-          totalSize: folderStats.totalSize
-        });
-      } else if (isMediaFile(entry.name)) {
-        const filePath = _path2.default.join(absolutePath, entry.name);
-        const stats = await _fs.promises.stat(filePath);
-        const isImage = isImageFile(entry.name);
+    const seenFolders = /* @__PURE__ */ new Set();
+    for (const key of metaKeys) {
+      const entry = meta[key];
+      if (!key.startsWith(pathPrefix) && pathPrefix !== "/") continue;
+      if (pathPrefix === "/" && !key.startsWith("/")) continue;
+      const remaining = pathPrefix === "/" ? key.slice(1) : key.slice(pathPrefix.length);
+      if (!remaining) continue;
+      const slashIndex = remaining.indexOf("/");
+      if (slashIndex !== -1) {
+        const folderName = remaining.slice(0, slashIndex);
+        if (!seenFolders.has(folderName)) {
+          seenFolders.add(folderName);
+          const folderPrefix = pathPrefix === "/" ? `/${folderName}/` : `${pathPrefix}${folderName}/`;
+          let fileCount = 0;
+          for (const k of metaKeys) {
+            if (k.startsWith(folderPrefix)) fileCount++;
+          }
+          items.push({
+            name: folderName,
+            path: relativePath ? `public/${relativePath}/${folderName}` : `public/${folderName}`,
+            type: "folder",
+            fileCount
+          });
+        }
+      } else {
+        const fileName = remaining;
+        const isImage = isImageFile(fileName);
+        const isSynced = entry.s === 1;
         let thumbnail;
         let hasThumbnail = false;
-        let dimensions;
-        if (isImage) {
-          const relativePath = safePath.replace(/^public\/?/, "");
-          if (relativePath === "images" || relativePath.startsWith("images/")) {
-            thumbnail = itemPath.replace("public", "");
-            hasThumbnail = true;
+        let fileSize;
+        if (isImage && (entry.w || entry.blur)) {
+          const thumbPath = _chunkHE2DOD2Kjs.getThumbnailPath.call(void 0, key, "sm");
+          if (isSynced) {
+            const cdnUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL || process.env.NEXT_PUBLIC_CLOUDFLARE_R2_PUBLIC_URL;
+            if (cdnUrl) {
+              thumbnail = `${cdnUrl}${thumbPath}`;
+              hasThumbnail = true;
+            }
           } else {
-            const ext = _path2.default.extname(entry.name).toLowerCase();
-            const baseName = _path2.default.basename(entry.name, ext);
-            const thumbnailDir = relativePath ? `images/${relativePath}` : "images";
-            const thumbnailName = `${baseName}-sm${ext === ".png" ? ".png" : ".jpg"}`;
-            const thumbnailPath = _path2.default.join(process.cwd(), "public", thumbnailDir, thumbnailName);
+            const localThumbPath = _path2.default.join(process.cwd(), "public", thumbPath);
             try {
-              await _fs.promises.access(thumbnailPath);
-              thumbnail = `/${thumbnailDir}/${thumbnailName}`;
+              await _fs.promises.access(localThumbPath);
+              thumbnail = thumbPath;
               hasThumbnail = true;
-            } catch (e5) {
-              thumbnail = itemPath.replace("public", "");
+            } catch (e4) {
+              thumbnail = key;
               hasThumbnail = false;
             }
           }
-          if (!entry.name.toLowerCase().endsWith(".svg")) {
-            try {
-              const metadata = await _sharp2.default.call(void 0, filePath).metadata();
-              if (metadata.width && metadata.height) {
-                dimensions = { width: metadata.width, height: metadata.height };
-              }
-            } catch (e6) {
-            }
+        } else if (isImage) {
+          thumbnail = key;
+          hasThumbnail = false;
+        }
+        if (!isSynced) {
+          try {
+            const filePath = _path2.default.join(process.cwd(), "public", key);
+            const stats = await _fs.promises.stat(filePath);
+            fileSize = stats.size;
+          } catch (e5) {
           }
         }
         items.push({
-          name: entry.name,
-          path: itemPath,
+          name: fileName,
+          path: relativePath ? `public/${relativePath}/${fileName}` : `public/${fileName}`,
           type: "file",
-          size: stats.size,
+          size: fileSize,
           thumbnail,
           hasThumbnail,
-          dimensions
+          cdnSynced: isSynced,
+          dimensions: entry.w && entry.h ? { width: entry.w, height: entry.h } : void 0
         });
       }
     }
@@ -291,62 +282,49 @@ async function handleSearch(request) {
     return _server.NextResponse.json({ items: [] });
   }
   try {
+    const meta = await loadMeta();
     const items = [];
-    const publicDir = _path2.default.join(process.cwd(), "public");
-    async function searchDir(dir, relativePath) {
-      try {
-        const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = _path2.default.join(dir, entry.name);
-          const itemPath = relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`;
-          const itemRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            await searchDir(fullPath, itemRelPath);
-          } else if (isImageFile(entry.name)) {
-            if (itemPath.toLowerCase().includes(query)) {
-              const stats = await _fs.promises.stat(fullPath);
-              let thumbnail;
-              let hasThumbnail = false;
-              let dimensions;
-              const ext = _path2.default.extname(entry.name).toLowerCase();
-              const baseName = _path2.default.basename(entry.name, ext);
-              const thumbnailDir = relativePath ? `images/${relativePath}` : "images";
-              const thumbnailName = `${baseName}-sm${ext === ".png" ? ".png" : ".jpg"}`;
-              const thumbnailPath = _path2.default.join(process.cwd(), "public", thumbnailDir, thumbnailName);
-              try {
-                await _fs.promises.access(thumbnailPath);
-                thumbnail = `/${thumbnailDir}/${thumbnailName}`;
-                hasThumbnail = true;
-              } catch (e7) {
-                thumbnail = `/${itemRelPath}`;
-                hasThumbnail = false;
-              }
-              if (!entry.name.toLowerCase().endsWith(".svg")) {
-                try {
-                  const metadata = await _sharp2.default.call(void 0, fullPath).metadata();
-                  if (metadata.width && metadata.height) {
-                    dimensions = { width: metadata.width, height: metadata.height };
-                  }
-                } catch (e8) {
-                }
-              }
-              items.push({
-                name: entry.name,
-                path: itemPath,
-                type: "file",
-                size: stats.size,
-                thumbnail,
-                hasThumbnail,
-                dimensions
-              });
-            }
+    for (const [key, entry] of Object.entries(meta)) {
+      if (!key.toLowerCase().includes(query)) continue;
+      const fileName = _path2.default.basename(key);
+      const relativePath = key.slice(1);
+      const isImage = isImageFile(fileName);
+      const isSynced = entry.s === 1;
+      let thumbnail;
+      let hasThumbnail = false;
+      if (isImage && (entry.w || entry.blur)) {
+        const thumbPath = _chunkHE2DOD2Kjs.getThumbnailPath.call(void 0, key, "sm");
+        if (isSynced) {
+          const cdnUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL || process.env.NEXT_PUBLIC_CLOUDFLARE_R2_PUBLIC_URL;
+          if (cdnUrl) {
+            thumbnail = `${cdnUrl}${thumbPath}`;
+            hasThumbnail = true;
+          }
+        } else {
+          const localThumbPath = _path2.default.join(process.cwd(), "public", thumbPath);
+          try {
+            await _fs.promises.access(localThumbPath);
+            thumbnail = thumbPath;
+            hasThumbnail = true;
+          } catch (e6) {
+            thumbnail = key;
+            hasThumbnail = false;
           }
         }
-      } catch (e9) {
+      } else if (isImage) {
+        thumbnail = key;
+        hasThumbnail = false;
       }
+      items.push({
+        name: fileName,
+        path: `public/${relativePath}`,
+        type: "file",
+        thumbnail,
+        hasThumbnail,
+        cdnSynced: isSynced,
+        dimensions: entry.w && entry.h ? { width: entry.w, height: entry.h } : void 0
+      });
     }
-    await searchDir(publicDir, "");
     return _server.NextResponse.json({ items });
   } catch (error) {
     console.error("Failed to search:", error);
@@ -355,27 +333,28 @@ async function handleSearch(request) {
 }
 async function handleListFolders() {
   try {
-    const publicDir = _path2.default.join(process.cwd(), "public");
-    const folders = [];
-    async function scanDir(dir, relativePath, depth) {
-      try {
-        const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (!entry.isDirectory()) continue;
-          if (entry.name.startsWith(".")) continue;
-          const folderRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          folders.push({
-            path: `public/${folderRelativePath}`,
-            name: entry.name,
-            depth
-          });
-          await scanDir(_path2.default.join(dir, entry.name), folderRelativePath, depth + 1);
-        }
-      } catch (e10) {
+    const meta = await loadMeta();
+    const folderSet = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(meta)) {
+      const parts = key.split("/");
+      let current = "";
+      for (let i = 1; i < parts.length - 1; i++) {
+        current = current ? `${current}/${parts[i]}` : parts[i];
+        folderSet.add(current);
       }
     }
+    const folders = [];
     folders.push({ path: "public", name: "public", depth: 0 });
-    await scanDir(publicDir, "", 1);
+    const sortedFolders = Array.from(folderSet).sort();
+    for (const folderPath of sortedFolders) {
+      const depth = folderPath.split("/").length;
+      const name = folderPath.split("/").pop() || folderPath;
+      folders.push({
+        path: `public/${folderPath}`,
+        name,
+        depth
+      });
+    }
     return _server.NextResponse.json({ folders });
   } catch (error) {
     console.error("Failed to list folders:", error);
@@ -384,26 +363,14 @@ async function handleListFolders() {
 }
 async function handleCountImages() {
   try {
+    const meta = await loadMeta();
     const allImages = [];
-    async function scanPublicFolder(dir, relativePath = "") {
-      try {
-        const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = _path2.default.join(dir, entry.name);
-          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (relPath === "images" || relPath.startsWith("images/")) continue;
-          if (entry.isDirectory()) {
-            await scanPublicFolder(fullPath, relPath);
-          } else if (isImageFile(entry.name)) {
-            allImages.push(relPath);
-          }
-        }
-      } catch (e11) {
+    for (const key of Object.keys(meta)) {
+      const fileName = _path2.default.basename(key);
+      if (isImageFile(fileName)) {
+        allImages.push(key.slice(1));
       }
     }
-    const publicDir = _path2.default.join(process.cwd(), "public");
-    await scanPublicFolder(publicDir);
     return _server.NextResponse.json({
       count: allImages.length,
       images: allImages
@@ -421,29 +388,22 @@ async function handleFolderImages(request) {
       return _server.NextResponse.json({ error: "No folders provided" }, { status: 400 });
     }
     const folders = foldersParam.split(",");
+    const meta = await loadMeta();
     const allImages = [];
-    async function scanFolder(dir, relativePath = "") {
-      try {
-        const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = _path2.default.join(dir, entry.name);
-          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            await scanFolder(fullPath, relPath);
-          } else if (isImageFile(entry.name)) {
-            allImages.push(relPath);
-          }
+    const prefixes = folders.map((f) => {
+      const rel = f.replace(/^public\/?/, "");
+      return rel ? `/${rel}/` : "/";
+    });
+    for (const key of Object.keys(meta)) {
+      const fileName = _path2.default.basename(key);
+      if (!isImageFile(fileName)) continue;
+      for (const prefix of prefixes) {
+        if (key.startsWith(prefix) || prefix === "/" && key.startsWith("/")) {
+          allImages.push(key.slice(1));
+          break;
         }
-      } catch (e12) {
       }
     }
-    for (const folder of folders) {
-      const relativePath = folder.replace(/^public\/?/, "");
-      if (relativePath === "images" || relativePath.startsWith("images/")) continue;
-      const folderPath = _path2.default.join(process.cwd(), folder);
-      await scanFolder(folderPath, relativePath);
-    }
     return _server.NextResponse.json({
       count: allImages.length,
       images: allImages
@@ -459,7 +419,6 @@ async function handleFolderImages(request) {
 
 
 
-
 async function handleUpload(request) {
   try {
     const formData = await request.formData();
@@ -471,11 +430,9 @@ async function handleUpload(request) {
     const bytes = await file.arrayBuffer();
     const buffer = Buffer.from(bytes);
     const fileName = file.name;
-    const baseName = _path2.default.basename(fileName, _path2.default.extname(fileName));
     const ext = _path2.default.extname(fileName).toLowerCase();
     const isImage = isImageFile(fileName);
-    const isSvg = ext === ".svg";
-    const isProcessableImage = isImage && !isSvg;
+    const isMedia = isMediaFile(fileName);
     const meta = await loadMeta();
     let relativeDir = "";
     if (targetPath === "public") {
@@ -489,71 +446,49 @@ async function handleUpload(request) {
         { status: 400 }
       );
     }
+    let imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
+    if (meta[imageKey]) {
+      const baseName = _path2.default.basename(fileName, ext);
+      let counter = 1;
+      let newFileName = `${baseName}-${counter}${ext}`;
+      let newKey = "/" + (relativeDir ? `${relativeDir}/${newFileName}` : newFileName);
+      while (meta[newKey]) {
+        counter++;
+        newFileName = `${baseName}-${counter}${ext}`;
+        newKey = "/" + (relativeDir ? `${relativeDir}/${newFileName}` : newFileName);
+      }
+      imageKey = newKey;
+    }
+    const actualFileName = _path2.default.basename(imageKey);
     const uploadDir = _path2.default.join(process.cwd(), "public", relativeDir);
     await _fs.promises.mkdir(uploadDir, { recursive: true });
-    await _fs.promises.writeFile(_path2.default.join(uploadDir, fileName), buffer);
-    if (!isImage) {
+    await _fs.promises.writeFile(_path2.default.join(uploadDir, actualFileName), buffer);
+    if (!isMedia) {
       return _server.NextResponse.json({
         success: true,
-        message: "File uploaded successfully (non-image, no thumbnails generated)",
-        path: `public/${relativeDir ? relativeDir + "/" : ""}${fileName}`
+        message: "File uploaded (not a media file)",
+        path: `public/${relativeDir ? relativeDir + "/" : ""}${actualFileName}`
       });
     }
-    const imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
-    if (meta[imageKey]) {
-      return _server.NextResponse.json(
-        { error: `File '${imageKey}' already exists in meta` },
-        { status: 409 }
-      );
-    }
-    const imagesPath = _path2.default.join(process.cwd(), "public", "images", relativeDir);
-    await _fs.promises.mkdir(imagesPath, { recursive: true });
-    let originalWidth = 0;
-    let originalHeight = 0;
-    let blurhash = "";
-    const originalPath = `/${relativeDir ? relativeDir + "/" : ""}${fileName}`;
-    if (isSvg) {
-      const fullPath = _path2.default.join(imagesPath, fileName);
-      await _fs.promises.writeFile(fullPath, buffer);
-    } else if (isProcessableImage) {
-      const sharpInstance = _sharp2.default.call(void 0, buffer);
-      const metadata = await sharpInstance.metadata();
-      originalWidth = metadata.width || 0;
-      originalHeight = metadata.height || 0;
-      const outputExt = ext === ".png" ? ".png" : ".jpg";
-      const fullFileName = `${baseName}${outputExt}`;
-      const fullPath = _path2.default.join(imagesPath, fullFileName);
-      if (ext === ".png") {
-        await _sharp2.default.call(void 0, buffer).png({ quality: 85 }).toFile(fullPath);
-      } else {
-        await _sharp2.default.call(void 0, buffer).jpeg({ quality: 85 }).toFile(fullPath);
-      }
-      for (const [, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
-        const { width: maxWidth, suffix } = sizeConfig;
-        if (originalWidth <= maxWidth) {
-          continue;
-        }
-        const ratio = originalHeight / originalWidth;
-        const newHeight = Math.round(maxWidth * ratio);
-        const sizeFileName = `${baseName}${suffix}${outputExt}`;
-        const sizePath = _path2.default.join(imagesPath, sizeFileName);
-        if (ext === ".png") {
-          await _sharp2.default.call(void 0, buffer).resize(maxWidth, newHeight).png({ quality: 80 }).toFile(sizePath);
-        } else {
-          await _sharp2.default.call(void 0, buffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
-        }
+    if (isImage && ext !== ".svg") {
+      try {
+        const metadata = await _sharp2.default.call(void 0, buffer).metadata();
+        meta[imageKey] = {
+          w: metadata.width || 0,
+          h: metadata.height || 0
+        };
+      } catch (e7) {
+        meta[imageKey] = { w: 0, h: 0 };
       }
-      const { data, info } = await _sharp2.default.call(void 0, buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-      blurhash = _blurhash.encode.call(void 0, new Uint8ClampedArray(data), info.width, info.height, 4, 4);
+    } else {
+      meta[imageKey] = {};
     }
-    const entry = {
-      w: originalWidth,
-      h: originalHeight,
-      blur: blurhash
-    };
-    meta[originalPath] = entry;
     await saveMeta(meta);
-    return _server.NextResponse.json({ success: true, imageKey: originalPath, entry });
+    return _server.NextResponse.json({
+      success: true,
+      imageKey,
+      message: 'File uploaded. Run "Process Images" to generate thumbnails.'
+    });
   } catch (error) {
     console.error("Failed to upload:", error);
     const message = error instanceof Error ? error.message : "Unknown error";
@@ -576,31 +511,61 @@ async function handleDelete(request) {
           continue;
         }
         const absolutePath = _path2.default.join(process.cwd(), itemPath);
-        const stats = await _fs.promises.stat(absolutePath);
-        if (stats.isDirectory()) {
-          await _fs.promises.rm(absolutePath, { recursive: true });
-          const prefix = "/" + itemPath.replace(/^public\/images\/?/, "").replace(/^public\/?/, "");
-          for (const key of Object.keys(meta)) {
-            if (key.startsWith(prefix)) {
-              delete meta[key];
+        const imageKey = "/" + itemPath.replace(/^public\//, "");
+        const entry = meta[imageKey];
+        const isSynced = _optionalChain([entry, 'optionalAccess', _5 => _5.s]) === 1;
+        try {
+          const stats = await _fs.promises.stat(absolutePath);
+          if (stats.isDirectory()) {
+            await _fs.promises.rm(absolutePath, { recursive: true });
+            const prefix = imageKey + "/";
+            for (const key of Object.keys(meta)) {
+              if (key.startsWith(prefix) || key === imageKey) {
+                if (!meta[key].s) {
+                  for (const thumbPath of _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, key)) {
+                    const absoluteThumbPath = _path2.default.join(process.cwd(), "public", thumbPath);
+                    try {
+                      await _fs.promises.unlink(absoluteThumbPath);
+                    } catch (e8) {
+                    }
+                  }
+                }
+                delete meta[key];
+              }
             }
-          }
-        } else {
-          await _fs.promises.unlink(absolutePath);
-          const isInImagesFolder = itemPath.startsWith("public/images/");
-          if (!isInImagesFolder) {
-            const imageKey = "/" + itemPath.replace(/^public\//, "");
-            if (meta[imageKey]) {
-              for (const thumbPath of _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, imageKey)) {
-                const absoluteThumbPath = _path2.default.join(process.cwd(), "public", thumbPath);
-                try {
-                  await _fs.promises.unlink(absoluteThumbPath);
-                } catch (e13) {
+          } else {
+            await _fs.promises.unlink(absolutePath);
+            const isInImagesFolder = itemPath.startsWith("public/images/");
+            if (!isInImagesFolder && entry) {
+              if (!isSynced) {
+                for (const thumbPath of _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+                  const absoluteThumbPath = _path2.default.join(process.cwd(), "public", thumbPath);
+                  try {
+                    await _fs.promises.unlink(absoluteThumbPath);
+                  } catch (e9) {
+                  }
                 }
               }
               delete meta[imageKey];
             }
           }
+        } catch (e10) {
+          if (entry) {
+            delete meta[imageKey];
+          } else {
+            const prefix = imageKey + "/";
+            let foundAny = false;
+            for (const key of Object.keys(meta)) {
+              if (key.startsWith(prefix)) {
+                delete meta[key];
+                foundAny = true;
+              }
+            }
+            if (!foundAny) {
+              errors.push(`Not found: ${itemPath}`);
+              continue;
+            }
+          }
         }
         deleted.push(itemPath);
       } catch (error) {
@@ -637,7 +602,7 @@ async function handleCreateFolder(request) {
     try {
       await _fs.promises.access(folderPath);
       return _server.NextResponse.json({ error: "A folder with this name already exists" }, { status: 400 });
-    } catch (e14) {
+    } catch (e11) {
     }
     await _fs.promises.mkdir(folderPath, { recursive: true });
     return _server.NextResponse.json({ success: true, path: _path2.default.join(safePath, sanitizedName) });
@@ -665,13 +630,13 @@ async function handleRename(request) {
     }
     try {
       await _fs.promises.access(absoluteOldPath);
-    } catch (e15) {
+    } catch (e12) {
       return _server.NextResponse.json({ error: "File or folder not found" }, { status: 404 });
     }
     try {
       await _fs.promises.access(absoluteNewPath);
       return _server.NextResponse.json({ error: "An item with this name already exists" }, { status: 400 });
-    } catch (e16) {
+    } catch (e13) {
     }
     const stats = await _fs.promises.stat(absoluteOldPath);
     const isFile = stats.isFile();
@@ -685,15 +650,15 @@ async function handleRename(request) {
       const newKey = "/" + newRelativePath;
       if (meta[oldKey]) {
         const entry = meta[oldKey];
-        const oldThumbPaths = _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, oldKey);
-        const newThumbPaths = _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, newKey);
+        const oldThumbPaths = _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, oldKey);
+        const newThumbPaths = _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, newKey);
         for (let i = 0; i < oldThumbPaths.length; i++) {
           const oldThumbPath = _path2.default.join(process.cwd(), "public", oldThumbPaths[i]);
           const newThumbPath = _path2.default.join(process.cwd(), "public", newThumbPaths[i]);
           await _fs.promises.mkdir(_path2.default.dirname(newThumbPath), { recursive: true });
           try {
             await _fs.promises.rename(oldThumbPath, newThumbPath);
-          } catch (e17) {
+          } catch (e14) {
           }
         }
         delete meta[oldKey];
@@ -727,7 +692,7 @@ async function handleMove(request) {
       if (!destStats.isDirectory()) {
         return _server.NextResponse.json({ error: "Destination is not a folder" }, { status: 400 });
       }
-    } catch (e18) {
+    } catch (e15) {
       return _server.NextResponse.json({ error: "Destination folder not found" }, { status: 404 });
     }
     const moved = [];
@@ -745,7 +710,7 @@ async function handleMove(request) {
       }
       try {
         await _fs.promises.access(absolutePath);
-      } catch (e19) {
+      } catch (e16) {
         errors.push(`${itemName} not found`);
         continue;
       }
@@ -753,7 +718,7 @@ async function handleMove(request) {
         await _fs.promises.access(newAbsolutePath);
         errors.push(`${itemName} already exists in destination`);
         continue;
-      } catch (e20) {
+      } catch (e17) {
       }
       try {
         await _fs.promises.rename(absolutePath, newAbsolutePath);
@@ -765,15 +730,15 @@ async function handleMove(request) {
           const newKey = "/" + newRelativePath;
           if (meta[oldKey]) {
             const entry = meta[oldKey];
-            const oldThumbPaths = _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, oldKey);
-            const newThumbPaths = _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, newKey);
+            const oldThumbPaths = _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, oldKey);
+            const newThumbPaths = _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, newKey);
             for (let i = 0; i < oldThumbPaths.length; i++) {
               const oldThumbPath = _path2.default.join(process.cwd(), "public", oldThumbPaths[i]);
               const newThumbPath = _path2.default.join(process.cwd(), "public", newThumbPaths[i]);
               await _fs.promises.mkdir(_path2.default.dirname(newThumbPath), { recursive: true });
               try {
                 await _fs.promises.rename(oldThumbPath, newThumbPath);
-              } catch (e21) {
+              } catch (e18) {
               }
             }
             delete meta[oldKey];
@@ -782,7 +747,7 @@ async function handleMove(request) {
           }
         }
         moved.push(itemPath);
-      } catch (e22) {
+      } catch (e19) {
         errors.push(`Failed to move ${itemName}`);
       }
     }
@@ -833,7 +798,7 @@ async function handleSync(request) {
     for (const imageKey of imageKeys) {
       const entry = meta[imageKey];
       if (!entry) {
-        errors.push(`Image not found in meta: ${imageKey}`);
+        errors.push(`Image not found in meta: ${imageKey}. Run Scan first.`);
         continue;
       }
       if (entry.s) {
@@ -841,7 +806,22 @@ async function handleSync(request) {
         continue;
       }
       try {
-        for (const thumbPath of _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+        const originalLocalPath = _path2.default.join(process.cwd(), "public", imageKey);
+        try {
+          const originalBuffer = await _fs.promises.readFile(originalLocalPath);
+          await r2.send(
+            new (0, _clients3.PutObjectCommand)({
+              Bucket: bucketName,
+              Key: imageKey.replace(/^\//, ""),
+              Body: originalBuffer,
+              ContentType: getContentType(imageKey)
+            })
+          );
+        } catch (err) {
+          errors.push(`Original file not found: ${imageKey}`);
+          continue;
+        }
+        for (const thumbPath of _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, imageKey)) {
           const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
           try {
             const fileBuffer = await _fs.promises.readFile(localPath);
@@ -853,21 +833,25 @@ async function handleSync(request) {
                 ContentType: getContentType(thumbPath)
               })
             );
-          } catch (e23) {
+          } catch (e20) {
           }
         }
         entry.s = 1;
-        for (const thumbPath of _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+        for (const thumbPath of _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, imageKey)) {
           const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
           try {
             await _fs.promises.unlink(localPath);
-          } catch (e24) {
+          } catch (e21) {
           }
         }
+        try {
+          await _fs.promises.unlink(originalLocalPath);
+        } catch (e22) {
+        }
         synced.push(imageKey);
       } catch (error) {
         console.error(`Failed to sync ${imageKey}:`, error);
-        errors.push(imageKey);
+        errors.push(`Failed to sync: ${imageKey}`);
       }
     }
     await saveMeta(meta);
@@ -894,21 +878,29 @@ async function handleReprocess(request) {
       try {
         let buffer;
         const entry = meta[imageKey];
+        const isSynced = _optionalChain([entry, 'optionalAccess', _6 => _6.s]) === 1;
         const originalPath = _path2.default.join(process.cwd(), "public", imageKey);
         try {
           buffer = await _fs.promises.readFile(originalPath);
-        } catch (e25) {
-          if (_optionalChain([entry, 'optionalAccess', _5 => _5.s])) {
+        } catch (e23) {
+          if (isSynced) {
             buffer = await downloadFromCdn(imageKey);
+            const dir = _path2.default.dirname(originalPath);
+            await _fs.promises.mkdir(dir, { recursive: true });
+            await _fs.promises.writeFile(originalPath, buffer);
           } else {
             throw new Error(`File not found: ${imageKey}`);
           }
         }
         const updatedEntry = await processImage(buffer, imageKey);
-        if (_optionalChain([entry, 'optionalAccess', _6 => _6.s])) {
+        if (isSynced) {
           updatedEntry.s = 1;
           await uploadToCdn(imageKey);
           await deleteLocalThumbnails(imageKey);
+          try {
+            await _fs.promises.unlink(originalPath);
+          } catch (e24) {
+          }
         }
         meta[imageKey] = updatedEntry;
         processed.push(imageKey);
@@ -942,73 +934,61 @@ async function handleProcessAllStream() {
         const processed = [];
         const errors = [];
         const orphansRemoved = [];
-        const allImages = [];
-        async function scanPublicFolder(dir, relativePath = "") {
-          try {
-            const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-              if (entry.name.startsWith(".")) continue;
-              const fullPath = _path2.default.join(dir, entry.name);
-              const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-              if (relPath === "images" || relPath.startsWith("images/")) continue;
-              if (entry.isDirectory()) {
-                await scanPublicFolder(fullPath, relPath);
-              } else if (isImageFile(entry.name)) {
-                allImages.push({ key: relPath, fullPath });
-              }
-            }
-          } catch (e26) {
+        const imagesToProcess = [];
+        for (const [key, entry] of Object.entries(meta)) {
+          if (entry.s) continue;
+          const fileName = _path2.default.basename(key);
+          if (!isImageFile(fileName)) continue;
+          if (!entry.blur) {
+            imagesToProcess.push({ key, entry });
           }
         }
-        const publicDir = _path2.default.join(process.cwd(), "public");
-        await scanPublicFolder(publicDir);
-        const total = allImages.length;
+        const total = imagesToProcess.length;
         sendEvent({ type: "start", total });
-        for (let i = 0; i < allImages.length; i++) {
-          const { key, fullPath } = allImages[i];
-          const imageKey = "/" + key;
+        for (let i = 0; i < imagesToProcess.length; i++) {
+          const { key } = imagesToProcess[i];
+          const fullPath = _path2.default.join(process.cwd(), "public", key);
           sendEvent({
             type: "progress",
             current: i + 1,
             total,
             percent: Math.round((i + 1) / total * 100),
-            currentFile: key
+            currentFile: key.slice(1)
+            // Remove leading /
           });
           try {
             const buffer = await _fs.promises.readFile(fullPath);
             const ext = _path2.default.extname(key).toLowerCase();
             const isSvg = ext === ".svg";
             if (isSvg) {
-              const imageDir = _path2.default.dirname(key);
+              const imageDir = _path2.default.dirname(key.slice(1));
               const imagesPath = _path2.default.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
               await _fs.promises.mkdir(imagesPath, { recursive: true });
               const fileName = _path2.default.basename(key);
               const destPath = _path2.default.join(imagesPath, fileName);
               await _fs.promises.writeFile(destPath, buffer);
-              meta[imageKey] = {
+              meta[key] = {
                 w: 0,
                 h: 0,
                 blur: ""
               };
             } else {
-              const existingEntry = meta[imageKey];
-              const processedEntry = await processImage(buffer, imageKey);
-              if (_optionalChain([existingEntry, 'optionalAccess', _7 => _7.s])) {
-                processedEntry.s = 1;
-              }
-              meta[imageKey] = processedEntry;
+              const processedEntry = await processImage(buffer, key);
+              meta[key] = processedEntry;
             }
-            processed.push(key);
+            processed.push(key.slice(1));
           } catch (error) {
             console.error(`Failed to process ${key}:`, error);
-            errors.push(key);
+            errors.push(key.slice(1));
           }
         }
         sendEvent({ type: "cleanup", message: "Removing orphaned thumbnails..." });
         const trackedPaths = /* @__PURE__ */ new Set();
         for (const imageKey of Object.keys(meta)) {
-          for (const thumbPath of _chunkCN5NRNWBjs.getAllThumbnailPaths.call(void 0, imageKey)) {
-            trackedPaths.add(thumbPath);
+          if (!meta[imageKey].s) {
+            for (const thumbPath of _chunkHE2DOD2Kjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+              trackedPaths.add(thumbPath);
+            }
           }
         }
         async function findOrphans(dir, relativePath = "") {
@@ -1032,11 +1012,14 @@ async function handleProcessAllStream() {
                 }
               }
             }
-          } catch (e27) {
+          } catch (e25) {
           }
         }
         const imagesDir = _path2.default.join(process.cwd(), "public", "images");
-        await findOrphans(imagesDir);
+        try {
+          await findOrphans(imagesDir);
+        } catch (e26) {
+        }
         async function removeEmptyDirs(dir) {
           try {
             const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
@@ -1053,11 +1036,14 @@ async function handleProcessAllStream() {
               await _fs.promises.rmdir(dir);
             }
             return isEmpty;
-          } catch (e28) {
+          } catch (e27) {
             return true;
           }
         }
-        await removeEmptyDirs(imagesDir);
+        try {
+          await removeEmptyDirs(imagesDir);
+        } catch (e28) {
+        }
         await saveMeta(meta);
         sendEvent({
           type: "complete",
@@ -1082,6 +1068,135 @@ async function handleProcessAllStream() {
   });
 }
 
+// src/handlers/scan.ts
+
+
+
+async function handleScanStream() {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      };
+      try {
+        const meta = await loadMeta();
+        const existingKeys = new Set(Object.keys(meta));
+        const added = [];
+        const renamed = [];
+        const errors = [];
+        const allFiles = [];
+        async function scanDir(dir, relativePath = "") {
+          try {
+            const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.name.startsWith(".")) continue;
+              const fullPath = _path2.default.join(dir, entry.name);
+              const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+              if (relPath === "images" || relPath.startsWith("images/")) continue;
+              if (entry.isDirectory()) {
+                await scanDir(fullPath, relPath);
+              } else if (isMediaFile(entry.name)) {
+                allFiles.push({ relativePath: relPath, fullPath });
+              }
+            }
+          } catch (e29) {
+          }
+        }
+        const publicDir = _path2.default.join(process.cwd(), "public");
+        await scanDir(publicDir);
+        const total = allFiles.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < allFiles.length; i++) {
+          let { relativePath, fullPath } = allFiles[i];
+          let imageKey = "/" + relativePath;
+          sendEvent({
+            type: "progress",
+            current: i + 1,
+            total,
+            percent: Math.round((i + 1) / total * 100),
+            currentFile: relativePath
+          });
+          if (existingKeys.has(imageKey)) {
+            continue;
+          }
+          if (meta[imageKey]) {
+            const ext = _path2.default.extname(relativePath);
+            const baseName = relativePath.slice(0, -ext.length);
+            let counter = 1;
+            let newKey = `/${baseName}-${counter}${ext}`;
+            while (meta[newKey]) {
+              counter++;
+              newKey = `/${baseName}-${counter}${ext}`;
+            }
+            const newRelativePath = `${baseName}-${counter}${ext}`;
+            const newFullPath = _path2.default.join(process.cwd(), "public", newRelativePath);
+            try {
+              await _fs.promises.rename(fullPath, newFullPath);
+              renamed.push({ from: relativePath, to: newRelativePath });
+              relativePath = newRelativePath;
+              fullPath = newFullPath;
+              imageKey = newKey;
+            } catch (err) {
+              console.error(`Failed to rename ${relativePath}:`, err);
+              errors.push(`Failed to rename ${relativePath}`);
+              continue;
+            }
+          }
+          try {
+            const isImage = isImageFile(relativePath);
+            if (isImage) {
+              const ext = _path2.default.extname(relativePath).toLowerCase();
+              if (ext === ".svg") {
+                meta[imageKey] = { w: 0, h: 0 };
+              } else {
+                try {
+                  const metadata = await _sharp2.default.call(void 0, fullPath).metadata();
+                  meta[imageKey] = {
+                    w: metadata.width || 0,
+                    h: metadata.height || 0
+                  };
+                } catch (e30) {
+                  meta[imageKey] = { w: 0, h: 0 };
+                }
+              }
+            } else {
+              meta[imageKey] = {};
+            }
+            existingKeys.add(imageKey);
+            added.push(imageKey);
+          } catch (error) {
+            console.error(`Failed to process ${relativePath}:`, error);
+            errors.push(relativePath);
+          }
+        }
+        await saveMeta(meta);
+        sendEvent({
+          type: "complete",
+          added: added.length,
+          renamed: renamed.length,
+          errors: errors.length,
+          renamedFiles: renamed
+        });
+      } catch (error) {
+        console.error("Scan failed:", error);
+        sendEvent({ type: "error", message: "Scan failed" });
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
+}
+
 // src/handlers/index.ts
 async function GET(request) {
   if (process.env.NODE_ENV !== "development") {
@@ -1136,6 +1251,9 @@ async function POST(request) {
   if (route === "move") {
     return handleMove(request);
   }
+  if (route === "scan") {
+    return handleScanStream();
+  }
   return _server.NextResponse.json({ error: "Not found" }, { status: 404 });
 }
 async function DELETE(request) {