@gallop.software/studio 0.1.72 → 0.1.74

package/dist/handlers.mjs

@@ -1,3 +1,7 @@
+import {
+  getAllThumbnailPaths
+} from "./chunk-3RI33B7A.mjs";
+
 // src/handlers.ts
 import { NextResponse } from "next/server";
 import { promises as fs } from "fs";
@@ -252,9 +256,9 @@ async function handleScan() {
     const validFiles = [];
     const imagesDir = path.join(process.cwd(), "public", "images");
     const trackedPaths = /* @__PURE__ */ new Set();
-    for (const entry of Object.values(meta.images)) {
-      for (const sizeData of Object.values(entry.sizes)) {
-        trackedPaths.add(sizeData.path);
+    for (const imageKey of Object.keys(meta)) {
+      for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+        trackedPaths.add(thumbPath);
       }
     }
     async function scanDir(dir, relativePath = "") {
@@ -279,20 +283,20 @@ async function handleScan() {
       }
     }
     await scanDir(imagesDir);
-    for (const [key, entry] of Object.entries(meta.images)) {
-      for (const [size, sizeData] of Object.entries(entry.sizes)) {
-        const filePath = path.join(process.cwd(), "public", sizeData.path);
+    for (const [imageKey, entry] of Object.entries(meta)) {
+      if (entry.s) continue;
+      for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+        const filePath = path.join(process.cwd(), "public", thumbPath);
         try {
           await fs.access(filePath);
         } catch {
-          if (!entry.cdn?.synced) {
-            missingFiles.push(`${key} (${size}): ${sizeData.path}`);
-          }
+          missingFiles.push(`${imageKey}: ${thumbPath}`);
+          break;
         }
       }
     }
     return NextResponse.json({
-      totalInMeta: Object.keys(meta.images).length,
+      totalInMeta: Object.keys(meta).length,
       validFiles: validFiles.length,
       untrackedFiles,
       missingFiles
@@ -319,9 +323,6 @@ async function handleUpload(request) {
     const isSvg = ext === ".svg";
     const isProcessableImage = isImage && !isSvg;
     const meta = await loadMeta();
-    if (!meta.images) {
-      meta.images = {};
-    }
     let relativeDir = "";
     if (targetPath === "public") {
       relativeDir = "";
@@ -344,10 +345,10 @@ async function handleUpload(request) {
         path: `public/${relativeDir ? relativeDir + "/" : ""}${fileName}`
       });
     }
-    const fullImageKey = relativeDir ? `${relativeDir}/${fileName}` : fileName;
-    if (meta.images[fullImageKey]) {
+    const imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
+    if (meta[imageKey]) {
       return NextResponse.json(
-        { error: `File '${fullImageKey}' already exists in meta` },
+        { error: `File '${imageKey}' already exists in meta` },
         { status: 409 }
       );
     }
@@ -356,21 +357,10 @@ async function handleUpload(request) {
     let originalWidth = 0;
     let originalHeight = 0;
     let blurhash = "";
-    let dominantColor = "#888888";
-    const sizes = {
-      full: { path: "", width: 0, height: 0 },
-      large: { path: "", width: 0, height: 0 },
-      medium: { path: "", width: 0, height: 0 },
-      small: { path: "", width: 0, height: 0 }
-    };
     const originalPath = `/${relativeDir ? relativeDir + "/" : ""}${fileName}`;
     if (isSvg) {
       const fullPath = path.join(imagesPath, fileName);
       await fs.writeFile(fullPath, buffer);
-      sizes.full = { path: `/images/${relativeDir ? relativeDir + "/" : ""}${fileName}`, width: 0, height: 0 };
-      sizes.large = { ...sizes.full };
-      sizes.medium = { ...sizes.full };
-      sizes.small = { ...sizes.full };
     } else if (isProcessableImage) {
       const sharpInstance = sharp(buffer);
       const metadata = await sharpInstance.metadata();
@@ -384,11 +374,9 @@ async function handleUpload(request) {
       } else {
         await sharp(buffer).jpeg({ quality: 85 }).toFile(fullPath);
       }
-      sizes.full = { path: `/images/${relativeDir ? relativeDir + "/" : ""}${fullFileName}`, width: originalWidth, height: originalHeight };
-      for (const [sizeName, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
+      for (const [, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
         const { width: maxWidth, suffix } = sizeConfig;
         if (originalWidth <= maxWidth) {
-          sizes[sizeName] = { ...sizes.full };
           continue;
         }
         const ratio = originalHeight / originalWidth;
@@ -400,32 +388,18 @@ async function handleUpload(request) {
         } else {
           await sharp(buffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
         }
-        sizes[sizeName] = {
-          path: `/images/${relativeDir ? relativeDir + "/" : ""}${sizeFileName}`,
-          width: maxWidth,
-          height: newHeight
-        };
       }
       const { data, info } = await sharp(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
       blurhash = encode(new Uint8ClampedArray(data), info.width, info.height, 4, 4);
-      const { dominant } = await sharp(buffer).stats();
-      dominantColor = `#${dominant.r.toString(16).padStart(2, "0")}${dominant.g.toString(16).padStart(2, "0")}${dominant.b.toString(16).padStart(2, "0")}`;
     }
     const entry = {
-      original: {
-        path: originalPath,
-        width: originalWidth,
-        height: originalHeight,
-        fileSize: buffer.length
-      },
-      sizes,
-      blurhash,
-      dominantColor,
-      cdn: null
+      w: originalWidth,
+      h: originalHeight,
+      blur: blurhash
     };
-    meta.images[fullImageKey] = entry;
+    meta[originalPath] = entry;
     await saveMeta(meta);
-    return NextResponse.json({ success: true, imageKey: fullImageKey, entry });
+    return NextResponse.json({ success: true, imageKey: originalPath, entry });
   } catch (error) {
     console.error("Failed to upload:", error);
     const message = error instanceof Error ? error.message : "Unknown error";
@@ -451,27 +425,26 @@ async function handleDelete(request) {
         const stats = await fs.stat(absolutePath);
         if (stats.isDirectory()) {
           await fs.rm(absolutePath, { recursive: true });
-          const prefix = itemPath.replace(/^public\/images\/?/, "").replace(/^public\/?/, "");
-          for (const key of Object.keys(meta.images)) {
+          const prefix = "/" + itemPath.replace(/^public\/images\/?/, "").replace(/^public\/?/, "");
+          for (const key of Object.keys(meta)) {
             if (key.startsWith(prefix)) {
-              delete meta.images[key];
+              delete meta[key];
             }
           }
         } else {
           await fs.unlink(absolutePath);
           const isInImagesFolder = itemPath.startsWith("public/images/");
           if (!isInImagesFolder) {
-            const imageKey = itemPath.replace(/^public\//, "");
-            const entry = meta.images[imageKey];
-            if (entry) {
-              for (const sizeData of Object.values(entry.sizes)) {
-                const sizePath = path.join(process.cwd(), "public", sizeData.path);
+            const imageKey = "/" + itemPath.replace(/^public\//, "");
+            if (meta[imageKey]) {
+              for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+                const absoluteThumbPath = path.join(process.cwd(), "public", thumbPath);
                 try {
-                  await fs.unlink(sizePath);
+                  await fs.unlink(absoluteThumbPath);
                 } catch {
                 }
               }
-              delete meta.images[imageKey];
+              delete meta[imageKey];
             }
           }
         }
@@ -518,35 +491,34 @@ async function handleSync(request) {
     const synced = [];
     const errors = [];
     for (const imageKey of imageKeys) {
-      const entry = meta.images[imageKey];
+      const entry = meta[imageKey];
       if (!entry) {
         errors.push(`Image not found in meta: ${imageKey}`);
         continue;
       }
-      if (entry.cdn?.synced) {
+      if (entry.s) {
         synced.push(imageKey);
         continue;
       }
       try {
-        for (const sizeData of Object.values(entry.sizes)) {
-          const localPath = path.join(process.cwd(), "public", sizeData.path);
-          const fileBuffer = await fs.readFile(localPath);
-          await r2.send(
-            new PutObjectCommand({
-              Bucket: bucketName,
-              Key: sizeData.path.replace(/^\//, ""),
-              Body: fileBuffer,
-              ContentType: getContentType(sizeData.path)
-            })
-          );
+        for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+          const localPath = path.join(process.cwd(), "public", thumbPath);
+          try {
+            const fileBuffer = await fs.readFile(localPath);
+            await r2.send(
+              new PutObjectCommand({
+                Bucket: bucketName,
+                Key: thumbPath.replace(/^\//, ""),
+                Body: fileBuffer,
+                ContentType: getContentType(thumbPath)
+              })
+            );
+          } catch {
+          }
         }
-        entry.cdn = {
-          synced: true,
-          baseUrl: publicUrl,
-          syncedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        for (const sizeData of Object.values(entry.sizes)) {
-          const localPath = path.join(process.cwd(), "public", sizeData.path);
+        entry.s = 1;
+        for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+          const localPath = path.join(process.cwd(), "public", thumbPath);
           try {
             await fs.unlink(localPath);
           } catch {
@@ -581,54 +553,24 @@ async function handleReprocess(request) {
     for (const imageKey of imageKeys) {
       try {
         let buffer;
-        let entry = meta.images[imageKey];
+        const entry = meta[imageKey];
         const originalPath = path.join(process.cwd(), "public", imageKey);
         try {
           buffer = await fs.readFile(originalPath);
         } catch {
-          if (entry) {
-            const entryOriginalPath = path.join(process.cwd(), "public", entry.original.path);
-            try {
-              buffer = await fs.readFile(entryOriginalPath);
-            } catch {
-              if (entry.cdn?.synced) {
-                buffer = await downloadFromCdn(entry.original.path);
-              } else {
-                throw new Error("Original not found locally and not on CDN");
-              }
-            }
+          if (entry?.s) {
+            buffer = await downloadFromCdn(imageKey);
           } else {
             throw new Error(`File not found: ${imageKey}`);
           }
         }
-        if (!entry) {
-          const sharpInstance = sharp(buffer);
-          const metadata = await sharpInstance.metadata();
-          const stats = await fs.stat(originalPath);
-          entry = {
-            original: {
-              path: imageKey,
-              width: metadata.width || 0,
-              height: metadata.height || 0,
-              fileSize: stats.size
-            },
-            sizes: {
-              full: { path: "", width: 0, height: 0 },
-              large: { path: "", width: 0, height: 0 },
-              medium: { path: "", width: 0, height: 0 },
-              small: { path: "", width: 0, height: 0 }
-            },
-            blurhash: "",
-            dominantColor: "#000000",
-            cdn: null
-          };
-        }
-        const updatedEntry = await processImage(buffer, entry, imageKey);
-        meta.images[imageKey] = updatedEntry;
-        if (entry.cdn?.synced) {
-          await uploadToCdn(updatedEntry);
-          await deleteLocalFiles(updatedEntry);
+        const updatedEntry = await processImage(buffer, imageKey);
+        if (entry?.s) {
+          updatedEntry.s = 1;
+          await uploadToCdn(imageKey);
+          await deleteLocalThumbnails(imageKey);
         }
+        meta[imageKey] = updatedEntry;
         processed.push(imageKey);
       } catch (error) {
         console.error(`Failed to reprocess ${imageKey}:`, error);
@@ -755,6 +697,7 @@ async function handleProcessAllStream() {
         sendEvent({ type: "start", total });
         for (let i = 0; i < allImages.length; i++) {
           const { key, fullPath } = allImages[i];
+          const imageKey = "/" + key;
           sendEvent({
             type: "progress",
             current: i + 1,
@@ -773,45 +716,18 @@ async function handleProcessAllStream() {
               const fileName = path.basename(key);
               const destPath = path.join(imagesPath, fileName);
               await fs.writeFile(destPath, buffer);
-              const sizePath = `/images/${imageDir === "." ? "" : imageDir + "/"}${fileName}`;
-              meta.images[key] = {
-                original: {
-                  path: `/${key}`,
-                  width: 0,
-                  height: 0,
-                  fileSize: buffer.length
-                },
-                sizes: {
-                  full: { path: sizePath, width: 0, height: 0 },
-                  large: { path: sizePath, width: 0, height: 0 },
-                  medium: { path: sizePath, width: 0, height: 0 },
-                  small: { path: sizePath, width: 0, height: 0 }
-                },
-                blurhash: "",
-                dominantColor: "#888888",
-                cdn: null
+              meta[imageKey] = {
+                w: 0,
+                h: 0,
+                blur: ""
               };
             } else {
-              const existingEntry = meta.images[key];
-              const baseEntry = existingEntry || {
-                original: {
-                  path: `/${key}`,
-                  width: 0,
-                  height: 0,
-                  fileSize: buffer.length
-                },
-                sizes: {
-                  full: { path: "", width: 0, height: 0 },
-                  large: { path: "", width: 0, height: 0 },
-                  medium: { path: "", width: 0, height: 0 },
-                  small: { path: "", width: 0, height: 0 }
-                },
-                blurhash: "",
-                dominantColor: "#888888",
-                cdn: null
-              };
-              const processedEntry = await processImage(buffer, baseEntry, key);
-              meta.images[key] = processedEntry;
+              const existingEntry = meta[imageKey];
+              const processedEntry = await processImage(buffer, imageKey);
+              if (existingEntry?.s) {
+                processedEntry.s = 1;
+              }
+              meta[imageKey] = processedEntry;
             }
             processed.push(key);
           } catch (error) {
@@ -821,9 +737,9 @@ async function handleProcessAllStream() {
         }
         sendEvent({ type: "cleanup", message: "Removing orphaned thumbnails..." });
         const trackedPaths = /* @__PURE__ */ new Set();
-        for (const entry of Object.values(meta.images)) {
-          for (const sizeData of Object.values(entry.sizes)) {
-            trackedPaths.add(sizeData.path);
+        for (const imageKey of Object.keys(meta)) {
+          for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+            trackedPaths.add(thumbPath);
           }
         }
         async function findOrphans(dir, relativePath = "") {
@@ -898,57 +814,18 @@ async function handleProcessAllStream() {
 }
 async function loadMeta() {
   const metaPath = path.join(process.cwd(), "_data", "_meta.json");
-  const emptyMeta = {
-    $schema: "https://gallop.software/schemas/studio-meta.json",
-    version: 1,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    images: {}
-  };
   try {
     const content = await fs.readFile(metaPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (parsed.images && typeof parsed.images === "object") {
-      return parsed;
-    }
-    const meta = { ...emptyMeta, images: {} };
-    for (const [imagePath, entry] of Object.entries(parsed)) {
-      const leanEntry = entry;
-      const key = imagePath.startsWith("/") ? imagePath.slice(1) : imagePath;
-      meta.images[key] = {
-        original: {
-          path: imagePath,
-          width: leanEntry.w,
-          height: leanEntry.h,
-          fileSize: 0
-        },
-        sizes: {},
-        blurhash: leanEntry.blur,
-        dominantColor: "",
-        cdn: leanEntry.s ? { synced: true, baseUrl: "", syncedAt: "" } : null
-      };
-    }
-    return meta;
+    return JSON.parse(content);
   } catch {
-    return emptyMeta;
+    return {};
   }
 }
 async function saveMeta(meta) {
   const dataDir = path.join(process.cwd(), "_data");
   await fs.mkdir(dataDir, { recursive: true });
-  const lean = {};
-  for (const [key, entry] of Object.entries(meta.images)) {
-    const imagePath = entry.original?.path || `/${key}`;
-    lean[imagePath] = {
-      w: entry.original?.width || 0,
-      h: entry.original?.height || 0,
-      blur: entry.blurhash || ""
-    };
-    if (entry.cdn?.synced) {
-      lean[imagePath].s = 1;
-    }
-  }
   const metaPath = path.join(dataDir, "_meta.json");
-  await fs.writeFile(metaPath, JSON.stringify(lean, null, 2));
+  await fs.writeFile(metaPath, JSON.stringify(meta, null, 2));
 }
 function isImageFile(filename) {
   const ext = path.extname(filename).toLowerCase();
@@ -980,22 +857,17 @@ function getContentType(filePath) {
       return "application/octet-stream";
   }
 }
-async function processImage(buffer, entry, imageKey) {
+async function processImage(buffer, imageKey) {
   const sharpInstance = sharp(buffer);
   const metadata = await sharpInstance.metadata();
   const originalWidth = metadata.width || 0;
   const originalHeight = metadata.height || 0;
-  const baseName = path.basename(imageKey, path.extname(imageKey));
-  const ext = path.extname(imageKey).toLowerCase();
-  const imageDir = path.dirname(imageKey);
+  const keyWithoutSlash = imageKey.startsWith("/") ? imageKey.slice(1) : imageKey;
+  const baseName = path.basename(keyWithoutSlash, path.extname(keyWithoutSlash));
+  const ext = path.extname(keyWithoutSlash).toLowerCase();
+  const imageDir = path.dirname(keyWithoutSlash);
   const imagesPath = path.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
   await fs.mkdir(imagesPath, { recursive: true });
-  const sizes = {
-    full: { path: "", width: originalWidth, height: originalHeight },
-    large: { path: "", width: 0, height: 0 },
-    medium: { path: "", width: 0, height: 0 },
-    small: { path: "", width: 0, height: 0 }
-  };
   const isPng = ext === ".png";
   const outputExt = isPng ? ".png" : ".jpg";
   const fullFileName = imageDir === "." ? `${baseName}${outputExt}` : `${imageDir}/${baseName}${outputExt}`;
@@ -1005,11 +877,9 @@ async function processImage(buffer, entry, imageKey) {
   } else {
     await sharp(buffer).jpeg({ quality: 85 }).toFile(fullPath);
   }
-  sizes.full.path = `/images/${fullFileName}`;
-  for (const [sizeName, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
+  for (const [, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
     const { width: maxWidth, suffix } = sizeConfig;
     if (originalWidth <= maxWidth) {
-      sizes[sizeName] = { ...sizes.full };
       continue;
     }
     const ratio = originalHeight / originalWidth;
@@ -1022,27 +892,13 @@ async function processImage(buffer, entry, imageKey) {
     } else {
       await sharp(buffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
     }
-    sizes[sizeName] = {
-      path: `/images/${sizeFilePath}`,
-      width: maxWidth,
-      height: newHeight
-    };
   }
   const { data, info } = await sharp(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
   const blurhash = encode(new Uint8ClampedArray(data), info.width, info.height, 4, 4);
-  const { dominant } = await sharp(buffer).stats();
-  const dominantColor = `#${dominant.r.toString(16).padStart(2, "0")}${dominant.g.toString(16).padStart(2, "0")}${dominant.b.toString(16).padStart(2, "0")}`;
   return {
-    ...entry,
-    original: {
-      ...entry.original,
-      width: originalWidth,
-      height: originalHeight,
-      fileSize: buffer.length
-    },
-    sizes,
-    blurhash,
-    dominantColor
+    w: originalWidth,
+    h: originalHeight,
+    blur: blurhash
   };
 }
 async function downloadFromCdn(originalPath) {
@@ -1071,7 +927,7 @@ async function downloadFromCdn(originalPath) {
   }
   return Buffer.concat(chunks);
 }
-async function uploadToCdn(entry) {
+async function uploadToCdn(imageKey) {
   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;
@@ -1084,22 +940,25 @@ async function uploadToCdn(entry) {
     endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
     credentials: { accessKeyId, secretAccessKey }
   });
-  for (const sizeData of Object.values(entry.sizes)) {
-    const localPath = path.join(process.cwd(), "public", sizeData.path);
-    const fileBuffer = await fs.readFile(localPath);
-    await r2.send(
-      new PutObjectCommand({
-        Bucket: bucketName,
-        Key: sizeData.path.replace(/^\//, ""),
-        Body: fileBuffer,
-        ContentType: getContentType(sizeData.path)
-      })
-    );
+  for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+    const localPath = path.join(process.cwd(), "public", thumbPath);
+    try {
+      const fileBuffer = await fs.readFile(localPath);
+      await r2.send(
+        new PutObjectCommand({
+          Bucket: bucketName,
+          Key: thumbPath.replace(/^\//, ""),
+          Body: fileBuffer,
+          ContentType: getContentType(thumbPath)
+        })
+      );
+    } catch {
+    }
   }
 }
-async function deleteLocalFiles(entry) {
-  for (const sizeData of Object.values(entry.sizes)) {
-    const localPath = path.join(process.cwd(), "public", sizeData.path);
+async function deleteLocalThumbnails(imageKey) {
+  for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+    const localPath = path.join(process.cwd(), "public", thumbPath);
     try {
       await fs.unlink(localPath);
     } catch {
@@ -1168,32 +1027,23 @@ async function handleRename(request) {
       const meta = await loadMeta();
       const oldRelativePath = safePath.replace(/^public\//, "");
       const newRelativePath = path.join(path.dirname(oldRelativePath), sanitizedName);
-      for (const [key, entry] of Object.entries(meta.images)) {
-        if (entry.original.path === `/${oldRelativePath}`) {
-          entry.original.path = `/${newRelativePath}`;
-          const oldExt = path.extname(path.basename(oldPath));
-          const oldBaseName = path.basename(oldPath, oldExt);
-          const newExt = path.extname(sanitizedName);
-          const newBaseName = path.basename(sanitizedName, newExt);
-          const oldDirRelative = path.dirname(oldRelativePath);
-          const thumbnailDir = path.join(process.cwd(), "public", "images", oldDirRelative);
-          for (const [sizeName, sizeData] of Object.entries(entry.sizes)) {
-            const suffix = DEFAULT_SIZES[sizeName]?.suffix || `-${sizeName}`;
-            const oldThumbName = `${oldBaseName}${suffix}${oldExt === ".png" ? ".png" : ".jpg"}`;
-            const newThumbName = `${newBaseName}${suffix}${newExt === ".png" ? ".png" : ".jpg"}`;
-            const oldThumbPath = path.join(thumbnailDir, oldThumbName);
-            const newThumbPath = path.join(thumbnailDir, newThumbName);
-            try {
-              await fs.rename(oldThumbPath, newThumbPath);
-              sizeData.path = `/images/${oldDirRelative}/${newThumbName}`.replace(/\/+/g, "/");
-            } catch {
-            }
+      const oldKey = "/" + oldRelativePath;
+      const newKey = "/" + newRelativePath;
+      if (meta[oldKey]) {
+        const entry = meta[oldKey];
+        const oldThumbPaths = getAllThumbnailPaths(oldKey);
+        const newThumbPaths = getAllThumbnailPaths(newKey);
+        for (let i = 0; i < oldThumbPaths.length; i++) {
+          const oldThumbPath = path.join(process.cwd(), "public", oldThumbPaths[i]);
+          const newThumbPath = path.join(process.cwd(), "public", newThumbPaths[i]);
+          await fs.mkdir(path.dirname(newThumbPath), { recursive: true });
+          try {
+            await fs.rename(oldThumbPath, newThumbPath);
+          } catch {
           }
-          const newKey = `/${newRelativePath}`;
-          delete meta.images[key];
-          meta.images[newKey] = entry;
-          break;
         }
+        delete meta[oldKey];
+        meta[newKey] = entry;
       }
       await saveMeta(meta);
     }
@@ -1260,33 +1110,24 @@ async function handleMove(request) {
         if (stats.isFile() && isImageFile(itemName)) {
           const oldRelativePath = safePath.replace(/^public\//, "");
           const newRelativePath = path.join(safeDestination.replace(/^public\//, ""), itemName);
-          for (const [key, entry] of Object.entries(meta.images)) {
-            if (entry.original.path === `/${oldRelativePath}`) {
-              entry.original.path = `/${newRelativePath}`;
-              const oldDir = path.dirname(oldRelativePath);
-              const newDir = path.dirname(newRelativePath);
-              const ext = path.extname(itemName);
-              const baseName = path.basename(itemName, ext);
-              const oldThumbDir = path.join(process.cwd(), "public", "images", oldDir);
-              const newThumbDir = path.join(process.cwd(), "public", "images", newDir);
-              await fs.mkdir(newThumbDir, { recursive: true });
-              for (const [sizeName, sizeData] of Object.entries(entry.sizes)) {
-                const suffix = DEFAULT_SIZES[sizeName]?.suffix || `-${sizeName}`;
-                const thumbName = `${baseName}${suffix}${ext === ".png" ? ".png" : ".jpg"}`;
-                const oldThumbPath = path.join(oldThumbDir, thumbName);
-                const newThumbPath = path.join(newThumbDir, thumbName);
-                try {
-                  await fs.rename(oldThumbPath, newThumbPath);
-                  sizeData.path = `/images/${newDir}/${thumbName}`.replace(/\/+/g, "/");
-                } catch {
-                }
+          const oldKey = "/" + oldRelativePath;
+          const newKey = "/" + newRelativePath;
+          if (meta[oldKey]) {
+            const entry = meta[oldKey];
+            const oldThumbPaths = getAllThumbnailPaths(oldKey);
+            const newThumbPaths = getAllThumbnailPaths(newKey);
+            for (let i = 0; i < oldThumbPaths.length; i++) {
+              const oldThumbPath = path.join(process.cwd(), "public", oldThumbPaths[i]);
+              const newThumbPath = path.join(process.cwd(), "public", newThumbPaths[i]);
+              await fs.mkdir(path.dirname(newThumbPath), { recursive: true });
+              try {
+                await fs.rename(oldThumbPath, newThumbPath);
+              } catch {
               }
-              const newKey = `/${newRelativePath}`;
-              delete meta.images[key];
-              meta.images[newKey] = entry;
-              metaChanged = true;
-              break;
             }
+            delete meta[oldKey];
+            meta[newKey] = entry;
+            metaChanged = true;
           }
         }
         moved.push(itemPath);