@gallop.software/studio 0.1.80 → 0.1.82

package/dist/{handlers.mjs → handlers/index.mjs}

@@ -1,96 +1,228 @@
 import {
   getAllThumbnailPaths
-} from "./chunk-3RI33B7A.mjs";
+} from "../chunk-3RI33B7A.mjs";
 
-// src/handlers.ts
+// src/handlers/index.ts
+import { NextResponse as NextResponse4 } from "next/server";
+
+// src/handlers/list.ts
 import { NextResponse } from "next/server";
+import { promises as fs5 } from "fs";
+import path5 from "path";
+import sharp2 from "sharp";
+
+// src/handlers/utils/meta.ts
 import { promises as fs } from "fs";
 import path from "path";
+async function loadMeta() {
+  const metaPath = path.join(process.cwd(), "_data", "_meta.json");
+  try {
+    const content = await fs.readFile(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function saveMeta(meta) {
+  const dataDir = path.join(process.cwd(), "_data");
+  await fs.mkdir(dataDir, { recursive: true });
+  const metaPath = path.join(dataDir, "_meta.json");
+  await fs.writeFile(metaPath, JSON.stringify(meta, null, 2));
+}
+
+// src/handlers/utils/files.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+function isImageFile(filename) {
+  const ext = path2.extname(filename).toLowerCase();
+  return [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".ico", ".bmp", ".tiff", ".tif"].includes(ext);
+}
+function isMediaFile(filename) {
+  const ext = path2.extname(filename).toLowerCase();
+  if ([".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".ico", ".bmp", ".tiff", ".tif"].includes(ext)) return true;
+  if ([".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v"].includes(ext)) return true;
+  if ([".mp3", ".wav", ".ogg", ".m4a", ".flac", ".aac"].includes(ext)) return true;
+  if ([".pdf"].includes(ext)) return true;
+  return false;
+}
+function getContentType(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".png":
+      return "image/png";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    case ".svg":
+      return "image/svg+xml";
+    default:
+      return "application/octet-stream";
+  }
+}
+async function getFolderStats(folderPath) {
+  let fileCount = 0;
+  let totalSize = 0;
+  async function scanFolder(dir) {
+    try {
+      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = path2.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await scanFolder(fullPath);
+        } else if (isMediaFile(entry.name)) {
+          fileCount++;
+          const stats = await fs2.stat(fullPath);
+          totalSize += stats.size;
+        }
+      }
+    } catch {
+    }
+  }
+  await scanFolder(folderPath);
+  return { fileCount, totalSize };
+}
+
+// src/handlers/utils/thumbnails.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
 import sharp from "sharp";
 import { encode } from "blurhash";
-import { S3Client, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
 var DEFAULT_SIZES = {
   small: { width: 300, suffix: "-sm" },
   medium: { width: 700, suffix: "-md" },
   large: { width: 1400, suffix: "-lg" }
 };
-async function GET(request) {
-  if (process.env.NODE_ENV !== "development") {
-    return NextResponse.json({ error: "Not available in production" }, { status: 403 });
-  }
-  const pathname = request.nextUrl.pathname;
-  const route = pathname.replace(/^\/api\/studio\/?/, "");
-  if (route === "list-folders") {
-    return handleListFolders();
-  }
-  if (route === "list" || route.startsWith("list")) {
-    return handleList(request);
-  }
-  if (route === "count-images") {
-    return handleCountImages();
-  }
-  if (route === "folder-images") {
-    return handleFolderImages(request);
+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 keyWithoutSlash = imageKey.startsWith("/") ? imageKey.slice(1) : imageKey;
+  const baseName = path3.basename(keyWithoutSlash, path3.extname(keyWithoutSlash));
+  const ext = path3.extname(keyWithoutSlash).toLowerCase();
+  const imageDir = path3.dirname(keyWithoutSlash);
+  const imagesPath = path3.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
+  await fs3.mkdir(imagesPath, { recursive: true });
+  const isPng = ext === ".png";
+  const outputExt = isPng ? ".png" : ".jpg";
+  const fullFileName = imageDir === "." ? `${baseName}${outputExt}` : `${imageDir}/${baseName}${outputExt}`;
+  const fullPath = path3.join(process.cwd(), "public", "images", fullFileName);
+  if (isPng) {
+    await sharp(buffer).png({ quality: 85 }).toFile(fullPath);
+  } else {
+    await sharp(buffer).jpeg({ quality: 85 }).toFile(fullPath);
   }
-  if (route === "search") {
-    return handleSearch(request);
+  for (const [, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
+    const { width: maxWidth, suffix } = sizeConfig;
+    if (originalWidth <= maxWidth) {
+      continue;
+    }
+    const ratio = originalHeight / originalWidth;
+    const newHeight = Math.round(maxWidth * ratio);
+    const sizeFileName = `${baseName}${suffix}${outputExt}`;
+    const sizeFilePath = imageDir === "." ? sizeFileName : `${imageDir}/${sizeFileName}`;
+    const sizePath = path3.join(process.cwd(), "public", "images", sizeFilePath);
+    if (isPng) {
+      await sharp(buffer).resize(maxWidth, newHeight).png({ quality: 80 }).toFile(sizePath);
+    } else {
+      await sharp(buffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
+    }
   }
-  return NextResponse.json({ error: "Not found" }, { status: 404 });
+  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);
+  return {
+    w: originalWidth,
+    h: originalHeight,
+    blur: blurhash
+  };
 }
-async function POST(request) {
-  if (process.env.NODE_ENV !== "development") {
-    return NextResponse.json({ error: "Not available in production" }, { status: 403 });
-  }
-  const pathname = request.nextUrl.pathname;
-  const route = pathname.replace(/^\/api\/studio\/?/, "");
-  if (route === "upload") {
-    return handleUpload(request);
-  }
-  if (route === "delete") {
-    return handleDelete(request);
-  }
-  if (route === "sync") {
-    return handleSync(request);
-  }
-  if (route === "reprocess") {
-    return handleReprocess(request);
-  }
-  if (route === "process-all") {
-    return handleProcessAllStream();
-  }
-  if (route === "create-folder") {
-    return handleCreateFolder(request);
+
+// src/handlers/utils/cdn.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+import { S3Client, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+function getR2Client() {
+  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;
+  if (!accountId || !accessKeyId || !secretAccessKey) {
+    throw new Error("R2 not configured");
   }
-  if (route === "rename") {
-    return handleRename(request);
+  return new S3Client({
+    region: "auto",
+    endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+    credentials: { accessKeyId, secretAccessKey }
+  });
+}
+async function downloadFromCdn(originalPath) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  const response = await r2.send(
+    new GetObjectCommand({
+      Bucket: bucketName,
+      Key: originalPath.replace(/^\//, "")
+    })
+  );
+  const stream = response.Body;
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
   }
-  if (route === "move") {
-    return handleMove(request);
+  return Buffer.concat(chunks);
+}
+async function uploadToCdn(imageKey) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+    const localPath = path4.join(process.cwd(), "public", thumbPath);
+    try {
+      const fileBuffer = await fs4.readFile(localPath);
+      await r2.send(
+        new PutObjectCommand({
+          Bucket: bucketName,
+          Key: thumbPath.replace(/^\//, ""),
+          Body: fileBuffer,
+          ContentType: getContentType(thumbPath)
+        })
+      );
+    } catch {
+    }
   }
-  return NextResponse.json({ error: "Not found" }, { status: 404 });
 }
-async function DELETE(request) {
-  if (process.env.NODE_ENV !== "development") {
-    return NextResponse.json({ error: "Not available in production" }, { status: 403 });
+async function deleteLocalThumbnails(imageKey) {
+  for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+    const localPath = path4.join(process.cwd(), "public", thumbPath);
+    try {
+      await fs4.unlink(localPath);
+    } catch {
+    }
   }
-  return handleDelete(request);
 }
+
+// src/handlers/list.ts
 async function handleList(request) {
   const searchParams = request.nextUrl.searchParams;
   const requestedPath = searchParams.get("path") || "public";
   try {
     const safePath = requestedPath.replace(/\.\./g, "");
-    const absolutePath = path.join(process.cwd(), safePath);
+    const absolutePath = path5.join(process.cwd(), safePath);
     if (!absolutePath.startsWith(process.cwd())) {
       return NextResponse.json({ error: "Invalid path" }, { status: 400 });
     }
     const items = [];
-    const entries = await fs.readdir(absolutePath, { withFileTypes: true });
+    const entries = await fs5.readdir(absolutePath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const itemPath = path.join(safePath, entry.name);
+      const itemPath = path5.join(safePath, entry.name);
       if (entry.isDirectory()) {
-        const folderStats = await getFolderStats(path.join(absolutePath, entry.name));
+        const folderStats = await getFolderStats(path5.join(absolutePath, entry.name));
         items.push({
           name: entry.name,
           path: itemPath,
@@ -99,8 +231,8 @@ async function handleList(request) {
           totalSize: folderStats.totalSize
         });
       } else if (isMediaFile(entry.name)) {
-        const filePath = path.join(absolutePath, entry.name);
-        const stats = await fs.stat(filePath);
+        const filePath = path5.join(absolutePath, entry.name);
+        const stats = await fs5.stat(filePath);
         const isImage = isImageFile(entry.name);
         let thumbnail;
         let hasThumbnail = false;
@@ -111,13 +243,13 @@ async function handleList(request) {
             thumbnail = itemPath.replace("public", "");
             hasThumbnail = true;
           } else {
-            const ext = path.extname(entry.name).toLowerCase();
-            const baseName = path.basename(entry.name, ext);
+            const ext = path5.extname(entry.name).toLowerCase();
+            const baseName = path5.basename(entry.name, ext);
             const thumbnailDir = relativePath ? `images/${relativePath}` : "images";
             const thumbnailName = `${baseName}-sm${ext === ".png" ? ".png" : ".jpg"}`;
-            const thumbnailPath = path.join(process.cwd(), "public", thumbnailDir, thumbnailName);
+            const thumbnailPath = path5.join(process.cwd(), "public", thumbnailDir, thumbnailName);
             try {
-              await fs.access(thumbnailPath);
+              await fs5.access(thumbnailPath);
               thumbnail = `/${thumbnailDir}/${thumbnailName}`;
               hasThumbnail = true;
             } catch {
@@ -127,7 +259,7 @@ async function handleList(request) {
           }
           if (!entry.name.toLowerCase().endsWith(".svg")) {
             try {
-              const metadata = await sharp(filePath).metadata();
+              const metadata = await sharp2(filePath).metadata();
               if (metadata.width && metadata.height) {
                 dimensions = { width: metadata.width, height: metadata.height };
               }
@@ -160,30 +292,30 @@ async function handleSearch(request) {
   }
   try {
     const items = [];
-    const publicDir = path.join(process.cwd(), "public");
+    const publicDir = path5.join(process.cwd(), "public");
     async function searchDir(dir, relativePath) {
       try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
+        const entries = await fs5.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.name.startsWith(".")) continue;
-          const fullPath = path.join(dir, entry.name);
+          const fullPath = path5.join(dir, entry.name);
           const itemPath = relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`;
           const itemRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             await searchDir(fullPath, itemRelPath);
           } else if (isImageFile(entry.name)) {
             if (itemPath.toLowerCase().includes(query)) {
-              const stats = await fs.stat(fullPath);
+              const stats = await fs5.stat(fullPath);
               let thumbnail;
               let hasThumbnail = false;
               let dimensions;
-              const ext = path.extname(entry.name).toLowerCase();
-              const baseName = path.basename(entry.name, ext);
+              const ext = path5.extname(entry.name).toLowerCase();
+              const baseName = path5.basename(entry.name, ext);
               const thumbnailDir = relativePath ? `images/${relativePath}` : "images";
               const thumbnailName = `${baseName}-sm${ext === ".png" ? ".png" : ".jpg"}`;
-              const thumbnailPath = path.join(process.cwd(), "public", thumbnailDir, thumbnailName);
+              const thumbnailPath = path5.join(process.cwd(), "public", thumbnailDir, thumbnailName);
               try {
-                await fs.access(thumbnailPath);
+                await fs5.access(thumbnailPath);
                 thumbnail = `/${thumbnailDir}/${thumbnailName}`;
                 hasThumbnail = true;
               } catch {
@@ -192,7 +324,7 @@ async function handleSearch(request) {
               }
               if (!entry.name.toLowerCase().endsWith(".svg")) {
                 try {
-                  const metadata = await sharp(fullPath).metadata();
+                  const metadata = await sharp2(fullPath).metadata();
                   if (metadata.width && metadata.height) {
                     dimensions = { width: metadata.width, height: metadata.height };
                   }
@@ -221,45 +353,129 @@ async function handleSearch(request) {
     return NextResponse.json({ error: "Failed to search" }, { status: 500 });
   }
 }
-async function getFolderStats(folderPath) {
-  let fileCount = 0;
-  let totalSize = 0;
-  async function scanFolder(dir) {
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name.startsWith(".")) continue;
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          await scanFolder(fullPath);
-        } else if (isMediaFile(entry.name)) {
-          fileCount++;
-          const stats = await fs.stat(fullPath);
-          totalSize += stats.size;
+async function handleListFolders() {
+  try {
+    const publicDir = path5.join(process.cwd(), "public");
+    const folders = [];
+    async function scanDir(dir, relativePath, depth) {
+      try {
+        const entries = await fs5.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          if (entry.name.startsWith(".")) continue;
+          const folderRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+          folders.push({
+            path: `public/${folderRelativePath}`,
+            name: entry.name,
+            depth
+          });
+          await scanDir(path5.join(dir, entry.name), folderRelativePath, depth + 1);
         }
+      } catch {
       }
-    } catch {
     }
+    folders.push({ path: "public", name: "public", depth: 0 });
+    await scanDir(publicDir, "", 1);
+    return NextResponse.json({ folders });
+  } catch (error) {
+    console.error("Failed to list folders:", error);
+    return NextResponse.json({ error: "Failed to list folders" }, { status: 500 });
   }
-  await scanFolder(folderPath);
-  return { fileCount, totalSize };
 }
-async function handleUpload(request) {
+async function handleCountImages() {
   try {
-    const formData = await request.formData();
-    const file = formData.get("file");
-    const targetPath = formData.get("path") || "public";
-    if (!file) {
-      return NextResponse.json({ error: "No file provided" }, { status: 400 });
+    const allImages = [];
+    async function scanPublicFolder(dir, relativePath = "") {
+      try {
+        const entries = await fs5.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.name.startsWith(".")) continue;
+          const fullPath = path5.join(dir, entry.name);
+          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+          if (relPath === "images" || relPath.startsWith("images/")) continue;
+          if (entry.isDirectory()) {
+            await scanPublicFolder(fullPath, relPath);
+          } else if (isImageFile(entry.name)) {
+            allImages.push(relPath);
+          }
+        }
+      } catch {
+      }
     }
-    const bytes = await file.arrayBuffer();
-    const buffer = Buffer.from(bytes);
-    const fileName = file.name;
-    const baseName = path.basename(fileName, path.extname(fileName));
-    const ext = path.extname(fileName).toLowerCase();
-    const isImage = isImageFile(fileName);
-    const isSvg = ext === ".svg";
-    const isProcessableImage = isImage && !isSvg;
+    const publicDir = path5.join(process.cwd(), "public");
+    await scanPublicFolder(publicDir);
+    return NextResponse.json({
+      count: allImages.length,
+      images: allImages
+    });
+  } catch (error) {
+    console.error("Failed to count images:", error);
+    return NextResponse.json({ error: "Failed to count images" }, { status: 500 });
+  }
+}
+async function handleFolderImages(request) {
+  try {
+    const searchParams = request.nextUrl.searchParams;
+    const foldersParam = searchParams.get("folders");
+    if (!foldersParam) {
+      return NextResponse.json({ error: "No folders provided" }, { status: 400 });
+    }
+    const folders = foldersParam.split(",");
+    const allImages = [];
+    async function scanFolder(dir, relativePath = "") {
+      try {
+        const entries = await fs5.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.name.startsWith(".")) continue;
+          const fullPath = path5.join(dir, entry.name);
+          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) {
+            await scanFolder(fullPath, relPath);
+          } else if (isImageFile(entry.name)) {
+            allImages.push(relPath);
+          }
+        }
+      } catch {
+      }
+    }
+    for (const folder of folders) {
+      const relativePath = folder.replace(/^public\/?/, "");
+      if (relativePath === "images" || relativePath.startsWith("images/")) continue;
+      const folderPath = path5.join(process.cwd(), folder);
+      await scanFolder(folderPath, relativePath);
+    }
+    return NextResponse.json({
+      count: allImages.length,
+      images: allImages
+    });
+  } catch (error) {
+    console.error("Failed to get folder images:", error);
+    return NextResponse.json({ error: "Failed to get folder images" }, { status: 500 });
+  }
+}
+
+// src/handlers/files.ts
+import { NextResponse as NextResponse2 } from "next/server";
+import { promises as fs6 } from "fs";
+import path6 from "path";
+import sharp3 from "sharp";
+import { encode as encode2 } from "blurhash";
+async function handleUpload(request) {
+  try {
+    const formData = await request.formData();
+    const file = formData.get("file");
+    const targetPath = formData.get("path") || "public";
+    if (!file) {
+      return NextResponse2.json({ error: "No file provided" }, { status: 400 });
+    }
+    const bytes = await file.arrayBuffer();
+    const buffer = Buffer.from(bytes);
+    const fileName = file.name;
+    const baseName = path6.basename(fileName, path6.extname(fileName));
+    const ext = path6.extname(fileName).toLowerCase();
+    const isImage = isImageFile(fileName);
+    const isSvg = ext === ".svg";
+    const isProcessableImage = isImage && !isSvg;
     const meta = await loadMeta();
     let relativeDir = "";
     if (targetPath === "public") {
@@ -268,16 +484,16 @@ async function handleUpload(request) {
       relativeDir = targetPath.replace("public/", "");
     }
     if (relativeDir === "images" || relativeDir.startsWith("images/")) {
-      return NextResponse.json(
+      return NextResponse2.json(
         { error: "Cannot upload to images/ folder. Upload to public/ instead - thumbnails are generated automatically." },
         { status: 400 }
       );
     }
-    const uploadDir = path.join(process.cwd(), "public", relativeDir);
-    await fs.mkdir(uploadDir, { recursive: true });
-    await fs.writeFile(path.join(uploadDir, fileName), buffer);
+    const uploadDir = path6.join(process.cwd(), "public", relativeDir);
+    await fs6.mkdir(uploadDir, { recursive: true });
+    await fs6.writeFile(path6.join(uploadDir, fileName), buffer);
     if (!isImage) {
-      return NextResponse.json({
+      return NextResponse2.json({
         success: true,
         message: "File uploaded successfully (non-image, no thumbnails generated)",
         path: `public/${relativeDir ? relativeDir + "/" : ""}${fileName}`
@@ -285,32 +501,32 @@ async function handleUpload(request) {
     }
     const imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
     if (meta[imageKey]) {
-      return NextResponse.json(
+      return NextResponse2.json(
         { error: `File '${imageKey}' already exists in meta` },
         { status: 409 }
       );
     }
-    const imagesPath = path.join(process.cwd(), "public", "images", relativeDir);
-    await fs.mkdir(imagesPath, { recursive: true });
+    const imagesPath = path6.join(process.cwd(), "public", "images", relativeDir);
+    await fs6.mkdir(imagesPath, { recursive: true });
     let originalWidth = 0;
     let originalHeight = 0;
     let blurhash = "";
     const originalPath = `/${relativeDir ? relativeDir + "/" : ""}${fileName}`;
     if (isSvg) {
-      const fullPath = path.join(imagesPath, fileName);
-      await fs.writeFile(fullPath, buffer);
+      const fullPath = path6.join(imagesPath, fileName);
+      await fs6.writeFile(fullPath, buffer);
     } else if (isProcessableImage) {
-      const sharpInstance = sharp(buffer);
+      const sharpInstance = sharp3(buffer);
       const metadata = await sharpInstance.metadata();
       originalWidth = metadata.width || 0;
       originalHeight = metadata.height || 0;
       const outputExt = ext === ".png" ? ".png" : ".jpg";
       const fullFileName = `${baseName}${outputExt}`;
-      const fullPath = path.join(imagesPath, fullFileName);
+      const fullPath = path6.join(imagesPath, fullFileName);
       if (ext === ".png") {
-        await sharp(buffer).png({ quality: 85 }).toFile(fullPath);
+        await sharp3(buffer).png({ quality: 85 }).toFile(fullPath);
       } else {
-        await sharp(buffer).jpeg({ quality: 85 }).toFile(fullPath);
+        await sharp3(buffer).jpeg({ quality: 85 }).toFile(fullPath);
       }
       for (const [, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
         const { width: maxWidth, suffix } = sizeConfig;
@@ -320,15 +536,15 @@ async function handleUpload(request) {
         const ratio = originalHeight / originalWidth;
         const newHeight = Math.round(maxWidth * ratio);
         const sizeFileName = `${baseName}${suffix}${outputExt}`;
-        const sizePath = path.join(imagesPath, sizeFileName);
+        const sizePath = path6.join(imagesPath, sizeFileName);
         if (ext === ".png") {
-          await sharp(buffer).resize(maxWidth, newHeight).png({ quality: 80 }).toFile(sizePath);
+          await sharp3(buffer).resize(maxWidth, newHeight).png({ quality: 80 }).toFile(sizePath);
         } else {
-          await sharp(buffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
+          await sharp3(buffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
         }
       }
-      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 { data, info } = await sharp3(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+      blurhash = encode2(new Uint8ClampedArray(data), info.width, info.height, 4, 4);
     }
     const entry = {
       w: originalWidth,
@@ -337,18 +553,18 @@ async function handleUpload(request) {
     };
     meta[originalPath] = entry;
     await saveMeta(meta);
-    return NextResponse.json({ success: true, imageKey: originalPath, entry });
+    return NextResponse2.json({ success: true, imageKey: originalPath, entry });
   } catch (error) {
     console.error("Failed to upload:", error);
     const message = error instanceof Error ? error.message : "Unknown error";
-    return NextResponse.json({ error: `Failed to upload file: ${message}` }, { status: 500 });
+    return NextResponse2.json({ 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 NextResponse.json({ error: "No paths provided" }, { status: 400 });
+      return NextResponse2.json({ error: "No paths provided" }, { status: 400 });
     }
     const meta = await loadMeta();
     const deleted = [];
@@ -359,10 +575,10 @@ async function handleDelete(request) {
           errors.push(`Invalid path: ${itemPath}`);
           continue;
         }
-        const absolutePath = path.join(process.cwd(), itemPath);
-        const stats = await fs.stat(absolutePath);
+        const absolutePath = path6.join(process.cwd(), itemPath);
+        const stats = await fs6.stat(absolutePath);
         if (stats.isDirectory()) {
-          await fs.rm(absolutePath, { recursive: true });
+          await fs6.rm(absolutePath, { recursive: true });
           const prefix = "/" + itemPath.replace(/^public\/images\/?/, "").replace(/^public\/?/, "");
           for (const key of Object.keys(meta)) {
             if (key.startsWith(prefix)) {
@@ -370,15 +586,15 @@ async function handleDelete(request) {
             }
           }
         } else {
-          await fs.unlink(absolutePath);
+          await fs6.unlink(absolutePath);
           const isInImagesFolder = itemPath.startsWith("public/images/");
           if (!isInImagesFolder) {
             const imageKey = "/" + itemPath.replace(/^public\//, "");
             if (meta[imageKey]) {
               for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-                const absoluteThumbPath = path.join(process.cwd(), "public", thumbPath);
+                const absoluteThumbPath = path6.join(process.cwd(), "public", thumbPath);
                 try {
-                  await fs.unlink(absoluteThumbPath);
+                  await fs6.unlink(absoluteThumbPath);
                 } catch {
                 }
               }
@@ -393,16 +609,202 @@ async function handleDelete(request) {
       }
     }
     await saveMeta(meta);
-    return NextResponse.json({
+    return NextResponse2.json({
       success: true,
       deleted,
       errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
     console.error("Failed to delete:", error);
-    return NextResponse.json({ error: "Failed to delete files" }, { status: 500 });
+    return NextResponse2.json({ error: "Failed to delete files" }, { status: 500 });
+  }
+}
+async function handleCreateFolder(request) {
+  try {
+    const { parentPath, name } = await request.json();
+    if (!name || typeof name !== "string") {
+      return NextResponse2.json({ error: "Folder name is required" }, { status: 400 });
+    }
+    const sanitizedName = name.replace(/[<>:"/\\|?*]/g, "").trim();
+    if (!sanitizedName) {
+      return NextResponse2.json({ error: "Invalid folder name" }, { status: 400 });
+    }
+    const safePath = (parentPath || "public").replace(/\.\./g, "");
+    const folderPath = path6.join(process.cwd(), safePath, sanitizedName);
+    if (!folderPath.startsWith(path6.join(process.cwd(), "public"))) {
+      return NextResponse2.json({ error: "Invalid path" }, { status: 400 });
+    }
+    try {
+      await fs6.access(folderPath);
+      return NextResponse2.json({ error: "A folder with this name already exists" }, { status: 400 });
+    } catch {
+    }
+    await fs6.mkdir(folderPath, { recursive: true });
+    return NextResponse2.json({ success: true, path: path6.join(safePath, sanitizedName) });
+  } catch (error) {
+    console.error("Failed to create folder:", error);
+    return NextResponse2.json({ error: "Failed to create folder" }, { status: 500 });
+  }
+}
+async function handleRename(request) {
+  try {
+    const { oldPath, newName } = await request.json();
+    if (!oldPath || !newName) {
+      return NextResponse2.json({ error: "Path and new name are required" }, { status: 400 });
+    }
+    const sanitizedName = newName.replace(/[<>:"/\\|?*]/g, "").trim();
+    if (!sanitizedName) {
+      return NextResponse2.json({ error: "Invalid name" }, { status: 400 });
+    }
+    const safePath = oldPath.replace(/\.\./g, "");
+    const absoluteOldPath = path6.join(process.cwd(), safePath);
+    const parentDir = path6.dirname(absoluteOldPath);
+    const absoluteNewPath = path6.join(parentDir, sanitizedName);
+    if (!absoluteOldPath.startsWith(path6.join(process.cwd(), "public"))) {
+      return NextResponse2.json({ error: "Invalid path" }, { status: 400 });
+    }
+    try {
+      await fs6.access(absoluteOldPath);
+    } catch {
+      return NextResponse2.json({ error: "File or folder not found" }, { status: 404 });
+    }
+    try {
+      await fs6.access(absoluteNewPath);
+      return NextResponse2.json({ error: "An item with this name already exists" }, { status: 400 });
+    } catch {
+    }
+    const stats = await fs6.stat(absoluteOldPath);
+    const isFile = stats.isFile();
+    const isImage = isFile && isImageFile(path6.basename(oldPath));
+    await fs6.rename(absoluteOldPath, absoluteNewPath);
+    if (isImage) {
+      const meta = await loadMeta();
+      const oldRelativePath = safePath.replace(/^public\//, "");
+      const newRelativePath = path6.join(path6.dirname(oldRelativePath), sanitizedName);
+      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 = path6.join(process.cwd(), "public", oldThumbPaths[i]);
+          const newThumbPath = path6.join(process.cwd(), "public", newThumbPaths[i]);
+          await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
+          try {
+            await fs6.rename(oldThumbPath, newThumbPath);
+          } catch {
+          }
+        }
+        delete meta[oldKey];
+        meta[newKey] = entry;
+      }
+      await saveMeta(meta);
+    }
+    const newPath = path6.join(path6.dirname(safePath), sanitizedName);
+    return NextResponse2.json({ success: true, newPath });
+  } catch (error) {
+    console.error("Failed to rename:", error);
+    return NextResponse2.json({ error: "Failed to rename" }, { status: 500 });
+  }
+}
+async function handleMove(request) {
+  try {
+    const { paths, destination } = await request.json();
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return NextResponse2.json({ error: "Paths are required" }, { status: 400 });
+    }
+    if (!destination || typeof destination !== "string") {
+      return NextResponse2.json({ error: "Destination is required" }, { status: 400 });
+    }
+    const safeDestination = destination.replace(/\.\./g, "");
+    const absoluteDestination = path6.join(process.cwd(), safeDestination);
+    if (!absoluteDestination.startsWith(path6.join(process.cwd(), "public"))) {
+      return NextResponse2.json({ error: "Invalid destination" }, { status: 400 });
+    }
+    try {
+      const destStats = await fs6.stat(absoluteDestination);
+      if (!destStats.isDirectory()) {
+        return NextResponse2.json({ error: "Destination is not a folder" }, { status: 400 });
+      }
+    } catch {
+      return NextResponse2.json({ error: "Destination folder not found" }, { status: 404 });
+    }
+    const moved = [];
+    const errors = [];
+    const meta = await loadMeta();
+    let metaChanged = false;
+    for (const itemPath of paths) {
+      const safePath = itemPath.replace(/\.\./g, "");
+      const absolutePath = path6.join(process.cwd(), safePath);
+      const itemName = path6.basename(safePath);
+      const newAbsolutePath = path6.join(absoluteDestination, itemName);
+      if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
+        errors.push(`Cannot move ${itemName} into itself`);
+        continue;
+      }
+      try {
+        await fs6.access(absolutePath);
+      } catch {
+        errors.push(`${itemName} not found`);
+        continue;
+      }
+      try {
+        await fs6.access(newAbsolutePath);
+        errors.push(`${itemName} already exists in destination`);
+        continue;
+      } catch {
+      }
+      try {
+        await fs6.rename(absolutePath, newAbsolutePath);
+        const stats = await fs6.stat(newAbsolutePath);
+        if (stats.isFile() && isImageFile(itemName)) {
+          const oldRelativePath = safePath.replace(/^public\//, "");
+          const newRelativePath = path6.join(safeDestination.replace(/^public\//, ""), itemName);
+          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 = path6.join(process.cwd(), "public", oldThumbPaths[i]);
+              const newThumbPath = path6.join(process.cwd(), "public", newThumbPaths[i]);
+              await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
+              try {
+                await fs6.rename(oldThumbPath, newThumbPath);
+              } catch {
+              }
+            }
+            delete meta[oldKey];
+            meta[newKey] = entry;
+            metaChanged = true;
+          }
+        }
+        moved.push(itemPath);
+      } catch {
+        errors.push(`Failed to move ${itemName}`);
+      }
+    }
+    if (metaChanged) {
+      await saveMeta(meta);
+    }
+    return NextResponse2.json({
+      success: errors.length === 0,
+      moved,
+      errors: errors.length > 0 ? errors : void 0
+    });
+  } catch (error) {
+    console.error("Failed to move:", error);
+    return NextResponse2.json({ error: "Failed to move items" }, { status: 500 });
   }
 }
+
+// src/handlers/images.ts
+import { NextResponse as NextResponse3 } from "next/server";
+import { promises as fs7 } from "fs";
+import path7 from "path";
+import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2 } from "@aws-sdk/client-s3";
 async function handleSync(request) {
   const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
   const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
@@ -410,7 +812,7 @@ async function handleSync(request) {
   const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
   const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL;
   if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
-    return NextResponse.json(
+    return NextResponse3.json(
       { error: "R2 not configured. Set CLOUDFLARE_R2_* environment variables." },
       { status: 400 }
     );
@@ -418,10 +820,10 @@ async function handleSync(request) {
   try {
     const { imageKeys } = await request.json();
     if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
-      return NextResponse.json({ error: "No image keys provided" }, { status: 400 });
+      return NextResponse3.json({ error: "No image keys provided" }, { status: 400 });
     }
     const meta = await loadMeta();
-    const r2 = new S3Client({
+    const r2 = new S3Client2({
       region: "auto",
       endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
       credentials: { accessKeyId, secretAccessKey }
@@ -440,11 +842,11 @@ async function handleSync(request) {
       }
       try {
         for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-          const localPath = path.join(process.cwd(), "public", thumbPath);
+          const localPath = path7.join(process.cwd(), "public", thumbPath);
           try {
-            const fileBuffer = await fs.readFile(localPath);
+            const fileBuffer = await fs7.readFile(localPath);
             await r2.send(
-              new PutObjectCommand({
+              new PutObjectCommand2({
                 Bucket: bucketName,
                 Key: thumbPath.replace(/^\//, ""),
                 Body: fileBuffer,
@@ -456,9 +858,9 @@ async function handleSync(request) {
         }
         entry.s = 1;
         for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-          const localPath = path.join(process.cwd(), "public", thumbPath);
+          const localPath = path7.join(process.cwd(), "public", thumbPath);
           try {
-            await fs.unlink(localPath);
+            await fs7.unlink(localPath);
           } catch {
           }
         }
@@ -469,21 +871,21 @@ async function handleSync(request) {
       }
     }
     await saveMeta(meta);
-    return NextResponse.json({
+    return NextResponse3.json({
       success: true,
       synced,
       errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
     console.error("Failed to sync:", error);
-    return NextResponse.json({ error: "Failed to sync to CDN" }, { status: 500 });
+    return NextResponse3.json({ error: "Failed to sync to CDN" }, { status: 500 });
   }
 }
 async function handleReprocess(request) {
   try {
     const { imageKeys } = await request.json();
     if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
-      return NextResponse.json({ error: "No image keys provided" }, { status: 400 });
+      return NextResponse3.json({ error: "No image keys provided" }, { status: 400 });
     }
     const meta = await loadMeta();
     const processed = [];
@@ -492,9 +894,9 @@ async function handleReprocess(request) {
       try {
         let buffer;
         const entry = meta[imageKey];
-        const originalPath = path.join(process.cwd(), "public", imageKey);
+        const originalPath = path7.join(process.cwd(), "public", imageKey);
         try {
-          buffer = await fs.readFile(originalPath);
+          buffer = await fs7.readFile(originalPath);
         } catch {
           if (entry?.s) {
             buffer = await downloadFromCdn(imageKey);
@@ -516,85 +918,14 @@ async function handleReprocess(request) {
       }
     }
     await saveMeta(meta);
-    return NextResponse.json({
+    return NextResponse3.json({
       success: true,
       processed,
       errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
     console.error("Failed to reprocess:", error);
-    return NextResponse.json({ error: "Failed to reprocess images" }, { status: 500 });
-  }
-}
-async function handleCountImages() {
-  try {
-    const allImages = [];
-    async function scanPublicFolder(dir, relativePath = "") {
-      try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = path.join(dir, entry.name);
-          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (relPath === "images" || relPath.startsWith("images/")) continue;
-          if (entry.isDirectory()) {
-            await scanPublicFolder(fullPath, relPath);
-          } else if (isImageFile(entry.name)) {
-            allImages.push(relPath);
-          }
-        }
-      } catch {
-      }
-    }
-    const publicDir = path.join(process.cwd(), "public");
-    await scanPublicFolder(publicDir);
-    return NextResponse.json({
-      count: allImages.length,
-      images: allImages
-    });
-  } catch (error) {
-    console.error("Failed to count images:", error);
-    return NextResponse.json({ error: "Failed to count images" }, { status: 500 });
-  }
-}
-async function handleFolderImages(request) {
-  try {
-    const searchParams = request.nextUrl.searchParams;
-    const foldersParam = searchParams.get("folders");
-    if (!foldersParam) {
-      return NextResponse.json({ error: "No folders provided" }, { status: 400 });
-    }
-    const folders = foldersParam.split(",");
-    const allImages = [];
-    async function scanFolder(dir, relativePath = "") {
-      try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = path.join(dir, entry.name);
-          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            await scanFolder(fullPath, relPath);
-          } else if (isImageFile(entry.name)) {
-            allImages.push(relPath);
-          }
-        }
-      } catch {
-      }
-    }
-    for (const folder of folders) {
-      const relativePath = folder.replace(/^public\/?/, "");
-      if (relativePath === "images" || relativePath.startsWith("images/")) continue;
-      const folderPath = path.join(process.cwd(), folder);
-      await scanFolder(folderPath, relativePath);
-    }
-    return NextResponse.json({
-      count: allImages.length,
-      images: allImages
-    });
-  } catch (error) {
-    console.error("Failed to get folder images:", error);
-    return NextResponse.json({ error: "Failed to get folder images" }, { status: 500 });
+    return NextResponse3.json({ error: "Failed to reprocess images" }, { status: 500 });
   }
 }
 async function handleProcessAllStream() {
@@ -614,10 +945,10 @@ async function handleProcessAllStream() {
         const allImages = [];
         async function scanPublicFolder(dir, relativePath = "") {
           try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
+            const entries = await fs7.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".")) continue;
-              const fullPath = path.join(dir, entry.name);
+              const fullPath = path7.join(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (relPath === "images" || relPath.startsWith("images/")) continue;
               if (entry.isDirectory()) {
@@ -629,7 +960,7 @@ async function handleProcessAllStream() {
           } catch {
           }
         }
-        const publicDir = path.join(process.cwd(), "public");
+        const publicDir = path7.join(process.cwd(), "public");
         await scanPublicFolder(publicDir);
         const total = allImages.length;
         sendEvent({ type: "start", total });
@@ -644,16 +975,16 @@ async function handleProcessAllStream() {
             currentFile: key
           });
           try {
-            const buffer = await fs.readFile(fullPath);
-            const ext = path.extname(key).toLowerCase();
+            const buffer = await fs7.readFile(fullPath);
+            const ext = path7.extname(key).toLowerCase();
             const isSvg = ext === ".svg";
             if (isSvg) {
-              const imageDir = path.dirname(key);
-              const imagesPath = path.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
-              await fs.mkdir(imagesPath, { recursive: true });
-              const fileName = path.basename(key);
-              const destPath = path.join(imagesPath, fileName);
-              await fs.writeFile(destPath, buffer);
+              const imageDir = path7.dirname(key);
+              const imagesPath = path7.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
+              await fs7.mkdir(imagesPath, { recursive: true });
+              const fileName = path7.basename(key);
+              const destPath = path7.join(imagesPath, fileName);
+              await fs7.writeFile(destPath, buffer);
               meta[imageKey] = {
                 w: 0,
                 h: 0,
@@ -682,10 +1013,10 @@ async function handleProcessAllStream() {
         }
         async function findOrphans(dir, relativePath = "") {
           try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
+            const entries = await fs7.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".")) continue;
-              const fullPath = path.join(dir, entry.name);
+              const fullPath = path7.join(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 await findOrphans(fullPath, relPath);
@@ -693,7 +1024,7 @@ async function handleProcessAllStream() {
                 const publicPath = `/images/${relPath}`;
                 if (!trackedPaths.has(publicPath)) {
                   try {
-                    await fs.unlink(fullPath);
+                    await fs7.unlink(fullPath);
                     orphansRemoved.push(publicPath);
                   } catch (err) {
                     console.error(`Failed to remove orphan ${publicPath}:`, err);
@@ -704,22 +1035,22 @@ async function handleProcessAllStream() {
           } catch {
           }
         }
-        const imagesDir = path.join(process.cwd(), "public", "images");
+        const imagesDir = path7.join(process.cwd(), "public", "images");
         await findOrphans(imagesDir);
         async function removeEmptyDirs(dir) {
           try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
+            const entries = await fs7.readdir(dir, { withFileTypes: true });
             let isEmpty = true;
             for (const entry of entries) {
               if (entry.isDirectory()) {
-                const subDirEmpty = await removeEmptyDirs(path.join(dir, entry.name));
+                const subDirEmpty = await removeEmptyDirs(path7.join(dir, entry.name));
                 if (!subDirEmpty) isEmpty = false;
               } else {
                 isEmpty = false;
               }
             }
             if (isEmpty && dir !== imagesDir) {
-              await fs.rmdir(dir);
+              await fs7.rmdir(dir);
             }
             return isEmpty;
           } catch {
@@ -750,371 +1081,72 @@ async function handleProcessAllStream() {
     }
   });
 }
-async function loadMeta() {
-  const metaPath = path.join(process.cwd(), "_data", "_meta.json");
-  try {
-    const content = await fs.readFile(metaPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
+
+// src/handlers/index.ts
+async function GET(request) {
+  if (process.env.NODE_ENV !== "development") {
+    return NextResponse4.json({ error: "Not available in production" }, { status: 403 });
   }
-}
-async function saveMeta(meta) {
-  const dataDir = path.join(process.cwd(), "_data");
-  await fs.mkdir(dataDir, { recursive: true });
-  const metaPath = path.join(dataDir, "_meta.json");
-  await fs.writeFile(metaPath, JSON.stringify(meta, null, 2));
-}
-function isImageFile(filename) {
-  const ext = path.extname(filename).toLowerCase();
-  return [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".ico", ".bmp", ".tiff", ".tif"].includes(ext);
-}
-function isMediaFile(filename) {
-  const ext = path.extname(filename).toLowerCase();
-  if ([".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".ico", ".bmp", ".tiff", ".tif"].includes(ext)) return true;
-  if ([".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v"].includes(ext)) return true;
-  if ([".mp3", ".wav", ".ogg", ".m4a", ".flac", ".aac"].includes(ext)) return true;
-  if ([".pdf"].includes(ext)) return true;
-  return false;
-}
-function getContentType(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  switch (ext) {
-    case ".jpg":
-    case ".jpeg":
-      return "image/jpeg";
-    case ".png":
-      return "image/png";
-    case ".gif":
-      return "image/gif";
-    case ".webp":
-      return "image/webp";
-    case ".svg":
-      return "image/svg+xml";
-    default:
-      return "application/octet-stream";
+  const pathname = request.nextUrl.pathname;
+  const route = pathname.replace(/^\/api\/studio\/?/, "");
+  if (route === "list-folders") {
+    return handleListFolders();
   }
-}
-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 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 isPng = ext === ".png";
-  const outputExt = isPng ? ".png" : ".jpg";
-  const fullFileName = imageDir === "." ? `${baseName}${outputExt}` : `${imageDir}/${baseName}${outputExt}`;
-  const fullPath = path.join(process.cwd(), "public", "images", fullFileName);
-  if (isPng) {
-    await sharp(buffer).png({ quality: 85 }).toFile(fullPath);
-  } else {
-    await sharp(buffer).jpeg({ quality: 85 }).toFile(fullPath);
+  if (route === "list" || route.startsWith("list")) {
+    return handleList(request);
   }
-  for (const [, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
-    const { width: maxWidth, suffix } = sizeConfig;
-    if (originalWidth <= maxWidth) {
-      continue;
-    }
-    const ratio = originalHeight / originalWidth;
-    const newHeight = Math.round(maxWidth * ratio);
-    const sizeFileName = `${baseName}${suffix}${outputExt}`;
-    const sizeFilePath = imageDir === "." ? sizeFileName : `${imageDir}/${sizeFileName}`;
-    const sizePath = path.join(process.cwd(), "public", "images", sizeFilePath);
-    if (isPng) {
-      await sharp(buffer).resize(maxWidth, newHeight).png({ quality: 80 }).toFile(sizePath);
-    } else {
-      await sharp(buffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
-    }
+  if (route === "count-images") {
+    return handleCountImages();
   }
-  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);
-  return {
-    w: originalWidth,
-    h: originalHeight,
-    blur: blurhash
-  };
-}
-async function downloadFromCdn(originalPath) {
-  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;
-  if (!accountId || !accessKeyId || !secretAccessKey || !bucketName) {
-    throw new Error("R2 not configured");
+  if (route === "folder-images") {
+    return handleFolderImages(request);
   }
-  const r2 = new S3Client({
-    region: "auto",
-    endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
-    credentials: { accessKeyId, secretAccessKey }
-  });
-  const response = await r2.send(
-    new GetObjectCommand({
-      Bucket: bucketName,
-      Key: originalPath.replace(/^\//, "")
-    })
-  );
-  const stream = response.Body;
-  const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(Buffer.from(chunk));
+  if (route === "search") {
+    return handleSearch(request);
   }
-  return Buffer.concat(chunks);
+  return NextResponse4.json({ error: "Not found" }, { status: 404 });
 }
-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;
-  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
-  if (!accountId || !accessKeyId || !secretAccessKey || !bucketName) {
-    throw new Error("R2 not configured");
+async function POST(request) {
+  if (process.env.NODE_ENV !== "development") {
+    return NextResponse4.json({ error: "Not available in production" }, { status: 403 });
   }
-  const r2 = new S3Client({
-    region: "auto",
-    endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
-    credentials: { accessKeyId, secretAccessKey }
-  });
-  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 {
-    }
+  const pathname = request.nextUrl.pathname;
+  const route = pathname.replace(/^\/api\/studio\/?/, "");
+  if (route === "upload") {
+    return handleUpload(request);
   }
-}
-async function deleteLocalThumbnails(imageKey) {
-  for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-    const localPath = path.join(process.cwd(), "public", thumbPath);
-    try {
-      await fs.unlink(localPath);
-    } catch {
-    }
+  if (route === "delete") {
+    return handleDelete(request);
   }
-}
-async function handleCreateFolder(request) {
-  try {
-    const { parentPath, name } = await request.json();
-    if (!name || typeof name !== "string") {
-      return NextResponse.json({ error: "Folder name is required" }, { status: 400 });
-    }
-    const sanitizedName = name.replace(/[<>:"/\\|?*]/g, "").trim();
-    if (!sanitizedName) {
-      return NextResponse.json({ error: "Invalid folder name" }, { status: 400 });
-    }
-    const safePath = (parentPath || "public").replace(/\.\./g, "");
-    const folderPath = path.join(process.cwd(), safePath, sanitizedName);
-    if (!folderPath.startsWith(path.join(process.cwd(), "public"))) {
-      return NextResponse.json({ error: "Invalid path" }, { status: 400 });
-    }
-    try {
-      await fs.access(folderPath);
-      return NextResponse.json({ error: "A folder with this name already exists" }, { status: 400 });
-    } catch {
-    }
-    await fs.mkdir(folderPath, { recursive: true });
-    return NextResponse.json({ success: true, path: path.join(safePath, sanitizedName) });
-  } catch (error) {
-    console.error("Failed to create folder:", error);
-    return NextResponse.json({ error: "Failed to create folder" }, { status: 500 });
+  if (route === "sync") {
+    return handleSync(request);
   }
-}
-async function handleRename(request) {
-  try {
-    const { oldPath, newName } = await request.json();
-    if (!oldPath || !newName) {
-      return NextResponse.json({ error: "Path and new name are required" }, { status: 400 });
-    }
-    const sanitizedName = newName.replace(/[<>:"/\\|?*]/g, "").trim();
-    if (!sanitizedName) {
-      return NextResponse.json({ error: "Invalid name" }, { status: 400 });
-    }
-    const safePath = oldPath.replace(/\.\./g, "");
-    const absoluteOldPath = path.join(process.cwd(), safePath);
-    const parentDir = path.dirname(absoluteOldPath);
-    const absoluteNewPath = path.join(parentDir, sanitizedName);
-    if (!absoluteOldPath.startsWith(path.join(process.cwd(), "public"))) {
-      return NextResponse.json({ error: "Invalid path" }, { status: 400 });
-    }
-    try {
-      await fs.access(absoluteOldPath);
-    } catch {
-      return NextResponse.json({ error: "File or folder not found" }, { status: 404 });
-    }
-    try {
-      await fs.access(absoluteNewPath);
-      return NextResponse.json({ error: "An item with this name already exists" }, { status: 400 });
-    } catch {
-    }
-    const stats = await fs.stat(absoluteOldPath);
-    const isFile = stats.isFile();
-    const isImage = isFile && isImageFile(path.basename(oldPath));
-    await fs.rename(absoluteOldPath, absoluteNewPath);
-    if (isImage) {
-      const meta = await loadMeta();
-      const oldRelativePath = safePath.replace(/^public\//, "");
-      const newRelativePath = path.join(path.dirname(oldRelativePath), sanitizedName);
-      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 {
-          }
-        }
-        delete meta[oldKey];
-        meta[newKey] = entry;
-      }
-      await saveMeta(meta);
-    }
-    const newPath = path.join(path.dirname(safePath), sanitizedName);
-    return NextResponse.json({ success: true, newPath });
-  } catch (error) {
-    console.error("Failed to rename:", error);
-    return NextResponse.json({ error: "Failed to rename" }, { status: 500 });
+  if (route === "reprocess") {
+    return handleReprocess(request);
   }
-}
-async function handleMove(request) {
-  try {
-    const { paths, destination } = await request.json();
-    if (!paths || !Array.isArray(paths) || paths.length === 0) {
-      return NextResponse.json({ error: "Paths are required" }, { status: 400 });
-    }
-    if (!destination || typeof destination !== "string") {
-      return NextResponse.json({ error: "Destination is required" }, { status: 400 });
-    }
-    const safeDestination = destination.replace(/\.\./g, "");
-    const absoluteDestination = path.join(process.cwd(), safeDestination);
-    if (!absoluteDestination.startsWith(path.join(process.cwd(), "public"))) {
-      return NextResponse.json({ error: "Invalid destination" }, { status: 400 });
-    }
-    try {
-      const destStats = await fs.stat(absoluteDestination);
-      if (!destStats.isDirectory()) {
-        return NextResponse.json({ error: "Destination is not a folder" }, { status: 400 });
-      }
-    } catch {
-      return NextResponse.json({ error: "Destination folder not found" }, { status: 404 });
-    }
-    const moved = [];
-    const errors = [];
-    const meta = await loadMeta();
-    let metaChanged = false;
-    for (const itemPath of paths) {
-      const safePath = itemPath.replace(/\.\./g, "");
-      const absolutePath = path.join(process.cwd(), safePath);
-      const itemName = path.basename(safePath);
-      const newAbsolutePath = path.join(absoluteDestination, itemName);
-      if (absoluteDestination.startsWith(absolutePath + path.sep)) {
-        errors.push(`Cannot move ${itemName} into itself`);
-        continue;
-      }
-      try {
-        await fs.access(absolutePath);
-      } catch {
-        errors.push(`${itemName} not found`);
-        continue;
-      }
-      try {
-        await fs.access(newAbsolutePath);
-        errors.push(`${itemName} already exists in destination`);
-        continue;
-      } catch {
-      }
-      try {
-        await fs.rename(absolutePath, newAbsolutePath);
-        const stats = await fs.stat(newAbsolutePath);
-        if (stats.isFile() && isImageFile(itemName)) {
-          const oldRelativePath = safePath.replace(/^public\//, "");
-          const newRelativePath = path.join(safeDestination.replace(/^public\//, ""), itemName);
-          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 {
-              }
-            }
-            delete meta[oldKey];
-            meta[newKey] = entry;
-            metaChanged = true;
-          }
-        }
-        moved.push(itemPath);
-      } catch (error) {
-        errors.push(`Failed to move ${itemName}`);
-      }
-    }
-    if (metaChanged) {
-      await saveMeta(meta);
-    }
-    return NextResponse.json({
-      success: errors.length === 0,
-      moved,
-      errors: errors.length > 0 ? errors : void 0
-    });
-  } catch (error) {
-    console.error("Failed to move:", error);
-    return NextResponse.json({ error: "Failed to move items" }, { status: 500 });
+  if (route === "process-all") {
+    return handleProcessAllStream();
+  }
+  if (route === "create-folder") {
+    return handleCreateFolder(request);
+  }
+  if (route === "rename") {
+    return handleRename(request);
+  }
+  if (route === "move") {
+    return handleMove(request);
   }
+  return NextResponse4.json({ error: "Not found" }, { status: 404 });
 }
-async function handleListFolders() {
-  try {
-    const publicDir = path.join(process.cwd(), "public");
-    const folders = [];
-    async function scanDir(dir, relativePath, depth) {
-      try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (!entry.isDirectory()) continue;
-          if (entry.name.startsWith(".")) continue;
-          const folderRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          folders.push({
-            path: `public/${folderRelativePath}`,
-            name: entry.name,
-            depth
-          });
-          await scanDir(path.join(dir, entry.name), folderRelativePath, depth + 1);
-        }
-      } catch {
-      }
-    }
-    folders.push({ path: "public", name: "public", depth: 0 });
-    await scanDir(publicDir, "", 1);
-    return NextResponse.json({ folders });
-  } catch (error) {
-    console.error("Failed to list folders:", error);
-    return NextResponse.json({ error: "Failed to list folders" }, { status: 500 });
+async function DELETE(request) {
+  if (process.env.NODE_ENV !== "development") {
+    return NextResponse4.json({ error: "Not available in production" }, { status: 403 });
   }
+  return handleDelete(request);
 }
 export {
   DELETE,
   GET,
   POST
 };
-//# sourceMappingURL=handlers.mjs.map
+//# sourceMappingURL=index.mjs.map