@gallop.software/studio 2.3.51 → 2.3.52

package/dist/server/index.js

@@ -1016,8 +1016,8 @@ async function handleFolderImages(request) {
 }
 
 // src/handlers/files.ts
-import { promises as fs6 } from "fs";
-import path6 from "path";
+import { promises as fs7 } from "fs";
+import path7 from "path";
 import sharp2 from "sharp";
 
 // src/handlers/utils/folders.ts
@@ -1087,324 +1087,288 @@ async function cleanupEmptyFoldersRecursive(dir) {
   }
 }
 
-// src/handlers/files.ts
-async function handleUpload(request) {
+// src/handlers/images.ts
+import { promises as fs6 } from "fs";
+import path6 from "path";
+import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2, DeleteObjectCommand as DeleteObjectCommand2 } from "@aws-sdk/client-s3";
+var cancelledOperations = /* @__PURE__ */ new Set();
+function cancelOperation(operationId) {
+  cancelledOperations.add(operationId);
+  setTimeout(() => cancelledOperations.delete(operationId), 6e4);
+}
+function isOperationCancelled(operationId) {
+  return cancelledOperations.has(operationId);
+}
+function clearCancelledOperation(operationId) {
+  cancelledOperations.delete(operationId);
+}
+async function handleSync(request) {
+  const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
+  const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY;
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
+  if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
+    return jsonResponse(
+      { error: "R2 not configured. Set CLOUDFLARE_R2_* environment variables." },
+      { status: 400 }
+    );
+  }
   try {
-    const formData = await request.formData();
-    const file = formData.get("file");
-    const targetPath = formData.get("path") || "public";
-    if (!file) {
-      return jsonResponse({ error: "No file provided" }, { status: 400 });
+    const { imageKeys } = await request.json();
+    if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
+      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
     }
-    const bytes = await file.arrayBuffer();
-    const buffer = Buffer.from(bytes);
-    const fileName = slugifyFilename(file.name);
-    const ext = path6.extname(fileName).toLowerCase();
-    const isImage = isImageFile(fileName);
-    const isMedia = isMediaFile(fileName);
     const meta = await loadMeta();
-    let relativeDir = "";
-    if (targetPath === "public") {
-      relativeDir = "";
-    } else if (targetPath.startsWith("public/")) {
-      relativeDir = targetPath.replace("public/", "");
-    }
-    if (relativeDir === "images" || relativeDir.startsWith("images/")) {
-      return jsonResponse(
-        { error: "Cannot upload to images/ folder. Upload to public/ instead - thumbnails are generated automatically." },
-        { status: 400 }
-      );
-    }
-    let imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
-    if (meta[imageKey]) {
-      const baseName = path6.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);
+    const cdnUrls = getCdnUrls(meta);
+    const cdnIndex = getOrAddCdnIndex(meta, publicUrl);
+    const r2 = new S3Client2({
+      region: "auto",
+      endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+      credentials: { accessKeyId, secretAccessKey }
+    });
+    const pushed = [];
+    const alreadyPushed = [];
+    const errors = [];
+    const sourceFolders = /* @__PURE__ */ new Set();
+    for (let imageKey of imageKeys) {
+      if (!imageKey.startsWith("/")) {
+        imageKey = `/${imageKey}`;
       }
-      imageKey = newKey;
-    }
-    const actualFileName = path6.basename(imageKey);
-    const uploadDir = getPublicPath(relativeDir);
-    await fs6.mkdir(uploadDir, { recursive: true });
-    await fs6.writeFile(path6.join(uploadDir, actualFileName), buffer);
-    if (!isMedia) {
-      return jsonResponse({
-        success: true,
-        message: "File uploaded (not a media file)",
-        path: `public/${relativeDir ? relativeDir + "/" : ""}${actualFileName}`
-      });
-    }
-    if (isImage && ext !== ".svg") {
+      const entry = getMetaEntry(meta, imageKey);
+      if (!entry) {
+        errors.push(`Image not found in meta: ${imageKey}. Run Scan first.`);
+        continue;
+      }
+      const existingCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+      const isAlreadyInOurR2 = existingCdnUrl === publicUrl;
+      if (isAlreadyInOurR2) {
+        alreadyPushed.push(imageKey);
+        continue;
+      }
+      const isRemote = entry.c !== void 0 && existingCdnUrl !== publicUrl;
       try {
-        const metadata = await sharp2(buffer).metadata();
-        meta[imageKey] = {
-          o: { w: metadata.width || 0, h: metadata.height || 0 }
-        };
-      } catch {
-        meta[imageKey] = { o: { w: 0, h: 0 } };
+        let originalBuffer;
+        if (isRemote) {
+          const remoteUrl = `${existingCdnUrl}${imageKey}`;
+          originalBuffer = await downloadFromRemoteUrl(remoteUrl);
+        } else {
+          const originalLocalPath = getPublicPath(imageKey);
+          try {
+            originalBuffer = await fs6.readFile(originalLocalPath);
+          } catch {
+            errors.push(`Original file not found: ${imageKey}`);
+            continue;
+          }
+        }
+        await r2.send(
+          new PutObjectCommand2({
+            Bucket: bucketName,
+            Key: imageKey.replace(/^\//, ""),
+            Body: originalBuffer,
+            ContentType: getContentType(imageKey)
+          })
+        );
+        if (!isRemote && isProcessed(entry)) {
+          for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+            const localPath = getPublicPath(thumbPath);
+            try {
+              const fileBuffer = await fs6.readFile(localPath);
+              await r2.send(
+                new PutObjectCommand2({
+                  Bucket: bucketName,
+                  Key: thumbPath.replace(/^\//, ""),
+                  Body: fileBuffer,
+                  ContentType: getContentType(thumbPath)
+                })
+              );
+            } catch {
+            }
+          }
+        }
+        entry.c = cdnIndex;
+        if (!isRemote) {
+          const originalLocalPath = getPublicPath(imageKey);
+          sourceFolders.add(path6.dirname(originalLocalPath));
+          for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+            const localPath = getPublicPath(thumbPath);
+            sourceFolders.add(path6.dirname(localPath));
+            try {
+              await fs6.unlink(localPath);
+            } catch {
+            }
+          }
+          try {
+            await fs6.unlink(originalLocalPath);
+          } catch {
+          }
+        }
+        pushed.push(imageKey);
+      } catch (error) {
+        console.error(`Failed to push ${imageKey}:`, error);
+        errors.push(`Failed to push: ${imageKey}`);
       }
-    } else {
-      meta[imageKey] = {};
     }
     await saveMeta(meta);
+    for (const folder of sourceFolders) {
+      await deleteEmptyFolders(folder);
+    }
     return jsonResponse({
       success: true,
-      imageKey,
-      message: 'File uploaded. Run "Process Images" to generate thumbnails.'
+      pushed,
+      alreadyPushed: alreadyPushed.length > 0 ? alreadyPushed : void 0,
+      errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
-    console.error("Failed to upload:", error);
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return jsonResponse({ error: `Failed to upload file: ${message}` }, { status: 500 });
+    console.error("Failed to push:", error);
+    return jsonResponse({ error: "Failed to push to CDN" }, { status: 500 });
   }
 }
-async function handleDelete(request) {
+async function handleUnprocessStream(request) {
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
+  const encoder = new TextEncoder();
+  let imageKeys;
   try {
-    const { paths } = await request.json();
-    if (!paths || !Array.isArray(paths) || paths.length === 0) {
-      return jsonResponse({ error: "No paths provided" }, { status: 400 });
+    const body = await request.json();
+    imageKeys = body.imageKeys;
+    if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
+      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
     }
-    const meta = await loadMeta();
-    const deleted = [];
-    const errors = [];
-    const sourceFolders = /* @__PURE__ */ new Set();
-    for (const itemPath of paths) {
+  } catch {
+    return jsonResponse({ error: "Invalid request body" }, { status: 400 });
+  }
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      };
       try {
-        if (!itemPath.startsWith("public/")) {
-          errors.push(`Invalid path: ${itemPath}`);
-          continue;
-        }
-        const absolutePath = getWorkspacePath(itemPath);
-        const imageKey = "/" + itemPath.replace(/^public\//, "");
-        sourceFolders.add(path6.dirname(absolutePath));
-        const entry = meta[imageKey];
-        const isPushedToCloud = entry?.c !== void 0;
-        const hasThumbnails = entry ? isProcessed(entry) : false;
-        try {
-          const stats = await fs6.stat(absolutePath);
-          if (stats.isDirectory()) {
-            await fs6.rm(absolutePath, { recursive: true });
-            const prefix = imageKey + "/";
-            for (const key of Object.keys(meta)) {
-              if (key.startsWith(prefix) || key === imageKey) {
-                const keyEntry = meta[key];
-                const keyHasThumbnails = keyEntry ? isProcessed(keyEntry) : false;
-                if (keyEntry?.c !== void 0) {
-                  try {
-                    await deleteFromCdn(key, keyHasThumbnails);
-                  } catch {
-                  }
-                } else {
-                  for (const thumbPath of getAllThumbnailPaths(key)) {
-                    const absoluteThumbPath = getPublicPath(thumbPath);
-                    try {
-                      await fs6.unlink(absoluteThumbPath);
-                    } catch {
-                    }
-                  }
-                }
-                delete meta[key];
-              }
-            }
-          } else {
-            await fs6.unlink(absolutePath);
-            const isInImagesFolder = itemPath.startsWith("public/images/");
-            if (!isInImagesFolder && entry) {
-              if (isPushedToCloud) {
-                try {
-                  await deleteFromCdn(imageKey, hasThumbnails);
-                } catch {
-                }
-              } else {
-                for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-                  const absoluteThumbPath = getPublicPath(thumbPath);
-                  try {
-                    await fs6.unlink(absoluteThumbPath);
-                  } catch {
-                  }
-                }
-              }
-              delete meta[imageKey];
-            }
-          }
-        } catch {
-          if (entry) {
-            if (isPushedToCloud) {
-              try {
-                await deleteFromCdn(imageKey, hasThumbnails);
-              } catch {
-              }
-            }
-            delete meta[imageKey];
-          } else {
-            const prefix = imageKey + "/";
-            let foundAny = false;
-            for (const key of Object.keys(meta)) {
-              if (key.startsWith(prefix)) {
-                const keyEntry = meta[key];
-                const keyHasThumbnails = keyEntry ? isProcessed(keyEntry) : false;
-                if (keyEntry?.c !== void 0) {
-                  try {
-                    await deleteFromCdn(key, keyHasThumbnails);
-                  } catch {
-                  }
-                }
-                delete meta[key];
-                foundAny = true;
-              }
+        const meta = await loadMeta();
+        const cdnUrls = getCdnUrls(meta);
+        const removed = [];
+        const skipped = [];
+        const errors = [];
+        const total = imageKeys.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < imageKeys.length; i++) {
+          let imageKey = imageKeys[i];
+          if (!imageKey.startsWith("/")) {
+            imageKey = `/${imageKey}`;
+          }
+          try {
+            const entry = getMetaEntry(meta, imageKey);
+            if (!entry) {
+              errors.push(imageKey);
+              sendEvent({
+                type: "progress",
+                current: i + 1,
+                total,
+                processed: removed.length,
+                percent: Math.round((i + 1) / total * 100),
+                message: `Error: ${imageKey.slice(1)}`
+              });
+              continue;
             }
-            if (!foundAny) {
-              errors.push(`Not found: ${itemPath}`);
+            const hasThumbnails = entry.sm || entry.md || entry.lg || entry.f;
+            if (!hasThumbnails) {
+              skipped.push(imageKey);
+              sendEvent({
+                type: "progress",
+                current: i + 1,
+                total,
+                processed: removed.length,
+                percent: Math.round((i + 1) / total * 100),
+                message: `Skipped ${imageKey.slice(1)} (no thumbnails)`
+              });
               continue;
             }
+            const existingCdnIndex = entry.c;
+            const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
+            const isInOurR2 = existingCdnUrl === publicUrl;
+            await deleteLocalThumbnails(imageKey);
+            if (isInOurR2) {
+              await deleteThumbnailsFromCdn(imageKey);
+            }
+            meta[imageKey] = {
+              o: entry.o,
+              b: entry.b,
+              ...entry.c !== void 0 ? { c: entry.c } : {}
+            };
+            removed.push(imageKey);
+            sendEvent({
+              type: "progress",
+              current: i + 1,
+              total,
+              processed: removed.length,
+              percent: Math.round((i + 1) / total * 100),
+              message: `Removed thumbnails for ${imageKey.slice(1)}`
+            });
+          } catch (error) {
+            console.error(`Failed to unprocess ${imageKey}:`, error);
+            errors.push(imageKey);
+            sendEvent({
+              type: "progress",
+              current: i + 1,
+              total,
+              processed: removed.length,
+              percent: Math.round((i + 1) / total * 100),
+              message: `Failed: ${imageKey.slice(1)}`
+            });
           }
         }
-        deleted.push(itemPath);
-      } catch (error) {
-        console.error(`Failed to delete ${itemPath}:`, error);
-        errors.push(itemPath);
-      }
-    }
-    await saveMeta(meta);
-    for (const folder of sourceFolders) {
-      await deleteEmptyFolders(folder);
-    }
-    return jsonResponse({
-      success: true,
-      deleted,
-      errors: errors.length > 0 ? errors : void 0
-    });
-  } catch (error) {
-    console.error("Failed to delete:", error);
-    return jsonResponse({ error: "Failed to delete files" }, { status: 500 });
-  }
-}
-async function handleCreateFolder(request) {
-  try {
-    const { parentPath, name } = await request.json();
-    if (!name || typeof name !== "string") {
-      return jsonResponse({ error: "Folder name is required" }, { status: 400 });
-    }
-    const sanitizedName = slugifyFolderName(name);
-    if (!sanitizedName) {
-      return jsonResponse({ error: "Invalid folder name" }, { status: 400 });
-    }
-    const safePath = (parentPath || "public").replace(/\.\./g, "");
-    const folderPath = getWorkspacePath(safePath, sanitizedName);
-    if (!folderPath.startsWith(getPublicPath())) {
-      return jsonResponse({ error: "Invalid path" }, { status: 400 });
-    }
-    try {
-      await fs6.access(folderPath);
-      return jsonResponse({ error: "A folder with this name already exists" }, { status: 400 });
-    } catch {
-    }
-    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 });
-  }
-}
-async function handleRename(request) {
-  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "");
-  try {
-    const { oldPath, newName } = await request.json();
-    if (!oldPath || !newName) {
-      return jsonResponse({ error: "Path and new name are required" }, { status: 400 });
-    }
-    const safePath = oldPath.replace(/\.\./g, "");
-    const absoluteOldPath = getWorkspacePath(safePath);
-    if (!absoluteOldPath.startsWith(getPublicPath())) {
-      return jsonResponse({ error: "Invalid path" }, { status: 400 });
-    }
-    const oldRelativePath = safePath.replace(/^public\//, "");
-    const oldKey = "/" + oldRelativePath;
-    const isImage = isImageFile(path6.basename(oldPath));
-    const meta = await loadMeta();
-    const cdnUrls = getCdnUrls(meta);
-    const entry = meta[oldKey];
-    const isInCloud = entry?.c !== void 0;
-    const fileCdnUrl = isInCloud && entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
-    const isInOurR2 = isInCloud && fileCdnUrl === publicUrl;
-    const hasThumbnails = entry ? isProcessed(entry) : false;
-    let hasLocalFile = false;
-    let isFile = true;
-    try {
-      const stats = await fs6.stat(absoluteOldPath);
-      hasLocalFile = true;
-      isFile = stats.isFile();
-    } catch {
-      if (!isInCloud) {
-        return jsonResponse({ error: "File or folder not found" }, { status: 404 });
-      }
-    }
-    const sanitizedName = isFile ? slugifyFilename(newName) : slugifyFolderName(newName);
-    if (!sanitizedName) {
-      return jsonResponse({ error: "Invalid name" }, { status: 400 });
-    }
-    const parentDir = path6.dirname(absoluteOldPath);
-    const absoluteNewPath = path6.join(parentDir, sanitizedName);
-    const newRelativePath = path6.join(path6.dirname(oldRelativePath), sanitizedName);
-    const newKey = "/" + newRelativePath;
-    if (meta[newKey]) {
-      return jsonResponse({ error: "An item with this name already exists" }, { status: 400 });
-    }
-    try {
-      await fs6.access(absoluteNewPath);
-      return jsonResponse({ error: "An item with this name already exists" }, { status: 400 });
-    } catch {
-    }
-    if (isInOurR2 && !hasLocalFile && isImage) {
-      await moveInCdn(oldKey, newKey, hasThumbnails);
-      delete meta[oldKey];
-      meta[newKey] = entry;
-      await saveMeta(meta);
-      const newPath2 = path6.join(path6.dirname(safePath), sanitizedName);
-      return jsonResponse({ success: true, newPath: newPath2 });
-    }
-    if (hasLocalFile) {
-      await fs6.rename(absoluteOldPath, absoluteNewPath);
-    }
-    if (isImage && entry) {
-      const oldThumbPaths = getAllThumbnailPaths(oldKey);
-      const newThumbPaths = getAllThumbnailPaths(newKey);
-      for (let i = 0; i < oldThumbPaths.length; i++) {
-        const oldThumbPath = getPublicPath(oldThumbPaths[i]);
-        const newThumbPath = getPublicPath(newThumbPaths[i]);
-        await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
+        sendEvent({ type: "cleanup", message: "Saving metadata..." });
+        await saveMeta(meta);
+        sendEvent({ type: "cleanup", message: "Cleaning up empty folders..." });
+        const imagesDir = getPublicPath("images");
         try {
-          await fs6.rename(oldThumbPath, newThumbPath);
+          await cleanupEmptyFoldersRecursive(imagesDir);
         } catch {
         }
-      }
-      if (isInOurR2) {
-        await moveInCdn(oldKey, newKey, hasThumbnails);
-        try {
-          await fs6.unlink(absoluteNewPath);
-        } catch {
+        let message = `Removed thumbnails from ${removed.length} image${removed.length !== 1 ? "s" : ""}.`;
+        if (skipped.length > 0) {
+          message += ` ${skipped.length} image${skipped.length !== 1 ? "s" : ""} had no thumbnails.`;
         }
-        await deleteLocalThumbnails(newKey);
+        if (errors.length > 0) {
+          message += ` ${errors.length} image${errors.length !== 1 ? "s" : ""} failed.`;
+        }
+        sendEvent({
+          type: "complete",
+          processed: removed.length,
+          skipped: skipped.length,
+          errors: errors.length,
+          message
+        });
+        controller.close();
+      } catch (error) {
+        console.error("Unprocess stream error:", error);
+        sendEvent({ type: "error", message: "Failed to remove thumbnails" });
+        controller.close();
       }
-      delete meta[oldKey];
-      meta[newKey] = entry;
-      await saveMeta(meta);
     }
-    const newPath = path6.join(path6.dirname(safePath), sanitizedName);
-    return jsonResponse({ success: true, newPath });
-  } catch (error) {
-    console.error("Failed to rename:", error);
-    return jsonResponse({ error: "Failed to rename" }, { status: 500 });
-  }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
 }
-async function handleRenameStream(request) {
+async function handleReprocessStream(request) {
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
   const encoder = new TextEncoder();
-  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "");
+  let imageKeys;
+  try {
+    const body = await request.json();
+    imageKeys = body.imageKeys;
+    if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
+      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
+    }
+  } catch {
+    return jsonResponse({ error: "Invalid request body" }, { status: 400 });
+  }
   const stream = new ReadableStream({
     async start(controller) {
       const sendEvent = (data) => {
@@ -1413,642 +1377,239 @@ async function handleRenameStream(request) {
 `));
       };
       try {
-        const { oldPath, newName } = await request.json();
-        if (!oldPath || !newName) {
-          sendEvent({ type: "error", message: "Path and new name are required" });
-          controller.close();
-          return;
-        }
-        const safePath = oldPath.replace(/\.\./g, "");
-        const absoluteOldPath = getWorkspacePath(safePath);
-        if (!absoluteOldPath.startsWith(getPublicPath())) {
-          sendEvent({ type: "error", message: "Invalid path" });
-          controller.close();
-          return;
-        }
-        const oldRelativePath = safePath.replace(/^public\//, "");
-        const isImagePath = isImageFile(path6.basename(oldPath));
-        let hasLocalItem = false;
-        let isFile = true;
-        let isVirtualFolder = false;
-        try {
-          const stats = await fs6.stat(absoluteOldPath);
-          hasLocalItem = true;
-          isFile = stats.isFile();
-        } catch {
-          const meta2 = await loadMeta();
-          const oldKey2 = "/" + oldRelativePath;
-          const entry2 = meta2[oldKey2];
-          if (entry2) {
-            isFile = true;
-          } else {
-            const folderPrefix = oldKey2 + "/";
-            const hasChildrenInMeta = Object.keys(meta2).some((key) => key.startsWith(folderPrefix));
-            if (hasChildrenInMeta) {
-              isFile = false;
-              isVirtualFolder = true;
-            } else {
-              sendEvent({ type: "error", message: "File or folder not found" });
-              controller.close();
-              return;
-            }
-          }
-        }
-        const sanitizedName = isFile ? slugifyFilename(newName) : slugifyFolderName(newName);
-        if (!sanitizedName) {
-          sendEvent({ type: "error", message: "Invalid name" });
-          controller.close();
-          return;
-        }
-        const parentDir = path6.dirname(absoluteOldPath);
-        const absoluteNewPath = path6.join(parentDir, sanitizedName);
-        const newRelativePath = path6.join(path6.dirname(oldRelativePath), sanitizedName);
-        const newPath = path6.join(path6.dirname(safePath), sanitizedName);
         const meta = await loadMeta();
         const cdnUrls = getCdnUrls(meta);
-        if (isFile) {
-          const newKey2 = "/" + newRelativePath;
-          if (meta[newKey2]) {
-            sendEvent({ type: "error", message: "An item with this name already exists" });
-            controller.close();
-            return;
+        const processed = [];
+        const errors = [];
+        const total = imageKeys.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < imageKeys.length; i++) {
+          let imageKey = imageKeys[i];
+          if (!imageKey.startsWith("/")) {
+            imageKey = `/${imageKey}`;
           }
-        }
-        if (!isVirtualFolder) {
           try {
-            await fs6.access(absoluteNewPath);
-            sendEvent({ type: "error", message: "An item with this name already exists" });
-            controller.close();
-            return;
-          } catch {
-          }
-        }
-        if (isVirtualFolder) {
-          const newPrefix = "/" + newRelativePath + "/";
-          const hasConflict = Object.keys(meta).some((key) => key.startsWith(newPrefix));
-          if (hasConflict) {
-            sendEvent({ type: "error", message: "A folder with this name already exists" });
-            controller.close();
-            return;
-          }
-        }
-        if (!isFile) {
-          const oldPrefix = "/" + oldRelativePath + "/";
-          const newPrefix = "/" + newRelativePath + "/";
-          const itemsToUpdate = [];
-          for (const [key, entry2] of Object.entries(meta)) {
-            if (key.startsWith(oldPrefix) && entry2 && typeof entry2 === "object") {
-              const newKey2 = key.replace(oldPrefix, newPrefix);
-              itemsToUpdate.push({ oldKey: key, newKey: newKey2, entry: entry2 });
-            }
-          }
-          const total = itemsToUpdate.length + 1;
-          sendEvent({ type: "start", total, message: `Renaming folder with ${itemsToUpdate.length} item(s)...` });
-          if (hasLocalItem) {
-            await fs6.rename(absoluteOldPath, absoluteNewPath);
-            const imagesDir = getPublicPath("/images");
-            const oldThumbFolder2 = path6.join(imagesDir, oldRelativePath);
-            const newThumbFolder = path6.join(imagesDir, newRelativePath);
+            let buffer;
+            const entry = getMetaEntry(meta, imageKey);
+            const existingCdnIndex = entry?.c;
+            const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
+            const isInOurR2 = existingCdnUrl === publicUrl;
+            const isRemote = existingCdnIndex !== void 0 && !isInOurR2;
+            const originalPath = getPublicPath(imageKey);
             try {
-              await fs6.access(oldThumbFolder2);
-              await fs6.mkdir(path6.dirname(newThumbFolder), { recursive: true });
-              await fs6.rename(oldThumbFolder2, newThumbFolder);
+              buffer = await fs6.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);
+              } 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);
+              } else {
+                throw new Error(`File not found: ${imageKey}`);
+              }
             }
-          }
-          sendEvent({ type: "progress", current: 1, total, renamed: 1, message: "Renamed folder" });
-          let renamed = 1;
-          for (const item of itemsToUpdate) {
-            const { oldKey: oldKey2, newKey: newKey2, entry: entry2 } = item;
-            const isInCloud2 = entry2.c !== void 0;
-            const fileCdnUrl2 = isInCloud2 ? cdnUrls[entry2.c] : void 0;
-            const isInOurR22 = isInCloud2 && fileCdnUrl2 === publicUrl;
-            const hasThumbnails2 = isProcessed(entry2);
-            if (isInOurR22) {
-              try {
-                await moveInCdn(oldKey2, newKey2, hasThumbnails2);
-                const localFilePath = getPublicPath(newKey2);
+            const ext = path6.extname(imageKey).toLowerCase();
+            const isSvg = ext === ".svg";
+            if (isSvg) {
+              const imageDir = path6.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);
+              meta[imageKey] = {
+                ...entry,
+                o: { w: 0, h: 0 },
+                b: "",
+                f: { w: 0, h: 0 }
+              };
+              if (isRemote) {
+                delete meta[imageKey].c;
+              }
+            } else {
+              const updatedEntry = await processImage(buffer, imageKey);
+              if (isInOurR2) {
+                updatedEntry.c = existingCdnIndex;
+                await deleteOriginalFromCdn(imageKey);
+                await deleteThumbnailsFromCdn(imageKey);
+                await uploadOriginalToCdn(imageKey);
+                await uploadToCdn(imageKey);
+                await deleteLocalThumbnails(imageKey);
                 try {
-                  await fs6.unlink(localFilePath);
+                  await fs6.unlink(originalPath);
                 } catch {
                 }
-                if (hasThumbnails2) {
-                  await deleteLocalThumbnails(newKey2);
-                }
-              } catch (err) {
-                console.error(`Failed to rename in CDN ${oldKey2}:`, err);
               }
+              meta[imageKey] = updatedEntry;
             }
-            delete meta[oldKey2];
-            meta[newKey2] = entry2;
-            renamed++;
+            processed.push(imageKey);
             sendEvent({
               type: "progress",
-              current: renamed,
+              current: i + 1,
               total,
-              renamed,
-              message: `Renamed ${path6.basename(newKey2)}`
+              processed: processed.length,
+              percent: Math.round((i + 1) / total * 100),
+              message: `Processed ${imageKey.slice(1)}`
+            });
+          } catch (error) {
+            console.error(`Failed to reprocess ${imageKey}:`, error);
+            errors.push(imageKey);
+            sendEvent({
+              type: "progress",
+              current: i + 1,
+              total,
+              processed: processed.length,
+              percent: Math.round((i + 1) / total * 100),
+              message: `Failed: ${imageKey.slice(1)}`
             });
           }
-          await saveMeta(meta);
-          await deleteEmptyFolders(absoluteOldPath);
-          const oldThumbFolder = path6.join(getPublicPath("/images"), oldRelativePath);
-          await deleteEmptyFolders(oldThumbFolder);
-          sendEvent({ type: "complete", renamed, newPath });
-          controller.close();
-          return;
-        }
-        const oldKey = "/" + oldRelativePath;
-        const newKey = "/" + newRelativePath;
-        const entry = meta[oldKey];
-        const isInCloud = entry?.c !== void 0;
-        const fileCdnUrl = isInCloud && entry?.c !== void 0 ? cdnUrls[entry.c] : void 0;
-        const isInOurR2 = isInCloud && fileCdnUrl === publicUrl;
-        const hasThumbnails = entry ? isProcessed(entry) : false;
-        sendEvent({ type: "start", total: 1, message: "Renaming file..." });
-        if (isInOurR2 && !hasLocalItem && isImagePath) {
-          await moveInCdn(oldKey, newKey, hasThumbnails);
-          delete meta[oldKey];
-          if (entry) meta[newKey] = entry;
-          await saveMeta(meta);
-          sendEvent({ type: "complete", renamed: 1, newPath });
-          controller.close();
-          return;
         }
-        if (hasLocalItem) {
-          await fs6.rename(absoluteOldPath, absoluteNewPath);
-        }
-        if (isImagePath && entry) {
-          const oldThumbPaths = getAllThumbnailPaths(oldKey);
-          const newThumbPaths = getAllThumbnailPaths(newKey);
-          for (let i = 0; i < oldThumbPaths.length; i++) {
-            const oldThumbPath = getPublicPath(oldThumbPaths[i]);
-            const newThumbPath = getPublicPath(newThumbPaths[i]);
-            await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
-            try {
-              await fs6.rename(oldThumbPath, newThumbPath);
-            } catch {
-            }
-          }
-          if (isInOurR2) {
-            await moveInCdn(oldKey, newKey, hasThumbnails);
-            try {
-              await fs6.unlink(absoluteNewPath);
-            } catch {
-            }
-            await deleteLocalThumbnails(newKey);
-          }
-          delete meta[oldKey];
-          meta[newKey] = entry;
-          await saveMeta(meta);
+        sendEvent({ type: "cleanup", message: "Saving metadata..." });
+        await saveMeta(meta);
+        let message = `Generated thumbnails for ${processed.length} image${processed.length !== 1 ? "s" : ""}.`;
+        if (errors.length > 0) {
+          message += ` ${errors.length} image${errors.length !== 1 ? "s" : ""} failed.`;
         }
-        sendEvent({ type: "complete", renamed: 1, newPath });
+        sendEvent({
+          type: "complete",
+          processed: processed.length,
+          errors: errors.length,
+          message
+        });
         controller.close();
       } catch (error) {
-        console.error("Rename stream error:", error);
-        sendEvent({ type: "error", message: "Failed to rename" });
+        console.error("Reprocess stream error:", error);
+        sendEvent({ type: "error", message: "Failed to generate thumbnails" });
         controller.close();
       }
     }
   });
-  return streamResponse(stream);
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
 }
-async function handleMoveStream(request) {
-  const encoder = new TextEncoder();
+async function handleDownloadStream(request) {
+  const { imageKeys, operationId } = await request.json();
+  if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
+    return jsonResponse({ error: "No image keys provided" }, { status: 400 });
+  }
   const stream = new ReadableStream({
     async start(controller) {
+      const encoder = new TextEncoder();
       const sendEvent = (data) => {
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
 
 `));
+        } catch {
+        }
       };
+      sendEvent({ type: "start", total: imageKeys.length });
+      const downloaded = [];
+      const skipped = [];
+      const errors = [];
+      const isCancelled = () => operationId ? isOperationCancelled(operationId) : false;
       try {
-        const { paths, destination } = await request.json();
-        if (!paths || !Array.isArray(paths) || paths.length === 0) {
-          sendEvent({ type: "error", message: "Paths are required" });
-          controller.close();
-          return;
-        }
-        if (!destination || typeof destination !== "string") {
-          sendEvent({ type: "error", message: "Destination is required" });
-          controller.close();
-          return;
-        }
-        const safeDestination = destination.replace(/\.\./g, "");
-        const absoluteDestination = getWorkspacePath(safeDestination);
-        if (!absoluteDestination.startsWith(getPublicPath())) {
-          sendEvent({ type: "error", message: "Invalid destination" });
-          controller.close();
-          return;
-        }
-        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();
-        let totalFiles = 0;
-        const expandedItems = [];
-        for (const itemPath of paths) {
-          const safePath = itemPath.replace(/\.\./g, "");
-          const itemName = path6.basename(safePath);
-          const oldRelativePath = safePath.replace(/^public\/?/, "");
-          const destWithoutPublic = safeDestination.replace(/^public\/?/, "");
-          const newRelativePath = destWithoutPublic ? path6.join(destWithoutPublic, itemName) : itemName;
-          const oldKey = "/" + oldRelativePath;
-          const newKey = "/" + newRelativePath;
-          const newAbsolutePath = path6.join(absoluteDestination, itemName);
-          const absolutePath = getWorkspacePath(safePath);
-          let hasLocalItem = false;
-          let isDirectory = false;
-          try {
-            const stats = await fs6.stat(absolutePath);
-            hasLocalItem = true;
-            isDirectory = stats.isDirectory();
-          } catch {
-          }
-          if (hasLocalItem && isDirectory) {
-            const countFilesRecursive = async (dir) => {
-              let count = 0;
-              const entries = await fs6.readdir(dir, { withFileTypes: true });
-              for (const entry of entries) {
-                if (entry.isDirectory()) {
-                  count += await countFilesRecursive(path6.join(dir, entry.name));
-                } else {
-                  count++;
-                }
-              }
-              return count;
-            };
-            const localFileCount = await countFilesRecursive(absolutePath);
-            const folderPrefix = oldKey + "/";
-            let cloudOnlyCount = 0;
-            for (const metaKey of Object.keys(meta)) {
-              if (metaKey.startsWith(folderPrefix)) {
-                const relPath = metaKey.slice(folderPrefix.length);
-                const localPath = path6.join(absolutePath, relPath);
-                try {
-                  await fs6.access(localPath);
-                } catch {
-                  cloudOnlyCount++;
-                }
-              }
-            }
-            totalFiles += localFileCount + cloudOnlyCount;
-            expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
-          } else if (!hasLocalItem) {
-            const folderPrefix = oldKey + "/";
-            const virtualItems = [];
-            for (const [key, metaEntry] of Object.entries(meta)) {
-              if (key.startsWith(folderPrefix) && metaEntry && typeof metaEntry === "object") {
-                const relativePath = key.slice(folderPrefix.length);
-                const destNewKey = newKey + "/" + relativePath;
-                virtualItems.push({ oldKey: key, newKey: destNewKey, entry: metaEntry });
-              }
-            }
-            if (virtualItems.length > 0) {
-              totalFiles += virtualItems.length;
-              expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: true, virtualFolderItems: virtualItems });
-              sourceFolders.add(absolutePath);
-            } else {
-              totalFiles++;
-              expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
-            }
-          } else {
-            totalFiles++;
-            expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
-          }
-        }
-        sendEvent({ type: "start", total: totalFiles });
-        let processedFiles = 0;
-        for (const expandedItem of expandedItems) {
-          const { itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder, virtualFolderItems } = expandedItem;
-          if (isVirtualFolder && virtualFolderItems) {
-            for (const vItem of virtualFolderItems) {
-              const itemEntry = vItem.entry;
-              const isItemInCloud = itemEntry.c !== void 0;
-              const itemCdnUrl = isItemInCloud ? cdnUrls[itemEntry.c] : void 0;
-              const isItemInR2 = isItemInCloud && itemCdnUrl === r2PublicUrl;
-              const itemHasThumbnails = isProcessed(itemEntry);
-              let vItemMoved = false;
-              if (isItemInR2) {
-                try {
-                  await moveInCdn(vItem.oldKey, vItem.newKey, itemHasThumbnails);
-                  vItemMoved = true;
-                } catch (err) {
-                  console.error(`Failed to move cloud item ${vItem.oldKey}:`, err);
-                  delete meta[vItem.oldKey];
-                }
-              }
-              if (vItemMoved) {
-                delete meta[vItem.oldKey];
-                meta[vItem.newKey] = itemEntry;
-              }
-              processedFiles++;
-              sendEvent({
-                type: "progress",
-                current: processedFiles,
-                total: totalFiles,
-                moved: moved.length,
-                percent: Math.round(processedFiles / totalFiles * 100),
-                currentFile: path6.basename(vItem.newKey)
-              });
-            }
-            const newFolderPath = getPublicPath(newKey);
-            await deleteEmptyFolders(newFolderPath);
-            const newThumbFolder = path6.join(getPublicPath("images"), newKey.slice(1));
-            await deleteEmptyFolders(newThumbFolder);
-            moved.push(itemPath);
-            continue;
+        for (let i = 0; i < imageKeys.length; i++) {
+          if (isCancelled()) {
+            await saveMeta(meta);
+            if (operationId) clearCancelledOperation(operationId);
+            sendEvent({
+              type: "stopped",
+              downloaded: downloaded.length,
+              message: `Stopped. ${downloaded.length} image${downloaded.length !== 1 ? "s" : ""} downloaded.`
+            });
+            controller.close();
+            return;
           }
-          if (meta[newKey]) {
-            errors.push(`${itemName} already exists in destination`);
-            processedFiles++;
+          const imageKey = imageKeys[i];
+          const entry = getMetaEntry(meta, imageKey);
+          if (!entry || entry.c === void 0) {
+            skipped.push(imageKey);
             sendEvent({
               type: "progress",
-              current: processedFiles,
-              total: totalFiles,
-              moved: moved.length,
-              percent: Math.round(processedFiles / totalFiles * 100),
-              currentFile: itemName
+              current: i + 1,
+              total: imageKeys.length,
+              downloaded: downloaded.length,
+              message: `Skipped ${imageKey} (not on cloud)`
             });
             continue;
           }
-          const entry = meta[oldKey];
-          const isImage = isImageFile(itemName);
-          const isInCloud = entry?.c !== void 0;
-          const fileCdnUrl = isInCloud && entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
-          const isRemote = isInCloud && (!r2PublicUrl || fileCdnUrl !== r2PublicUrl);
-          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 fs6.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
-              await fs6.writeFile(newAbsolutePath, buffer);
-              const newEntry = {
-                o: entry?.o,
-                b: entry?.b
-              };
-              delete meta[oldKey];
-              meta[newKey] = newEntry;
-              moved.push(itemPath);
-              processedFiles++;
-              sendEvent({
-                type: "progress",
-                current: processedFiles,
-                total: totalFiles,
-                moved: moved.length,
-                percent: Math.round(processedFiles / totalFiles * 100),
-                currentFile: itemName
-              });
-            } else if (isPushedToR2 && isImage) {
-              await moveInCdn(oldKey, newKey, hasProcessedThumbnails);
-              delete meta[oldKey];
-              if (entry) {
-                meta[newKey] = entry;
-              }
-              moved.push(itemPath);
-              processedFiles++;
+            const imageBuffer = await downloadFromCdn(imageKey);
+            if (isCancelled()) {
+              await saveMeta(meta);
+              if (operationId) clearCancelledOperation(operationId);
               sendEvent({
-                type: "progress",
-                current: processedFiles,
-                total: totalFiles,
-                moved: moved.length,
-                percent: Math.round(processedFiles / totalFiles * 100),
-                currentFile: itemName
+                type: "stopped",
+                downloaded: downloaded.length,
+                message: `Stopped. ${downloaded.length} image${downloaded.length !== 1 ? "s" : ""} downloaded.`
               });
-            } else {
-              const absolutePath = getWorkspacePath(safePath);
-              if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
-                errors.push(`Cannot move ${itemName} into itself`);
-                processedFiles++;
-                sendEvent({
-                  type: "progress",
-                  current: processedFiles,
-                  total: totalFiles,
-                  moved: moved.length,
-                  percent: Math.round(processedFiles / totalFiles * 100),
-                  currentFile: itemName
-                });
-                continue;
-              }
-              try {
-                await fs6.access(absolutePath);
-              } catch {
-                errors.push(`${itemName} not found`);
-                processedFiles++;
-                sendEvent({
-                  type: "progress",
-                  current: processedFiles,
-                  total: totalFiles,
-                  moved: moved.length,
-                  percent: Math.round(processedFiles / totalFiles * 100),
-                  currentFile: itemName
-                });
-                continue;
-              }
-              try {
-                await fs6.access(newAbsolutePath);
-                errors.push(`${itemName} already exists in destination`);
-                processedFiles++;
-                sendEvent({
-                  type: "progress",
-                  current: processedFiles,
-                  total: totalFiles,
-                  moved: moved.length,
-                  percent: Math.round(processedFiles / totalFiles * 100),
-                  currentFile: itemName
-                });
-                continue;
-              } catch {
-              }
-              const stats = await fs6.stat(absolutePath);
-              if (stats.isFile()) {
-                await fs6.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
-                await fs6.rename(absolutePath, newAbsolutePath);
-                if (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]);
-                    try {
-                      await fs6.access(oldThumbPath);
-                      sourceFolders.add(path6.dirname(oldThumbPath));
-                      await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
-                      await fs6.rename(oldThumbPath, newThumbPath);
-                    } catch {
-                    }
-                  }
-                  const fileIsInCloud = entry.c !== void 0;
-                  const fileCdnUrl2 = fileIsInCloud ? cdnUrls[entry.c] : void 0;
-                  const fileIsInR2 = fileIsInCloud && fileCdnUrl2 === r2PublicUrl;
-                  const fileHasThumbs = isProcessed(entry);
-                  if (fileIsInR2) {
-                    await deleteFromCdn(oldKey, fileHasThumbs);
-                    await uploadOriginalToCdn(newKey);
-                    if (fileHasThumbs) {
-                      await uploadToCdn(newKey);
-                    }
-                  }
-                  delete meta[oldKey];
-                  meta[newKey] = entry;
-                }
-                processedFiles++;
-                sendEvent({
-                  type: "progress",
-                  current: processedFiles,
-                  total: totalFiles,
-                  moved: moved.length,
-                  percent: Math.round(processedFiles / totalFiles * 100),
-                  currentFile: itemName
-                });
-                moved.push(itemPath);
-              } else if (stats.isDirectory()) {
-                const oldPrefix = oldKey + "/";
-                const newPrefix = newKey + "/";
-                const localFiles = [];
-                const collectLocalFiles = async (dir, relativeDir) => {
-                  const entries = await fs6.readdir(dir, { withFileTypes: true });
-                  for (const dirEntry of entries) {
-                    const entryRelPath = relativeDir ? `${relativeDir}/${dirEntry.name}` : dirEntry.name;
-                    if (dirEntry.isDirectory()) {
-                      await collectLocalFiles(path6.join(dir, dirEntry.name), entryRelPath);
-                    } else {
-                      localFiles.push({ relativePath: entryRelPath, isImage: isImageFile(dirEntry.name) });
-                    }
-                  }
-                };
-                await collectLocalFiles(absolutePath, "");
-                const cloudOnlyFiles = [];
-                for (const [metaKey, metaEntry] of Object.entries(meta)) {
-                  if (metaKey.startsWith(oldPrefix) && metaEntry && typeof metaEntry === "object") {
-                    const relPath = metaKey.slice(oldPrefix.length);
-                    const localPath = path6.join(absolutePath, relPath);
-                    try {
-                      await fs6.access(localPath);
-                    } catch {
-                      cloudOnlyFiles.push({
-                        oldKey: metaKey,
-                        newKey: newPrefix + relPath,
-                        entry: metaEntry
-                      });
-                    }
-                  }
-                }
-                for (const localFile of localFiles) {
-                  const fileOldPath = path6.join(absolutePath, localFile.relativePath);
-                  const fileNewPath = path6.join(newAbsolutePath, localFile.relativePath);
-                  const fileOldKey = oldPrefix + localFile.relativePath;
-                  const fileNewKey = newPrefix + localFile.relativePath;
-                  const fileEntry = meta[fileOldKey];
-                  sourceFolders.add(path6.dirname(fileOldPath));
-                  await fs6.mkdir(path6.dirname(fileNewPath), { recursive: true });
-                  await fs6.rename(fileOldPath, fileNewPath);
-                  if (localFile.isImage && fileEntry) {
-                    const oldThumbPaths = getAllThumbnailPaths(fileOldKey);
-                    const newThumbPaths = getAllThumbnailPaths(fileNewKey);
-                    for (let t = 0; t < oldThumbPaths.length; t++) {
-                      const oldThumbPath = getPublicPath(oldThumbPaths[t]);
-                      const newThumbPath = getPublicPath(newThumbPaths[t]);
-                      try {
-                        await fs6.access(oldThumbPath);
-                        sourceFolders.add(path6.dirname(oldThumbPath));
-                        await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
-                        await fs6.rename(oldThumbPath, newThumbPath);
-                      } catch {
-                      }
-                    }
-                    const fileIsInCloud = fileEntry.c !== void 0;
-                    const fileCdnUrl2 = fileIsInCloud ? cdnUrls[fileEntry.c] : void 0;
-                    const fileIsInR2 = fileIsInCloud && fileCdnUrl2 === r2PublicUrl;
-                    const fileHasThumbs = isProcessed(fileEntry);
-                    if (fileIsInR2) {
-                      await moveInCdn(fileOldKey, fileNewKey, fileHasThumbs);
-                    }
-                    delete meta[fileOldKey];
-                    meta[fileNewKey] = fileEntry;
-                  }
-                  processedFiles++;
-                  sendEvent({
-                    type: "progress",
-                    current: processedFiles,
-                    total: totalFiles,
-                    moved: moved.length,
-                    percent: Math.round(processedFiles / totalFiles * 100),
-                    currentFile: path6.basename(localFile.relativePath)
-                  });
-                }
-                for (const cloudFile of cloudOnlyFiles) {
-                  const cloudEntry = cloudFile.entry;
-                  const cloudIsInCloud = cloudEntry.c !== void 0;
-                  const cloudCdnUrl = cloudIsInCloud ? cdnUrls[cloudEntry.c] : void 0;
-                  const cloudIsInR2 = cloudIsInCloud && cloudCdnUrl === r2PublicUrl;
-                  const cloudHasThumbs = isProcessed(cloudEntry);
-                  let cloudFileMoved = false;
-                  if (cloudIsInR2) {
-                    try {
-                      await moveInCdn(cloudFile.oldKey, cloudFile.newKey, cloudHasThumbs);
-                      cloudFileMoved = true;
-                    } catch (err) {
-                      console.error(`Failed to move cloud file ${cloudFile.oldKey}:`, err);
-                      delete meta[cloudFile.oldKey];
-                    }
-                  }
-                  if (cloudFileMoved) {
-                    delete meta[cloudFile.oldKey];
-                    meta[cloudFile.newKey] = cloudEntry;
-                  }
-                  processedFiles++;
-                  sendEvent({
-                    type: "progress",
-                    current: processedFiles,
-                    total: totalFiles,
-                    moved: moved.length,
-                    percent: Math.round(processedFiles / totalFiles * 100),
-                    currentFile: path6.basename(cloudFile.newKey)
-                  });
-                }
-                sourceFolders.add(absolutePath);
-                const oldThumbRelPath = oldKey.slice(1);
-                const oldThumbFolder = path6.join(getPublicPath("images"), oldThumbRelPath);
-                sourceFolders.add(oldThumbFolder);
-                moved.push(itemPath);
-              }
+              controller.close();
+              return;
+            }
+            const localPath = getPublicPath(imageKey.replace(/^\//, ""));
+            await fs6.mkdir(path6.dirname(localPath), { recursive: true });
+            await fs6.writeFile(localPath, imageBuffer);
+            await deleteThumbnailsFromCdn(imageKey);
+            const wasProcessed = isProcessed(entry);
+            delete entry.c;
+            if (wasProcessed) {
+              const processedEntry = await processImage(imageBuffer, imageKey);
+              entry.sm = processedEntry.sm;
+              entry.md = processedEntry.md;
+              entry.lg = processedEntry.lg;
+              entry.f = processedEntry.f;
             }
-          } catch (err) {
-            console.error(`Failed to move ${itemName}:`, err);
-            errors.push(`Failed to move ${itemName}`);
-            processedFiles++;
+            downloaded.push(imageKey);
             sendEvent({
               type: "progress",
-              current: processedFiles,
-              total: totalFiles,
-              moved: moved.length,
-              percent: Math.round(processedFiles / totalFiles * 100),
-              currentFile: itemName
+              current: i + 1,
+              total: imageKeys.length,
+              downloaded: downloaded.length,
+              message: `Downloaded ${imageKey}`
+            });
+          } catch (error) {
+            console.error(`Failed to download ${imageKey}:`, error);
+            errors.push(imageKey);
+            sendEvent({
+              type: "progress",
+              current: i + 1,
+              total: imageKeys.length,
+              downloaded: downloaded.length,
+              message: `Failed to download ${imageKey}`
             });
           }
         }
         await saveMeta(meta);
-        for (const folder of sourceFolders) {
-          await deleteEmptyFolders(folder);
+        let message = `Downloaded ${downloaded.length} image${downloaded.length !== 1 ? "s" : ""}.`;
+        if (skipped.length > 0) {
+          message += ` ${skipped.length} image${skipped.length !== 1 ? "s were" : " was"} not on cloud.`;
+        }
+        if (errors.length > 0) {
+          message += ` ${errors.length} image${errors.length !== 1 ? "s" : ""} failed.`;
         }
-        await deleteEmptyFolders(absoluteDestination);
         sendEvent({
           type: "complete",
-          moved: moved.length,
+          downloaded: downloaded.length,
+          skipped: skipped.length,
           errors: errors.length,
-          errorMessages: errors
+          message
         });
       } catch (error) {
-        console.error("Failed to move:", error);
-        sendEvent({ type: "error", message: "Failed to move items" });
+        console.error("Download stream error:", error);
+        sendEvent({ type: "error", message: "Failed to download images" });
       } finally {
         controller.close();
       }
@@ -2062,157 +1623,13 @@ async function handleMoveStream(request) {
     }
   });
 }
-
-// src/handlers/images.ts
-import { promises as fs7 } from "fs";
-import path7 from "path";
-import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2, DeleteObjectCommand as DeleteObjectCommand2 } from "@aws-sdk/client-s3";
-var cancelledOperations = /* @__PURE__ */ new Set();
-function cancelOperation(operationId) {
-  cancelledOperations.add(operationId);
-  setTimeout(() => cancelledOperations.delete(operationId), 6e4);
-}
-function isOperationCancelled(operationId) {
-  return cancelledOperations.has(operationId);
-}
-function clearCancelledOperation(operationId) {
-  cancelledOperations.delete(operationId);
-}
-async function handleSync(request) {
+async function handlePushUpdatesStream(request) {
   const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
   const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
   const secretAccessKey = process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY;
   const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
-  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
-  if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
-    return jsonResponse(
-      { error: "R2 not configured. Set CLOUDFLARE_R2_* environment variables." },
-      { status: 400 }
-    );
-  }
-  try {
-    const { imageKeys } = await request.json();
-    if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
-      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
-    }
-    const meta = await loadMeta();
-    const cdnUrls = getCdnUrls(meta);
-    const cdnIndex = getOrAddCdnIndex(meta, publicUrl);
-    const r2 = new S3Client2({
-      region: "auto",
-      endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
-      credentials: { accessKeyId, secretAccessKey }
-    });
-    const pushed = [];
-    const alreadyPushed = [];
-    const errors = [];
-    const sourceFolders = /* @__PURE__ */ new Set();
-    for (let imageKey of imageKeys) {
-      if (!imageKey.startsWith("/")) {
-        imageKey = `/${imageKey}`;
-      }
-      const entry = getMetaEntry(meta, imageKey);
-      if (!entry) {
-        errors.push(`Image not found in meta: ${imageKey}. Run Scan first.`);
-        continue;
-      }
-      const existingCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
-      const isAlreadyInOurR2 = existingCdnUrl === publicUrl;
-      if (isAlreadyInOurR2) {
-        alreadyPushed.push(imageKey);
-        continue;
-      }
-      const isRemote = entry.c !== void 0 && existingCdnUrl !== publicUrl;
-      try {
-        let originalBuffer;
-        if (isRemote) {
-          const remoteUrl = `${existingCdnUrl}${imageKey}`;
-          originalBuffer = await downloadFromRemoteUrl(remoteUrl);
-        } else {
-          const originalLocalPath = getPublicPath(imageKey);
-          try {
-            originalBuffer = await fs7.readFile(originalLocalPath);
-          } catch {
-            errors.push(`Original file not found: ${imageKey}`);
-            continue;
-          }
-        }
-        await r2.send(
-          new PutObjectCommand2({
-            Bucket: bucketName,
-            Key: imageKey.replace(/^\//, ""),
-            Body: originalBuffer,
-            ContentType: getContentType(imageKey)
-          })
-        );
-        if (!isRemote && isProcessed(entry)) {
-          for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-            const localPath = getPublicPath(thumbPath);
-            try {
-              const fileBuffer = await fs7.readFile(localPath);
-              await r2.send(
-                new PutObjectCommand2({
-                  Bucket: bucketName,
-                  Key: thumbPath.replace(/^\//, ""),
-                  Body: fileBuffer,
-                  ContentType: getContentType(thumbPath)
-                })
-              );
-            } catch {
-            }
-          }
-        }
-        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 fs7.unlink(localPath);
-            } catch {
-            }
-          }
-          try {
-            await fs7.unlink(originalLocalPath);
-          } catch {
-          }
-        }
-        pushed.push(imageKey);
-      } catch (error) {
-        console.error(`Failed to push ${imageKey}:`, error);
-        errors.push(`Failed to push: ${imageKey}`);
-      }
-    }
-    await saveMeta(meta);
-    for (const folder of sourceFolders) {
-      await deleteEmptyFolders(folder);
-    }
-    return jsonResponse({
-      success: true,
-      pushed,
-      alreadyPushed: alreadyPushed.length > 0 ? alreadyPushed : void 0,
-      errors: errors.length > 0 ? errors : void 0
-    });
-  } catch (error) {
-    console.error("Failed to push:", error);
-    return jsonResponse({ error: "Failed to push to CDN" }, { status: 500 });
-  }
-}
-async function handleUnprocessStream(request) {
-  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "");
   const encoder = new TextEncoder();
-  let imageKeys;
-  try {
-    const body = await request.json();
-    imageKeys = body.imageKeys;
-    if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
-      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
-    }
-  } catch {
-    return jsonResponse({ error: "Invalid request body" }, { status: 400 });
-  }
   const stream = new ReadableStream({
     async start(controller) {
       const sendEvent = (data) => {
@@ -2221,105 +1638,133 @@ async function handleUnprocessStream(request) {
 `));
       };
       try {
+        if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
+          sendEvent({ type: "error", message: "R2 not configured" });
+          controller.close();
+          return;
+        }
+        const { paths } = await request.json();
+        if (!paths || !Array.isArray(paths) || paths.length === 0) {
+          sendEvent({ type: "error", message: "No paths provided" });
+          controller.close();
+          return;
+        }
+        const s3 = new S3Client2({
+          region: "auto",
+          endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+          credentials: { accessKeyId, secretAccessKey }
+        });
         const meta = await loadMeta();
         const cdnUrls = getCdnUrls(meta);
-        const removed = [];
+        const r2PublicUrl = publicUrl.replace(/\/$/, "");
+        const pushed = [];
         const skipped = [];
         const errors = [];
-        const total = imageKeys.length;
+        const total = paths.length;
         sendEvent({ type: "start", total });
-        for (let i = 0; i < imageKeys.length; i++) {
-          let imageKey = imageKeys[i];
-          if (!imageKey.startsWith("/")) {
-            imageKey = `/${imageKey}`;
+        for (let i = 0; i < paths.length; i++) {
+          const itemPath = paths[i];
+          const key = itemPath.startsWith("public/") ? "/" + itemPath.slice(7) : itemPath;
+          const entry = meta[key];
+          if (!entry || entry.u !== 1) {
+            skipped.push(key);
+            sendEvent({
+              type: "progress",
+              current: i + 1,
+              total,
+              pushed: pushed.length,
+              percent: Math.round((i + 1) / total * 100),
+              currentFile: path6.basename(key)
+            });
+            continue;
           }
-          try {
-            const entry = getMetaEntry(meta, imageKey);
-            if (!entry) {
-              errors.push(imageKey);
-              sendEvent({
-                type: "progress",
-                current: i + 1,
-                total,
-                processed: removed.length,
-                percent: Math.round((i + 1) / total * 100),
-                message: `Error: ${imageKey.slice(1)}`
-              });
-              continue;
-            }
-            const hasThumbnails = entry.sm || entry.md || entry.lg || entry.f;
-            if (!hasThumbnails) {
-              skipped.push(imageKey);
-              sendEvent({
-                type: "progress",
-                current: i + 1,
-                total,
-                processed: removed.length,
-                percent: Math.round((i + 1) / total * 100),
-                message: `Skipped ${imageKey.slice(1)} (no thumbnails)`
-              });
-              continue;
+          const fileCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c]?.replace(/\/$/, "") : void 0;
+          if (!fileCdnUrl || fileCdnUrl !== r2PublicUrl) {
+            skipped.push(key);
+            sendEvent({
+              type: "progress",
+              current: i + 1,
+              total,
+              pushed: pushed.length,
+              percent: Math.round((i + 1) / total * 100),
+              currentFile: path6.basename(key)
+            });
+            continue;
+          }
+          try {
+            const localPath = getPublicPath(key);
+            const buffer = await fs6.readFile(localPath);
+            const contentType = getContentType(path6.basename(key));
+            const uploadKey = key.startsWith("/") ? key.slice(1) : key;
+            try {
+              await s3.send(new DeleteObjectCommand2({
+                Bucket: bucketName,
+                Key: uploadKey
+              }));
+            } catch {
             }
-            const existingCdnIndex = entry.c;
-            const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
-            const isInOurR2 = existingCdnUrl === publicUrl;
-            await deleteLocalThumbnails(imageKey);
-            if (isInOurR2) {
-              await deleteThumbnailsFromCdn(imageKey);
+            await s3.send(new PutObjectCommand2({
+              Bucket: bucketName,
+              Key: uploadKey,
+              Body: buffer,
+              ContentType: contentType
+            }));
+            if (isProcessed(entry)) {
+              await deleteThumbnailsFromCdn(key);
+              const processedEntry = await processImage(buffer, key);
+              Object.assign(entry, processedEntry);
+              await uploadToCdn(key);
+              await deleteLocalThumbnails(key);
             }
-            meta[imageKey] = {
-              o: entry.o,
-              b: entry.b,
-              ...entry.c !== void 0 ? { c: entry.c } : {}
-            };
-            removed.push(imageKey);
+            await fs6.unlink(localPath);
+            delete entry.u;
+            pushed.push(key);
             sendEvent({
               type: "progress",
               current: i + 1,
               total,
-              processed: removed.length,
+              pushed: pushed.length,
               percent: Math.round((i + 1) / total * 100),
-              message: `Removed thumbnails for ${imageKey.slice(1)}`
+              currentFile: path6.basename(key)
             });
           } catch (error) {
-            console.error(`Failed to unprocess ${imageKey}:`, error);
-            errors.push(imageKey);
+            console.error(`Failed to push update for ${key}:`, error);
+            errors.push(key);
             sendEvent({
               type: "progress",
               current: i + 1,
               total,
-              processed: removed.length,
+              pushed: pushed.length,
               percent: Math.round((i + 1) / total * 100),
-              message: `Failed: ${imageKey.slice(1)}`
+              currentFile: path6.basename(key),
+              message: `Failed: ${path6.basename(key)}`
             });
           }
         }
-        sendEvent({ type: "cleanup", message: "Saving metadata..." });
-        await saveMeta(meta);
-        sendEvent({ type: "cleanup", message: "Cleaning up empty folders..." });
-        const imagesDir = getPublicPath("images");
-        try {
-          await cleanupEmptyFoldersRecursive(imagesDir);
-        } catch {
+        sendEvent({ type: "cleanup", message: "Cleaning up..." });
+        for (const itemPath of pushed) {
+          const localPath = getPublicPath(itemPath);
+          await deleteEmptyFolders(path6.dirname(localPath));
         }
-        let message = `Removed thumbnails from ${removed.length} image${removed.length !== 1 ? "s" : ""}.`;
+        await saveMeta(meta);
+        let message = `Pushed ${pushed.length} update${pushed.length !== 1 ? "s" : ""} to cloud.`;
         if (skipped.length > 0) {
-          message += ` ${skipped.length} image${skipped.length !== 1 ? "s" : ""} had no thumbnails.`;
+          message += ` ${skipped.length} file${skipped.length !== 1 ? "s" : ""} skipped.`;
         }
         if (errors.length > 0) {
-          message += ` ${errors.length} image${errors.length !== 1 ? "s" : ""} failed.`;
+          message += ` ${errors.length} file${errors.length !== 1 ? "s" : ""} failed.`;
         }
         sendEvent({
           type: "complete",
-          processed: removed.length,
+          pushed: pushed.length,
           skipped: skipped.length,
           errors: errors.length,
           message
         });
-        controller.close();
       } catch (error) {
-        console.error("Unprocess stream error:", error);
-        sendEvent({ type: "error", message: "Failed to remove thumbnails" });
+        console.error("Push updates error:", error);
+        sendEvent({ type: "error", message: "Failed to push updates" });
+      } finally {
         controller.close();
       }
     }
@@ -2328,283 +1773,602 @@ async function handleUnprocessStream(request) {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
-      Connection: "keep-alive"
+      "Connection": "keep-alive"
     }
   });
 }
-async function handleReprocessStream(request) {
-  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
-  const encoder = new TextEncoder();
-  let imageKeys;
+async function handleCancelStreamOperation(request) {
   try {
-    const body = await request.json();
-    imageKeys = body.imageKeys;
-    if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
-      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
+    const { operationId } = await request.json();
+    if (!operationId || typeof operationId !== "string") {
+      return jsonResponse({ error: "No operation ID provided" }, { status: 400 });
     }
-  } catch {
-    return jsonResponse({ error: "Invalid request body" }, { status: 400 });
+    cancelOperation(operationId);
+    return jsonResponse({ success: true, operationId });
+  } catch (error) {
+    console.error("Failed to cancel operation:", error);
+    return jsonResponse({ error: "Failed to cancel operation" }, { status: 500 });
   }
-  const stream = new ReadableStream({
-    async start(controller) {
-      const sendEvent = (data) => {
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+}
+async function handleCancelUpdates(request) {
+  try {
+    const { paths } = await request.json();
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return jsonResponse({ error: "No paths provided" }, { status: 400 });
+    }
+    const meta = await loadMeta();
+    const cancelled = [];
+    const skipped = [];
+    const errors = [];
+    const foldersToClean = /* @__PURE__ */ new Set();
+    for (const itemPath of paths) {
+      const key = itemPath.startsWith("public/") ? "/" + itemPath.slice(7) : itemPath;
+      const entry = meta[key];
+      if (!entry || entry.u !== 1) {
+        skipped.push(key);
+        continue;
+      }
+      try {
+        const localPath = getPublicPath(key);
+        await fs6.unlink(localPath);
+        foldersToClean.add(path6.dirname(localPath));
+        delete entry.u;
+        cancelled.push(key);
+      } catch (error) {
+        console.error(`Failed to cancel update for ${key}:`, error);
+        errors.push(key);
+      }
+    }
+    for (const folder of foldersToClean) {
+      await deleteEmptyFolders(folder);
+    }
+    await saveMeta(meta);
+    return jsonResponse({
+      success: true,
+      cancelled: cancelled.length,
+      skipped: skipped.length,
+      errors: errors.length
+    });
+  } catch (error) {
+    console.error("Cancel updates error:", error);
+    return jsonResponse({ error: "Failed to cancel updates" }, { status: 500 });
+  }
+}
 
-`));
-      };
+// src/handlers/files.ts
+async function handleUpload(request) {
+  try {
+    const formData = await request.formData();
+    const file = formData.get("file");
+    const targetPath = formData.get("path") || "public";
+    if (!file) {
+      return jsonResponse({ error: "No file provided" }, { status: 400 });
+    }
+    const bytes = await file.arrayBuffer();
+    const buffer = Buffer.from(bytes);
+    const fileName = slugifyFilename(file.name);
+    const ext = path7.extname(fileName).toLowerCase();
+    const isImage = isImageFile(fileName);
+    const isMedia = isMediaFile(fileName);
+    const meta = await loadMeta();
+    let relativeDir = "";
+    if (targetPath === "public") {
+      relativeDir = "";
+    } else if (targetPath.startsWith("public/")) {
+      relativeDir = targetPath.replace("public/", "");
+    }
+    if (relativeDir === "images" || relativeDir.startsWith("images/")) {
+      return jsonResponse(
+        { error: "Cannot upload to images/ folder. Upload to public/ instead - thumbnails are generated automatically." },
+        { status: 400 }
+      );
+    }
+    let imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
+    if (meta[imageKey]) {
+      const baseName = path7.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 = path7.basename(imageKey);
+    const uploadDir = getPublicPath(relativeDir);
+    await fs7.mkdir(uploadDir, { recursive: true });
+    await fs7.writeFile(path7.join(uploadDir, actualFileName), buffer);
+    if (!isMedia) {
+      return jsonResponse({
+        success: true,
+        message: "File uploaded (not a media file)",
+        path: `public/${relativeDir ? relativeDir + "/" : ""}${actualFileName}`
+      });
+    }
+    if (isImage && ext !== ".svg") {
       try {
-        const meta = await loadMeta();
-        const cdnUrls = getCdnUrls(meta);
-        const processed = [];
-        const errors = [];
-        const total = imageKeys.length;
-        sendEvent({ type: "start", total });
-        for (let i = 0; i < imageKeys.length; i++) {
-          let imageKey = imageKeys[i];
-          if (!imageKey.startsWith("/")) {
-            imageKey = `/${imageKey}`;
-          }
-          try {
-            let buffer;
-            const entry = getMetaEntry(meta, imageKey);
-            const existingCdnIndex = entry?.c;
-            const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
-            const isInOurR2 = existingCdnUrl === publicUrl;
-            const isRemote = existingCdnIndex !== void 0 && !isInOurR2;
-            const originalPath = getPublicPath(imageKey);
-            try {
-              buffer = await fs7.readFile(originalPath);
-            } catch {
-              if (isInOurR2) {
-                buffer = await downloadFromCdn(imageKey);
-                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 = path7.dirname(originalPath);
-                await fs7.mkdir(dir, { recursive: true });
-                await fs7.writeFile(originalPath, buffer);
-              } else {
-                throw new Error(`File not found: ${imageKey}`);
+        const metadata = await sharp2(buffer).metadata();
+        meta[imageKey] = {
+          o: { w: metadata.width || 0, h: metadata.height || 0 }
+        };
+      } catch {
+        meta[imageKey] = { o: { w: 0, h: 0 } };
+      }
+    } else {
+      meta[imageKey] = {};
+    }
+    await saveMeta(meta);
+    return jsonResponse({
+      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";
+    return jsonResponse({ error: `Failed to upload file: ${message}` }, { status: 500 });
+  }
+}
+async function handleDelete(request) {
+  try {
+    const { paths } = await request.json();
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return jsonResponse({ error: "No paths provided" }, { status: 400 });
+    }
+    const meta = await loadMeta();
+    const deleted = [];
+    const errors = [];
+    const sourceFolders = /* @__PURE__ */ new Set();
+    for (const itemPath of paths) {
+      try {
+        if (!itemPath.startsWith("public/")) {
+          errors.push(`Invalid path: ${itemPath}`);
+          continue;
+        }
+        const absolutePath = getWorkspacePath(itemPath);
+        const imageKey = "/" + itemPath.replace(/^public\//, "");
+        sourceFolders.add(path7.dirname(absolutePath));
+        const entry = meta[imageKey];
+        const isPushedToCloud = entry?.c !== void 0;
+        const hasThumbnails = entry ? isProcessed(entry) : false;
+        try {
+          const stats = await fs7.stat(absolutePath);
+          if (stats.isDirectory()) {
+            await fs7.rm(absolutePath, { recursive: true });
+            const prefix = imageKey + "/";
+            for (const key of Object.keys(meta)) {
+              if (key.startsWith(prefix) || key === imageKey) {
+                const keyEntry = meta[key];
+                const keyHasThumbnails = keyEntry ? isProcessed(keyEntry) : false;
+                if (keyEntry?.c !== void 0) {
+                  try {
+                    await deleteFromCdn(key, keyHasThumbnails);
+                  } catch {
+                  }
+                } else {
+                  for (const thumbPath of getAllThumbnailPaths(key)) {
+                    const absoluteThumbPath = getPublicPath(thumbPath);
+                    try {
+                      await fs7.unlink(absoluteThumbPath);
+                    } catch {
+                    }
+                  }
+                }
+                delete meta[key];
               }
             }
-            const ext = path7.extname(imageKey).toLowerCase();
-            const isSvg = ext === ".svg";
-            if (isSvg) {
-              const imageDir = path7.dirname(imageKey.slice(1));
-              const imagesPath = getPublicPath("images", imageDir === "." ? "" : imageDir);
-              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 },
-                b: "",
-                f: { w: 0, h: 0 }
-              };
-              if (isRemote) {
-                delete meta[imageKey].c;
-              }
-            } else {
-              const updatedEntry = await processImage(buffer, imageKey);
-              if (isInOurR2) {
-                updatedEntry.c = existingCdnIndex;
-                await deleteOriginalFromCdn(imageKey);
-                await deleteThumbnailsFromCdn(imageKey);
-                await uploadOriginalToCdn(imageKey);
-                await uploadToCdn(imageKey);
-                await deleteLocalThumbnails(imageKey);
+          } else {
+            await fs7.unlink(absolutePath);
+            const isInImagesFolder = itemPath.startsWith("public/images/");
+            if (!isInImagesFolder && entry) {
+              if (isPushedToCloud) {
                 try {
-                  await fs7.unlink(originalPath);
+                  await deleteFromCdn(imageKey, hasThumbnails);
                 } catch {
                 }
+              } else {
+                for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+                  const absoluteThumbPath = getPublicPath(thumbPath);
+                  try {
+                    await fs7.unlink(absoluteThumbPath);
+                  } catch {
+                  }
+                }
               }
-              meta[imageKey] = updatedEntry;
+              delete meta[imageKey];
+            }
+          }
+        } catch {
+          if (entry) {
+            if (isPushedToCloud) {
+              try {
+                await deleteFromCdn(imageKey, hasThumbnails);
+              } catch {
+              }
+            }
+            delete meta[imageKey];
+          } else {
+            const prefix = imageKey + "/";
+            let foundAny = false;
+            for (const key of Object.keys(meta)) {
+              if (key.startsWith(prefix)) {
+                const keyEntry = meta[key];
+                const keyHasThumbnails = keyEntry ? isProcessed(keyEntry) : false;
+                if (keyEntry?.c !== void 0) {
+                  try {
+                    await deleteFromCdn(key, keyHasThumbnails);
+                  } catch {
+                  }
+                }
+                delete meta[key];
+                foundAny = true;
+              }
+            }
+            if (!foundAny) {
+              errors.push(`Not found: ${itemPath}`);
+              continue;
             }
-            processed.push(imageKey);
-            sendEvent({
-              type: "progress",
-              current: i + 1,
-              total,
-              processed: processed.length,
-              percent: Math.round((i + 1) / total * 100),
-              message: `Processed ${imageKey.slice(1)}`
-            });
-          } catch (error) {
-            console.error(`Failed to reprocess ${imageKey}:`, error);
-            errors.push(imageKey);
-            sendEvent({
-              type: "progress",
-              current: i + 1,
-              total,
-              processed: processed.length,
-              percent: Math.round((i + 1) / total * 100),
-              message: `Failed: ${imageKey.slice(1)}`
-            });
           }
         }
-        sendEvent({ type: "cleanup", message: "Saving metadata..." });
-        await saveMeta(meta);
-        let message = `Generated thumbnails for ${processed.length} image${processed.length !== 1 ? "s" : ""}.`;
-        if (errors.length > 0) {
-          message += ` ${errors.length} image${errors.length !== 1 ? "s" : ""} failed.`;
-        }
-        sendEvent({
-          type: "complete",
-          processed: processed.length,
-          errors: errors.length,
-          message
-        });
-        controller.close();
+        deleted.push(itemPath);
       } catch (error) {
-        console.error("Reprocess stream error:", error);
-        sendEvent({ type: "error", message: "Failed to generate thumbnails" });
-        controller.close();
+        console.error(`Failed to delete ${itemPath}:`, error);
+        errors.push(itemPath);
       }
     }
-  });
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
+    await saveMeta(meta);
+    for (const folder of sourceFolders) {
+      await deleteEmptyFolders(folder);
     }
-  });
+    return jsonResponse({
+      success: true,
+      deleted,
+      errors: errors.length > 0 ? errors : void 0
+    });
+  } catch (error) {
+    console.error("Failed to delete:", error);
+    return jsonResponse({ error: "Failed to delete files" }, { status: 500 });
+  }
 }
-async function handleDownloadStream(request) {
-  const { imageKeys, operationId } = await request.json();
-  if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
-    return jsonResponse({ error: "No image keys provided" }, { status: 400 });
+async function handleCreateFolder(request) {
+  try {
+    const { parentPath, name } = await request.json();
+    if (!name || typeof name !== "string") {
+      return jsonResponse({ error: "Folder name is required" }, { status: 400 });
+    }
+    const sanitizedName = slugifyFolderName(name);
+    if (!sanitizedName) {
+      return jsonResponse({ error: "Invalid folder name" }, { status: 400 });
+    }
+    const safePath = (parentPath || "public").replace(/\.\./g, "");
+    const folderPath = getWorkspacePath(safePath, sanitizedName);
+    if (!folderPath.startsWith(getPublicPath())) {
+      return jsonResponse({ error: "Invalid path" }, { status: 400 });
+    }
+    try {
+      await fs7.access(folderPath);
+      return jsonResponse({ error: "A folder with this name already exists" }, { status: 400 });
+    } catch {
+    }
+    await fs7.mkdir(folderPath, { recursive: true });
+    return jsonResponse({ success: true, path: path7.join(safePath, sanitizedName) });
+  } catch (error) {
+    console.error("Failed to create folder:", error);
+    return jsonResponse({ error: "Failed to create folder" }, { status: 500 });
+  }
+}
+async function handleRename(request) {
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "");
+  try {
+    const { oldPath, newName } = await request.json();
+    if (!oldPath || !newName) {
+      return jsonResponse({ error: "Path and new name are required" }, { status: 400 });
+    }
+    const safePath = oldPath.replace(/\.\./g, "");
+    const absoluteOldPath = getWorkspacePath(safePath);
+    if (!absoluteOldPath.startsWith(getPublicPath())) {
+      return jsonResponse({ error: "Invalid path" }, { status: 400 });
+    }
+    const oldRelativePath = safePath.replace(/^public\//, "");
+    const oldKey = "/" + oldRelativePath;
+    const isImage = isImageFile(path7.basename(oldPath));
+    const meta = await loadMeta();
+    const cdnUrls = getCdnUrls(meta);
+    const entry = meta[oldKey];
+    const isInCloud = entry?.c !== void 0;
+    const fileCdnUrl = isInCloud && entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+    const isInOurR2 = isInCloud && fileCdnUrl === publicUrl;
+    const hasThumbnails = entry ? isProcessed(entry) : false;
+    let hasLocalFile = false;
+    let isFile = true;
+    try {
+      const stats = await fs7.stat(absoluteOldPath);
+      hasLocalFile = true;
+      isFile = stats.isFile();
+    } catch {
+      if (!isInCloud) {
+        return jsonResponse({ error: "File or folder not found" }, { status: 404 });
+      }
+    }
+    const sanitizedName = isFile ? slugifyFilename(newName) : slugifyFolderName(newName);
+    if (!sanitizedName) {
+      return jsonResponse({ error: "Invalid name" }, { status: 400 });
+    }
+    const parentDir = path7.dirname(absoluteOldPath);
+    const absoluteNewPath = path7.join(parentDir, sanitizedName);
+    const newRelativePath = path7.join(path7.dirname(oldRelativePath), sanitizedName);
+    const newKey = "/" + newRelativePath;
+    if (meta[newKey]) {
+      return jsonResponse({ error: "An item with this name already exists" }, { status: 400 });
+    }
+    try {
+      await fs7.access(absoluteNewPath);
+      return jsonResponse({ error: "An item with this name already exists" }, { status: 400 });
+    } catch {
+    }
+    if (isInOurR2 && !hasLocalFile && isImage) {
+      await moveInCdn(oldKey, newKey, hasThumbnails);
+      delete meta[oldKey];
+      meta[newKey] = entry;
+      await saveMeta(meta);
+      const newPath2 = path7.join(path7.dirname(safePath), sanitizedName);
+      return jsonResponse({ success: true, newPath: newPath2 });
+    }
+    if (hasLocalFile) {
+      await fs7.rename(absoluteOldPath, absoluteNewPath);
+    }
+    if (isImage && entry) {
+      const oldThumbPaths = getAllThumbnailPaths(oldKey);
+      const newThumbPaths = getAllThumbnailPaths(newKey);
+      for (let i = 0; i < oldThumbPaths.length; i++) {
+        const oldThumbPath = getPublicPath(oldThumbPaths[i]);
+        const newThumbPath = getPublicPath(newThumbPaths[i]);
+        await fs7.mkdir(path7.dirname(newThumbPath), { recursive: true });
+        try {
+          await fs7.rename(oldThumbPath, newThumbPath);
+        } catch {
+        }
+      }
+      if (isInOurR2) {
+        await moveInCdn(oldKey, newKey, hasThumbnails);
+        try {
+          await fs7.unlink(absoluteNewPath);
+        } catch {
+        }
+        await deleteLocalThumbnails(newKey);
+      }
+      delete meta[oldKey];
+      meta[newKey] = entry;
+      await saveMeta(meta);
+    }
+    const newPath = path7.join(path7.dirname(safePath), sanitizedName);
+    return jsonResponse({ success: true, newPath });
+  } catch (error) {
+    console.error("Failed to rename:", error);
+    return jsonResponse({ error: "Failed to rename" }, { status: 500 });
   }
+}
+async function handleRenameStream(request) {
+  const encoder = new TextEncoder();
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "");
   const stream = new ReadableStream({
     async start(controller) {
-      const encoder = new TextEncoder();
       const sendEvent = (data) => {
-        try {
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
 
 `));
-        } catch {
-        }
       };
-      sendEvent({ type: "start", total: imageKeys.length });
-      const downloaded = [];
-      const skipped = [];
-      const errors = [];
-      const isCancelled = () => operationId ? isOperationCancelled(operationId) : false;
       try {
+        const { oldPath, newName, operationId } = await request.json();
+        if (!oldPath || !newName) {
+          sendEvent({ type: "error", message: "Path and new name are required" });
+          controller.close();
+          return;
+        }
+        const isCancelled = () => operationId ? isOperationCancelled(operationId) : false;
+        const safePath = oldPath.replace(/\.\./g, "");
+        const absoluteOldPath = getWorkspacePath(safePath);
+        if (!absoluteOldPath.startsWith(getPublicPath())) {
+          sendEvent({ type: "error", message: "Invalid path" });
+          controller.close();
+          return;
+        }
+        const oldRelativePath = safePath.replace(/^public\//, "");
+        const isImagePath = isImageFile(path7.basename(oldPath));
+        let hasLocalItem = false;
+        let isFile = true;
+        let isVirtualFolder = false;
+        try {
+          const stats = await fs7.stat(absoluteOldPath);
+          hasLocalItem = true;
+          isFile = stats.isFile();
+        } catch {
+          const meta2 = await loadMeta();
+          const oldKey2 = "/" + oldRelativePath;
+          const entry2 = meta2[oldKey2];
+          if (entry2) {
+            isFile = true;
+          } else {
+            const folderPrefix = oldKey2 + "/";
+            const hasChildrenInMeta = Object.keys(meta2).some((key) => key.startsWith(folderPrefix));
+            if (hasChildrenInMeta) {
+              isFile = false;
+              isVirtualFolder = true;
+            } else {
+              sendEvent({ type: "error", message: "File or folder not found" });
+              controller.close();
+              return;
+            }
+          }
+        }
+        const sanitizedName = isFile ? slugifyFilename(newName) : slugifyFolderName(newName);
+        if (!sanitizedName) {
+          sendEvent({ type: "error", message: "Invalid name" });
+          controller.close();
+          return;
+        }
+        const parentDir = path7.dirname(absoluteOldPath);
+        const absoluteNewPath = path7.join(parentDir, sanitizedName);
+        const newRelativePath = path7.join(path7.dirname(oldRelativePath), sanitizedName);
+        const newPath = path7.join(path7.dirname(safePath), sanitizedName);
         const meta = await loadMeta();
-        for (let i = 0; i < imageKeys.length; i++) {
-          if (isCancelled()) {
-            await saveMeta(meta);
-            if (operationId) clearCancelledOperation(operationId);
-            sendEvent({
-              type: "stopped",
-              downloaded: downloaded.length,
-              message: `Stopped. ${downloaded.length} image${downloaded.length !== 1 ? "s" : ""} downloaded.`
-            });
+        const cdnUrls = getCdnUrls(meta);
+        if (isFile) {
+          const newKey2 = "/" + newRelativePath;
+          if (meta[newKey2]) {
+            sendEvent({ type: "error", message: "An item with this name already exists" });
             controller.close();
             return;
           }
-          const imageKey = imageKeys[i];
-          const entry = getMetaEntry(meta, imageKey);
-          if (!entry || entry.c === void 0) {
-            skipped.push(imageKey);
-            sendEvent({
-              type: "progress",
-              current: i + 1,
-              total: imageKeys.length,
-              downloaded: downloaded.length,
-              message: `Skipped ${imageKey} (not on cloud)`
-            });
-            continue;
-          }
+        }
+        if (!isVirtualFolder) {
           try {
-            const imageBuffer = await downloadFromCdn(imageKey);
+            await fs7.access(absoluteNewPath);
+            sendEvent({ type: "error", message: "An item with this name already exists" });
+            controller.close();
+            return;
+          } catch {
+          }
+        }
+        if (isVirtualFolder) {
+          const newPrefix = "/" + newRelativePath + "/";
+          const hasConflict = Object.keys(meta).some((key) => key.startsWith(newPrefix));
+          if (hasConflict) {
+            sendEvent({ type: "error", message: "A folder with this name already exists" });
+            controller.close();
+            return;
+          }
+        }
+        if (!isFile) {
+          const oldPrefix = "/" + oldRelativePath + "/";
+          const newPrefix = "/" + newRelativePath + "/";
+          const itemsToUpdate = [];
+          for (const [key, entry2] of Object.entries(meta)) {
+            if (key.startsWith(oldPrefix) && entry2 && typeof entry2 === "object") {
+              const newKey2 = key.replace(oldPrefix, newPrefix);
+              itemsToUpdate.push({ oldKey: key, newKey: newKey2, entry: entry2 });
+            }
+          }
+          const total = itemsToUpdate.length + 1;
+          sendEvent({ type: "start", total, message: `Renaming folder with ${itemsToUpdate.length} item(s)...` });
+          if (hasLocalItem) {
+            await fs7.rename(absoluteOldPath, absoluteNewPath);
+            const imagesDir = getPublicPath("/images");
+            const oldThumbFolder2 = path7.join(imagesDir, oldRelativePath);
+            const newThumbFolder = path7.join(imagesDir, newRelativePath);
+            try {
+              await fs7.access(oldThumbFolder2);
+              await fs7.mkdir(path7.dirname(newThumbFolder), { recursive: true });
+              await fs7.rename(oldThumbFolder2, newThumbFolder);
+            } catch {
+            }
+          }
+          sendEvent({ type: "progress", current: 1, total, renamed: 1, message: "Renamed folder" });
+          let renamed = 1;
+          for (const item of itemsToUpdate) {
             if (isCancelled()) {
               await saveMeta(meta);
-              if (operationId) clearCancelledOperation(operationId);
-              sendEvent({
-                type: "stopped",
-                downloaded: downloaded.length,
-                message: `Stopped. ${downloaded.length} image${downloaded.length !== 1 ? "s" : ""} downloaded.`
-              });
+              sendEvent({ type: "complete", renamed, newPath, cancelled: true });
               controller.close();
               return;
             }
-            const localPath = getPublicPath(imageKey.replace(/^\//, ""));
-            await fs7.mkdir(path7.dirname(localPath), { recursive: true });
-            await fs7.writeFile(localPath, imageBuffer);
-            await deleteThumbnailsFromCdn(imageKey);
-            const wasProcessed = isProcessed(entry);
-            delete entry.c;
-            if (wasProcessed) {
-              const processedEntry = await processImage(imageBuffer, imageKey);
-              entry.sm = processedEntry.sm;
-              entry.md = processedEntry.md;
-              entry.lg = processedEntry.lg;
-              entry.f = processedEntry.f;
+            const { oldKey: oldKey2, newKey: newKey2, entry: entry2 } = item;
+            const isInCloud2 = entry2.c !== void 0;
+            const fileCdnUrl2 = isInCloud2 ? cdnUrls[entry2.c] : void 0;
+            const isInOurR22 = isInCloud2 && fileCdnUrl2 === publicUrl;
+            const hasThumbnails2 = isProcessed(entry2);
+            if (isInOurR22) {
+              try {
+                await moveInCdn(oldKey2, newKey2, hasThumbnails2);
+                const localFilePath = getPublicPath(newKey2);
+                try {
+                  await fs7.unlink(localFilePath);
+                } catch {
+                }
+                if (hasThumbnails2) {
+                  await deleteLocalThumbnails(newKey2);
+                }
+              } catch (err) {
+                console.error(`Failed to rename in CDN ${oldKey2}:`, err);
+              }
             }
-            downloaded.push(imageKey);
-            sendEvent({
-              type: "progress",
-              current: i + 1,
-              total: imageKeys.length,
-              downloaded: downloaded.length,
-              message: `Downloaded ${imageKey}`
-            });
-          } catch (error) {
-            console.error(`Failed to download ${imageKey}:`, error);
-            errors.push(imageKey);
+            delete meta[oldKey2];
+            meta[newKey2] = entry2;
+            renamed++;
             sendEvent({
               type: "progress",
-              current: i + 1,
-              total: imageKeys.length,
-              downloaded: downloaded.length,
-              message: `Failed to download ${imageKey}`
+              current: renamed,
+              total,
+              renamed,
+              message: `Renamed ${path7.basename(newKey2)}`
             });
           }
+          await saveMeta(meta);
+          await deleteEmptyFolders(absoluteOldPath);
+          const oldThumbFolder = path7.join(getPublicPath("/images"), oldRelativePath);
+          await deleteEmptyFolders(oldThumbFolder);
+          sendEvent({ type: "complete", renamed, newPath });
+          controller.close();
+          return;
         }
-        await saveMeta(meta);
-        let message = `Downloaded ${downloaded.length} image${downloaded.length !== 1 ? "s" : ""}.`;
-        if (skipped.length > 0) {
-          message += ` ${skipped.length} image${skipped.length !== 1 ? "s were" : " was"} not on cloud.`;
+        const oldKey = "/" + oldRelativePath;
+        const newKey = "/" + newRelativePath;
+        const entry = meta[oldKey];
+        const isInCloud = entry?.c !== void 0;
+        const fileCdnUrl = isInCloud && entry?.c !== void 0 ? cdnUrls[entry.c] : void 0;
+        const isInOurR2 = isInCloud && fileCdnUrl === publicUrl;
+        const hasThumbnails = entry ? isProcessed(entry) : false;
+        sendEvent({ type: "start", total: 1, message: "Renaming file..." });
+        if (isInOurR2 && !hasLocalItem && isImagePath) {
+          await moveInCdn(oldKey, newKey, hasThumbnails);
+          delete meta[oldKey];
+          if (entry) meta[newKey] = entry;
+          await saveMeta(meta);
+          sendEvent({ type: "complete", renamed: 1, newPath });
+          controller.close();
+          return;
         }
-        if (errors.length > 0) {
-          message += ` ${errors.length} image${errors.length !== 1 ? "s" : ""} failed.`;
+        if (hasLocalItem) {
+          await fs7.rename(absoluteOldPath, absoluteNewPath);
         }
-        sendEvent({
-          type: "complete",
-          downloaded: downloaded.length,
-          skipped: skipped.length,
-          errors: errors.length,
-          message
-        });
+        if (isImagePath && entry) {
+          const oldThumbPaths = getAllThumbnailPaths(oldKey);
+          const newThumbPaths = getAllThumbnailPaths(newKey);
+          for (let i = 0; i < oldThumbPaths.length; i++) {
+            const oldThumbPath = getPublicPath(oldThumbPaths[i]);
+            const newThumbPath = getPublicPath(newThumbPaths[i]);
+            await fs7.mkdir(path7.dirname(newThumbPath), { recursive: true });
+            try {
+              await fs7.rename(oldThumbPath, newThumbPath);
+            } catch {
+            }
+          }
+          if (isInOurR2) {
+            await moveInCdn(oldKey, newKey, hasThumbnails);
+            try {
+              await fs7.unlink(absoluteNewPath);
+            } catch {
+            }
+            await deleteLocalThumbnails(newKey);
+          }
+          delete meta[oldKey];
+          meta[newKey] = entry;
+          await saveMeta(meta);
+        }
+        sendEvent({ type: "complete", renamed: 1, newPath });
+        controller.close();
       } catch (error) {
-        console.error("Download stream error:", error);
-        sendEvent({ type: "error", message: "Failed to download images" });
-      } finally {
+        console.error("Rename stream error:", error);
+        sendEvent({ type: "error", message: "Failed to rename" });
         controller.close();
       }
     }
   });
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      "Connection": "keep-alive"
-    }
-  });
+  return streamResponse(stream);
 }
-async function handlePushUpdatesStream(request) {
-  const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
-  const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
-  const secretAccessKey = process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY;
-  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
-  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "");
+async function handleMoveStream(request) {
   const encoder = new TextEncoder();
   const stream = new ReadableStream({
     async start(controller) {
@@ -2614,132 +2378,455 @@ async function handlePushUpdatesStream(request) {
 `));
       };
       try {
-        if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
-          sendEvent({ type: "error", message: "R2 not configured" });
+        const { paths, destination, operationId } = await request.json();
+        if (!paths || !Array.isArray(paths) || paths.length === 0) {
+          sendEvent({ type: "error", message: "Paths are required" });
           controller.close();
           return;
         }
-        const { paths } = await request.json();
-        if (!paths || !Array.isArray(paths) || paths.length === 0) {
-          sendEvent({ type: "error", message: "No paths provided" });
+        if (!destination || typeof destination !== "string") {
+          sendEvent({ type: "error", message: "Destination is required" });
           controller.close();
           return;
         }
-        const s3 = new S3Client2({
-          region: "auto",
-          endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
-          credentials: { accessKeyId, secretAccessKey }
-        });
+        const isCancelled = () => operationId ? isOperationCancelled(operationId) : false;
+        const safeDestination = destination.replace(/\.\./g, "");
+        const absoluteDestination = getWorkspacePath(safeDestination);
+        if (!absoluteDestination.startsWith(getPublicPath())) {
+          sendEvent({ type: "error", message: "Invalid destination" });
+          controller.close();
+          return;
+        }
+        await fs7.mkdir(absoluteDestination, { recursive: true });
         const meta = await loadMeta();
         const cdnUrls = getCdnUrls(meta);
-        const r2PublicUrl = publicUrl.replace(/\/$/, "");
-        const pushed = [];
-        const skipped = [];
+        const r2PublicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "") || "";
+        const moved = [];
         const errors = [];
-        const total = paths.length;
-        sendEvent({ type: "start", total });
-        for (let i = 0; i < paths.length; i++) {
-          const itemPath = paths[i];
-          const key = itemPath.startsWith("public/") ? "/" + itemPath.slice(7) : itemPath;
-          const entry = meta[key];
-          if (!entry || entry.u !== 1) {
-            skipped.push(key);
-            sendEvent({
-              type: "progress",
-              current: i + 1,
-              total,
-              pushed: pushed.length,
-              percent: Math.round((i + 1) / total * 100),
-              currentFile: path7.basename(key)
-            });
+        const sourceFolders = /* @__PURE__ */ new Set();
+        let totalFiles = 0;
+        const expandedItems = [];
+        for (const itemPath of paths) {
+          const safePath = itemPath.replace(/\.\./g, "");
+          const itemName = path7.basename(safePath);
+          const oldRelativePath = safePath.replace(/^public\/?/, "");
+          const destWithoutPublic = safeDestination.replace(/^public\/?/, "");
+          const newRelativePath = destWithoutPublic ? path7.join(destWithoutPublic, itemName) : itemName;
+          const oldKey = "/" + oldRelativePath;
+          const newKey = "/" + newRelativePath;
+          const newAbsolutePath = path7.join(absoluteDestination, itemName);
+          const absolutePath = getWorkspacePath(safePath);
+          let hasLocalItem = false;
+          let isDirectory = false;
+          try {
+            const stats = await fs7.stat(absolutePath);
+            hasLocalItem = true;
+            isDirectory = stats.isDirectory();
+          } catch {
+          }
+          if (hasLocalItem && isDirectory) {
+            const countFilesRecursive = async (dir) => {
+              let count = 0;
+              const entries = await fs7.readdir(dir, { withFileTypes: true });
+              for (const entry of entries) {
+                if (entry.isDirectory()) {
+                  count += await countFilesRecursive(path7.join(dir, entry.name));
+                } else {
+                  count++;
+                }
+              }
+              return count;
+            };
+            const localFileCount = await countFilesRecursive(absolutePath);
+            const folderPrefix = oldKey + "/";
+            let cloudOnlyCount = 0;
+            for (const metaKey of Object.keys(meta)) {
+              if (metaKey.startsWith(folderPrefix)) {
+                const relPath = metaKey.slice(folderPrefix.length);
+                const localPath = path7.join(absolutePath, relPath);
+                try {
+                  await fs7.access(localPath);
+                } catch {
+                  cloudOnlyCount++;
+                }
+              }
+            }
+            totalFiles += localFileCount + cloudOnlyCount;
+            expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
+          } else if (!hasLocalItem) {
+            const folderPrefix = oldKey + "/";
+            const virtualItems = [];
+            for (const [key, metaEntry] of Object.entries(meta)) {
+              if (key.startsWith(folderPrefix) && metaEntry && typeof metaEntry === "object") {
+                const relativePath = key.slice(folderPrefix.length);
+                const destNewKey = newKey + "/" + relativePath;
+                virtualItems.push({ oldKey: key, newKey: destNewKey, entry: metaEntry });
+              }
+            }
+            if (virtualItems.length > 0) {
+              totalFiles += virtualItems.length;
+              expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: true, virtualFolderItems: virtualItems });
+              sourceFolders.add(absolutePath);
+            } else {
+              totalFiles++;
+              expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
+            }
+          } else {
+            totalFiles++;
+            expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
+          }
+        }
+        sendEvent({ type: "start", total: totalFiles });
+        let processedFiles = 0;
+        for (const expandedItem of expandedItems) {
+          if (isCancelled()) {
+            sendEvent({ type: "complete", moved: moved.length, errors: errors.length, errorMessages: errors, cancelled: true });
+            controller.close();
+            return;
+          }
+          const { itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder, virtualFolderItems } = expandedItem;
+          if (isVirtualFolder && virtualFolderItems) {
+            for (const vItem of virtualFolderItems) {
+              if (isCancelled()) {
+                sendEvent({ type: "complete", moved: moved.length, errors: errors.length, errorMessages: errors, cancelled: true });
+                controller.close();
+                return;
+              }
+              const itemEntry = vItem.entry;
+              const isItemInCloud = itemEntry.c !== void 0;
+              const itemCdnUrl = isItemInCloud ? cdnUrls[itemEntry.c] : void 0;
+              const isItemInR2 = isItemInCloud && itemCdnUrl === r2PublicUrl;
+              const itemHasThumbnails = isProcessed(itemEntry);
+              let vItemMoved = false;
+              if (isItemInR2) {
+                try {
+                  await moveInCdn(vItem.oldKey, vItem.newKey, itemHasThumbnails);
+                  vItemMoved = true;
+                } catch (err) {
+                  console.error(`Failed to move cloud item ${vItem.oldKey}:`, err);
+                  delete meta[vItem.oldKey];
+                }
+              }
+              if (vItemMoved) {
+                delete meta[vItem.oldKey];
+                meta[vItem.newKey] = itemEntry;
+              }
+              processedFiles++;
+              sendEvent({
+                type: "progress",
+                current: processedFiles,
+                total: totalFiles,
+                moved: moved.length,
+                percent: Math.round(processedFiles / totalFiles * 100),
+                currentFile: path7.basename(vItem.newKey)
+              });
+            }
+            const newFolderPath = getPublicPath(newKey);
+            await deleteEmptyFolders(newFolderPath);
+            const newThumbFolder = path7.join(getPublicPath("images"), newKey.slice(1));
+            await deleteEmptyFolders(newThumbFolder);
+            moved.push(itemPath);
             continue;
           }
-          const fileCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c]?.replace(/\/$/, "") : void 0;
-          if (!fileCdnUrl || fileCdnUrl !== r2PublicUrl) {
-            skipped.push(key);
+          if (meta[newKey]) {
+            errors.push(`${itemName} already exists in destination`);
+            processedFiles++;
             sendEvent({
               type: "progress",
-              current: i + 1,
-              total,
-              pushed: pushed.length,
-              percent: Math.round((i + 1) / total * 100),
-              currentFile: path7.basename(key)
+              current: processedFiles,
+              total: totalFiles,
+              moved: moved.length,
+              percent: Math.round(processedFiles / totalFiles * 100),
+              currentFile: itemName
             });
             continue;
           }
+          const entry = meta[oldKey];
+          const isImage = isImageFile(itemName);
+          const isInCloud = entry?.c !== void 0;
+          const fileCdnUrl = isInCloud && entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+          const isRemote = isInCloud && (!r2PublicUrl || fileCdnUrl !== r2PublicUrl);
+          const isPushedToR2 = isInCloud && r2PublicUrl && fileCdnUrl === r2PublicUrl;
+          const hasProcessedThumbnails = isProcessed(entry);
           try {
-            const localPath = getPublicPath(key);
-            const buffer = await fs7.readFile(localPath);
-            const contentType = getContentType(path7.basename(key));
-            const uploadKey = key.startsWith("/") ? key.slice(1) : key;
-            try {
-              await s3.send(new DeleteObjectCommand2({
-                Bucket: bucketName,
-                Key: uploadKey
-              }));
-            } catch {
-            }
-            await s3.send(new PutObjectCommand2({
-              Bucket: bucketName,
-              Key: uploadKey,
-              Body: buffer,
-              ContentType: contentType
-            }));
-            if (isProcessed(entry)) {
-              await deleteThumbnailsFromCdn(key);
-              const processedEntry = await processImage(buffer, key);
-              Object.assign(entry, processedEntry);
-              await uploadToCdn(key);
-              await deleteLocalThumbnails(key);
+            const sourceFolder = path7.dirname(getWorkspacePath(safePath));
+            sourceFolders.add(sourceFolder);
+            if (isRemote && isImage) {
+              const remoteUrl = `${fileCdnUrl}${oldKey}`;
+              const buffer = await downloadFromRemoteUrl(remoteUrl);
+              await fs7.mkdir(path7.dirname(newAbsolutePath), { recursive: true });
+              await fs7.writeFile(newAbsolutePath, buffer);
+              const newEntry = {
+                o: entry?.o,
+                b: entry?.b
+              };
+              delete meta[oldKey];
+              meta[newKey] = newEntry;
+              moved.push(itemPath);
+              processedFiles++;
+              sendEvent({
+                type: "progress",
+                current: processedFiles,
+                total: totalFiles,
+                moved: moved.length,
+                percent: Math.round(processedFiles / totalFiles * 100),
+                currentFile: itemName
+              });
+            } else if (isPushedToR2 && isImage) {
+              await moveInCdn(oldKey, newKey, hasProcessedThumbnails);
+              delete meta[oldKey];
+              if (entry) {
+                meta[newKey] = entry;
+              }
+              moved.push(itemPath);
+              processedFiles++;
+              sendEvent({
+                type: "progress",
+                current: processedFiles,
+                total: totalFiles,
+                moved: moved.length,
+                percent: Math.round(processedFiles / totalFiles * 100),
+                currentFile: itemName
+              });
+            } else {
+              const absolutePath = getWorkspacePath(safePath);
+              if (absoluteDestination.startsWith(absolutePath + path7.sep)) {
+                errors.push(`Cannot move ${itemName} into itself`);
+                processedFiles++;
+                sendEvent({
+                  type: "progress",
+                  current: processedFiles,
+                  total: totalFiles,
+                  moved: moved.length,
+                  percent: Math.round(processedFiles / totalFiles * 100),
+                  currentFile: itemName
+                });
+                continue;
+              }
+              try {
+                await fs7.access(absolutePath);
+              } catch {
+                errors.push(`${itemName} not found`);
+                processedFiles++;
+                sendEvent({
+                  type: "progress",
+                  current: processedFiles,
+                  total: totalFiles,
+                  moved: moved.length,
+                  percent: Math.round(processedFiles / totalFiles * 100),
+                  currentFile: itemName
+                });
+                continue;
+              }
+              try {
+                await fs7.access(newAbsolutePath);
+                errors.push(`${itemName} already exists in destination`);
+                processedFiles++;
+                sendEvent({
+                  type: "progress",
+                  current: processedFiles,
+                  total: totalFiles,
+                  moved: moved.length,
+                  percent: Math.round(processedFiles / totalFiles * 100),
+                  currentFile: itemName
+                });
+                continue;
+              } catch {
+              }
+              const stats = await fs7.stat(absolutePath);
+              if (stats.isFile()) {
+                await fs7.mkdir(path7.dirname(newAbsolutePath), { recursive: true });
+                await fs7.rename(absolutePath, newAbsolutePath);
+                if (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]);
+                    try {
+                      await fs7.access(oldThumbPath);
+                      sourceFolders.add(path7.dirname(oldThumbPath));
+                      await fs7.mkdir(path7.dirname(newThumbPath), { recursive: true });
+                      await fs7.rename(oldThumbPath, newThumbPath);
+                    } catch {
+                    }
+                  }
+                  const fileIsInCloud = entry.c !== void 0;
+                  const fileCdnUrl2 = fileIsInCloud ? cdnUrls[entry.c] : void 0;
+                  const fileIsInR2 = fileIsInCloud && fileCdnUrl2 === r2PublicUrl;
+                  const fileHasThumbs = isProcessed(entry);
+                  if (fileIsInR2) {
+                    await deleteFromCdn(oldKey, fileHasThumbs);
+                    await uploadOriginalToCdn(newKey);
+                    if (fileHasThumbs) {
+                      await uploadToCdn(newKey);
+                    }
+                  }
+                  delete meta[oldKey];
+                  meta[newKey] = entry;
+                }
+                processedFiles++;
+                sendEvent({
+                  type: "progress",
+                  current: processedFiles,
+                  total: totalFiles,
+                  moved: moved.length,
+                  percent: Math.round(processedFiles / totalFiles * 100),
+                  currentFile: itemName
+                });
+                moved.push(itemPath);
+              } else if (stats.isDirectory()) {
+                const oldPrefix = oldKey + "/";
+                const newPrefix = newKey + "/";
+                const localFiles = [];
+                const collectLocalFiles = async (dir, relativeDir) => {
+                  const entries = await fs7.readdir(dir, { withFileTypes: true });
+                  for (const dirEntry of entries) {
+                    const entryRelPath = relativeDir ? `${relativeDir}/${dirEntry.name}` : dirEntry.name;
+                    if (dirEntry.isDirectory()) {
+                      await collectLocalFiles(path7.join(dir, dirEntry.name), entryRelPath);
+                    } else {
+                      localFiles.push({ relativePath: entryRelPath, isImage: isImageFile(dirEntry.name) });
+                    }
+                  }
+                };
+                await collectLocalFiles(absolutePath, "");
+                const cloudOnlyFiles = [];
+                for (const [metaKey, metaEntry] of Object.entries(meta)) {
+                  if (metaKey.startsWith(oldPrefix) && metaEntry && typeof metaEntry === "object") {
+                    const relPath = metaKey.slice(oldPrefix.length);
+                    const localPath = path7.join(absolutePath, relPath);
+                    try {
+                      await fs7.access(localPath);
+                    } catch {
+                      cloudOnlyFiles.push({
+                        oldKey: metaKey,
+                        newKey: newPrefix + relPath,
+                        entry: metaEntry
+                      });
+                    }
+                  }
+                }
+                for (const localFile of localFiles) {
+                  if (isCancelled()) {
+                    await saveMeta(meta);
+                    sendEvent({ type: "complete", moved: moved.length, errors: errors.length, errorMessages: errors, cancelled: true });
+                    controller.close();
+                    return;
+                  }
+                  const fileOldPath = path7.join(absolutePath, localFile.relativePath);
+                  const fileNewPath = path7.join(newAbsolutePath, localFile.relativePath);
+                  const fileOldKey = oldPrefix + localFile.relativePath;
+                  const fileNewKey = newPrefix + localFile.relativePath;
+                  const fileEntry = meta[fileOldKey];
+                  sourceFolders.add(path7.dirname(fileOldPath));
+                  await fs7.mkdir(path7.dirname(fileNewPath), { recursive: true });
+                  await fs7.rename(fileOldPath, fileNewPath);
+                  if (localFile.isImage && fileEntry) {
+                    const oldThumbPaths = getAllThumbnailPaths(fileOldKey);
+                    const newThumbPaths = getAllThumbnailPaths(fileNewKey);
+                    for (let t = 0; t < oldThumbPaths.length; t++) {
+                      const oldThumbPath = getPublicPath(oldThumbPaths[t]);
+                      const newThumbPath = getPublicPath(newThumbPaths[t]);
+                      try {
+                        await fs7.access(oldThumbPath);
+                        sourceFolders.add(path7.dirname(oldThumbPath));
+                        await fs7.mkdir(path7.dirname(newThumbPath), { recursive: true });
+                        await fs7.rename(oldThumbPath, newThumbPath);
+                      } catch {
+                      }
+                    }
+                    const fileIsInCloud = fileEntry.c !== void 0;
+                    const fileCdnUrl2 = fileIsInCloud ? cdnUrls[fileEntry.c] : void 0;
+                    const fileIsInR2 = fileIsInCloud && fileCdnUrl2 === r2PublicUrl;
+                    const fileHasThumbs = isProcessed(fileEntry);
+                    if (fileIsInR2) {
+                      await moveInCdn(fileOldKey, fileNewKey, fileHasThumbs);
+                    }
+                    delete meta[fileOldKey];
+                    meta[fileNewKey] = fileEntry;
+                  }
+                  processedFiles++;
+                  sendEvent({
+                    type: "progress",
+                    current: processedFiles,
+                    total: totalFiles,
+                    moved: moved.length,
+                    percent: Math.round(processedFiles / totalFiles * 100),
+                    currentFile: path7.basename(localFile.relativePath)
+                  });
+                }
+                for (const cloudFile of cloudOnlyFiles) {
+                  if (isCancelled()) {
+                    await saveMeta(meta);
+                    sendEvent({ type: "complete", moved: moved.length, errors: errors.length, errorMessages: errors, cancelled: true });
+                    controller.close();
+                    return;
+                  }
+                  const cloudEntry = cloudFile.entry;
+                  const cloudIsInCloud = cloudEntry.c !== void 0;
+                  const cloudCdnUrl = cloudIsInCloud ? cdnUrls[cloudEntry.c] : void 0;
+                  const cloudIsInR2 = cloudIsInCloud && cloudCdnUrl === r2PublicUrl;
+                  const cloudHasThumbs = isProcessed(cloudEntry);
+                  let cloudFileMoved = false;
+                  if (cloudIsInR2) {
+                    try {
+                      await moveInCdn(cloudFile.oldKey, cloudFile.newKey, cloudHasThumbs);
+                      cloudFileMoved = true;
+                    } catch (err) {
+                      console.error(`Failed to move cloud file ${cloudFile.oldKey}:`, err);
+                      delete meta[cloudFile.oldKey];
+                    }
+                  }
+                  if (cloudFileMoved) {
+                    delete meta[cloudFile.oldKey];
+                    meta[cloudFile.newKey] = cloudEntry;
+                  }
+                  processedFiles++;
+                  sendEvent({
+                    type: "progress",
+                    current: processedFiles,
+                    total: totalFiles,
+                    moved: moved.length,
+                    percent: Math.round(processedFiles / totalFiles * 100),
+                    currentFile: path7.basename(cloudFile.newKey)
+                  });
+                }
+                sourceFolders.add(absolutePath);
+                const oldThumbRelPath = oldKey.slice(1);
+                const oldThumbFolder = path7.join(getPublicPath("images"), oldThumbRelPath);
+                sourceFolders.add(oldThumbFolder);
+                moved.push(itemPath);
+              }
             }
-            await fs7.unlink(localPath);
-            delete entry.u;
-            pushed.push(key);
-            sendEvent({
-              type: "progress",
-              current: i + 1,
-              total,
-              pushed: pushed.length,
-              percent: Math.round((i + 1) / total * 100),
-              currentFile: path7.basename(key)
-            });
-          } catch (error) {
-            console.error(`Failed to push update for ${key}:`, error);
-            errors.push(key);
+          } catch (err) {
+            console.error(`Failed to move ${itemName}:`, err);
+            errors.push(`Failed to move ${itemName}`);
+            processedFiles++;
             sendEvent({
               type: "progress",
-              current: i + 1,
-              total,
-              pushed: pushed.length,
-              percent: Math.round((i + 1) / total * 100),
-              currentFile: path7.basename(key),
-              message: `Failed: ${path7.basename(key)}`
+              current: processedFiles,
+              total: totalFiles,
+              moved: moved.length,
+              percent: Math.round(processedFiles / totalFiles * 100),
+              currentFile: itemName
             });
           }
         }
-        sendEvent({ type: "cleanup", message: "Cleaning up..." });
-        for (const itemPath of pushed) {
-          const localPath = getPublicPath(itemPath);
-          await deleteEmptyFolders(path7.dirname(localPath));
-        }
         await saveMeta(meta);
-        let message = `Pushed ${pushed.length} update${pushed.length !== 1 ? "s" : ""} to cloud.`;
-        if (skipped.length > 0) {
-          message += ` ${skipped.length} file${skipped.length !== 1 ? "s" : ""} skipped.`;
-        }
-        if (errors.length > 0) {
-          message += ` ${errors.length} file${errors.length !== 1 ? "s" : ""} failed.`;
+        for (const folder of sourceFolders) {
+          await deleteEmptyFolders(folder);
         }
+        await deleteEmptyFolders(absoluteDestination);
         sendEvent({
           type: "complete",
-          pushed: pushed.length,
-          skipped: skipped.length,
+          moved: moved.length,
           errors: errors.length,
-          message
+          errorMessages: errors
         });
       } catch (error) {
-        console.error("Push updates error:", error);
-        sendEvent({ type: "error", message: "Failed to push updates" });
+        console.error("Failed to move:", error);
+        sendEvent({ type: "error", message: "Failed to move items" });
       } finally {
         controller.close();
       }
@@ -2753,63 +2840,6 @@ async function handlePushUpdatesStream(request) {
     }
   });
 }
-async function handleCancelStreamOperation(request) {
-  try {
-    const { operationId } = await request.json();
-    if (!operationId || typeof operationId !== "string") {
-      return jsonResponse({ error: "No operation ID provided" }, { status: 400 });
-    }
-    cancelOperation(operationId);
-    return jsonResponse({ success: true, operationId });
-  } catch (error) {
-    console.error("Failed to cancel operation:", error);
-    return jsonResponse({ error: "Failed to cancel operation" }, { status: 500 });
-  }
-}
-async function handleCancelUpdates(request) {
-  try {
-    const { paths } = await request.json();
-    if (!paths || !Array.isArray(paths) || paths.length === 0) {
-      return jsonResponse({ error: "No paths provided" }, { status: 400 });
-    }
-    const meta = await loadMeta();
-    const cancelled = [];
-    const skipped = [];
-    const errors = [];
-    const foldersToClean = /* @__PURE__ */ new Set();
-    for (const itemPath of paths) {
-      const key = itemPath.startsWith("public/") ? "/" + itemPath.slice(7) : itemPath;
-      const entry = meta[key];
-      if (!entry || entry.u !== 1) {
-        skipped.push(key);
-        continue;
-      }
-      try {
-        const localPath = getPublicPath(key);
-        await fs7.unlink(localPath);
-        foldersToClean.add(path7.dirname(localPath));
-        delete entry.u;
-        cancelled.push(key);
-      } catch (error) {
-        console.error(`Failed to cancel update for ${key}:`, error);
-        errors.push(key);
-      }
-    }
-    for (const folder of foldersToClean) {
-      await deleteEmptyFolders(folder);
-    }
-    await saveMeta(meta);
-    return jsonResponse({
-      success: true,
-      cancelled: cancelled.length,
-      skipped: skipped.length,
-      errors: errors.length
-    });
-  } catch (error) {
-    console.error("Cancel updates error:", error);
-    return jsonResponse({ error: "Failed to cancel updates" }, { status: 500 });
-  }
-}
 
 // src/handlers/scan.ts
 import { promises as fs8 } from "fs";