@spark-apps/piclet 1.0.3 → 1.0.5

package/dist/cli.js

@@ -40,14 +40,15 @@ ${renderLogo()}`);
 import chalk2 from "chalk";
 
 // src/tools/border.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { basename as basename2, join as join3 } from "path";
+import { basename as basename2, join as join4 } from "path";
 
 // src/lib/gui-server.ts
 import { spawn } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { createServer } from "http";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname2, extname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 import express from "express";
 
@@ -340,6 +341,58 @@ function startGuiServer(options) {
         res.json({ success: false, error: err.message });
       }
     });
+    app.post("/api/simplify-gif", async (req, res) => {
+      if (!options.onSimplifyGif) {
+        res.json({ success: false, error: "GIF simplification not supported" });
+        return;
+      }
+      try {
+        const skipFactor = req.body.skipFactor ?? 2;
+        const result = await options.onSimplifyGif(skipFactor);
+        if (result.success) {
+          options.imageInfo.filePath = result.filePath;
+          options.imageInfo.fileName = result.fileName;
+          options.imageInfo.width = result.width;
+          options.imageInfo.height = result.height;
+          options.imageInfo.frameCount = result.frameCount;
+        }
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
+    app.post("/api/delete-frame", async (req, res) => {
+      if (!options.onDeleteFrame) {
+        res.json({ success: false, error: "Frame deletion not supported" });
+        return;
+      }
+      try {
+        const frameIndex = req.body.frameIndex;
+        const result = await options.onDeleteFrame(frameIndex);
+        if (result.success) {
+          options.imageInfo.frameCount = result.frameCount;
+        }
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
+    app.post("/api/replace-frame", async (req, res) => {
+      if (!options.onReplaceFrame) {
+        res.json({ success: false, error: "Frame replacement not supported" });
+        return;
+      }
+      try {
+        const { frameIndex, imageData } = req.body;
+        const result = await options.onReplaceFrame(frameIndex, imageData);
+        if (result.success) {
+          options.imageInfo.frameCount = result.frameCount;
+        }
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
     app.post("/api/preview", async (req, res) => {
       if (!options.onPreview) {
         res.json({ success: false, error: "Preview not supported" });
@@ -359,6 +412,11 @@ function startGuiServer(options) {
       try {
         const result = await options.onProcess(req.body);
         processResult = result.success;
+        if (result.outputPath) {
+          options.lastOutputPath = result.outputPath;
+        } else {
+          options.lastOutputPath = void 0;
+        }
         res.json(result);
       } catch (err) {
         processResult = false;
@@ -436,8 +494,39 @@ function startGuiServer(options) {
       }).unref();
       res.json({ success: true });
     });
+    app.get("/api/output-preview", (_req, res) => {
+      const outputPath = options.lastOutputPath;
+      if (!outputPath) {
+        res.json({ success: false, error: "No output file" });
+        return;
+      }
+      try {
+        if (!existsSync2(outputPath)) {
+          res.json({ success: false, error: "Output file not found" });
+          return;
+        }
+        const buffer = readFileSync2(outputPath);
+        const ext = extname(outputPath).toLowerCase();
+        const mimeTypes = {
+          ".png": "image/png",
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".gif": "image/gif",
+          ".ico": "image/x-icon"
+        };
+        const mimeType = mimeTypes[ext] || "image/png";
+        res.json({
+          success: true,
+          imageData: `data:${mimeType};base64,${buffer.toString("base64")}`,
+          isGif: ext === ".gif"
+        });
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
     app.post("/api/open-folder", (_req, res) => {
-      const filePath = options.imageInfo.filePath;
+      const outputPath = options.lastOutputPath;
+      const filePath = outputPath || options.imageInfo.filePath;
       let winPath = filePath;
       const wslMatch = filePath.match(/^\/mnt\/([a-z])\/(.*)$/);
       if (wslMatch) {
@@ -445,8 +534,10 @@ function startGuiServer(options) {
         const rest = wslMatch[2].replace(/\//g, "\\");
         winPath = `${drive}:\\${rest}`;
       }
-      const dir = winPath.substring(0, winPath.lastIndexOf("\\")) || winPath.substring(0, winPath.lastIndexOf("/"));
-      spawn("powershell.exe", ["-WindowStyle", "Hidden", "-Command", `explorer.exe "${dir}"`], {
+      const lastSep = Math.max(winPath.lastIndexOf("\\"), winPath.lastIndexOf("/"));
+      const dir = lastSep > 0 ? winPath.substring(0, lastSep) : winPath;
+      const explorerCmd = outputPath ? `explorer.exe /select,"${winPath}"` : `explorer.exe "${dir}"`;
+      spawn("powershell.exe", ["-WindowStyle", "Hidden", "-Command", explorerCmd], {
         detached: true,
         stdio: "ignore",
         windowsHide: true
@@ -534,7 +625,7 @@ function clearLine() {
 
 // src/lib/magick.ts
 import { exec } from "child_process";
-import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, unlinkSync } from "fs";
 import { dirname as dirname3 } from "path";
 import { promisify } from "util";
 var execAsync = promisify(exec);
@@ -549,7 +640,7 @@ function isGif(imagePath) {
   return imagePath.toLowerCase().endsWith(".gif");
 }
 function getGifOutputSuffix(outputPath) {
-  return isGif(outputPath) ? " -layers Optimize" : "";
+  return isGif(outputPath) ? " -dispose Background -layers OptimizePlus" : "";
 }
 function getCoalescePrefix(inputPath) {
   return isGif(inputPath) ? "-coalesce " : "";
@@ -688,6 +779,20 @@ async function removeBackgroundBorderOnly(inputPath, outputPath, color, fuzz) {
     return false;
   }
 }
+async function removeBackgroundEdgeAware(inputPath, outputPath, color, fuzz, featherAmount = 50) {
+  if (isGif(inputPath)) {
+    return removeBackgroundBorderOnly(inputPath, outputPath, color, fuzz);
+  }
+  try {
+    const featherRadius = 0.5 + featherAmount / 100 * 2.5;
+    await execAsync(
+      `convert "${inputPath}" -bordercolor "${color}" -border 1x1 -fill none -fuzz ${fuzz}% -draw "matte 0,0 floodfill" -shave 1x1 \\( +clone -alpha extract -blur 0x${featherRadius} \\) -compose CopyOpacity -composite "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return removeBackgroundBorderOnly(inputPath, outputPath, color, fuzz);
+  }
+}
 async function createIco(inputPath, outputPath, sizes = [256, 128, 64, 48, 32, 16]) {
   try {
     const sizeStr = sizes.join(",");
@@ -710,14 +815,14 @@ async function createIcoFromMultiple(pngPaths, outputPath) {
 }
 function ensureDir(filePath) {
   const dir = dirname3(filePath);
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
 }
 function cleanup(...files) {
   for (const file of files) {
     try {
-      if (existsSync2(file)) {
+      if (existsSync3(file)) {
         unlinkSync(file);
       }
     } catch {
@@ -736,7 +841,13 @@ async function extractFirstFrame(inputPath, outputPath, frameIndex = 0) {
   }
   try {
     if (lowerPath.endsWith(".gif")) {
-      await execAsync(`convert "${inputPath}" -coalesce miff:- | convert "miff:-[${frameIndex}]" "${outputPath}"`);
+      if (frameIndex === 0) {
+        await execAsync(`convert "${inputPath}[0]" "${outputPath}"`);
+      } else {
+        await execAsync(
+          `convert "${inputPath}[0-${frameIndex}]" -coalesce -delete 0--2 "${outputPath}"`
+        );
+      }
     } else {
       await execAsync(`convert "${inputPath}[${frameIndex}]" "${outputPath}"`);
     }
@@ -764,7 +875,7 @@ async function extractAllFrames(inputPath, outputDir, baseName) {
   try {
     ensureDir(`${outputDir}/dummy`);
     await execAsync(
-      `convert "${inputPath}" -coalesce "${outputDir}/${baseName}-%04d.png"`
+      `convert "${inputPath}" -coalesce +adjoin "${outputDir}/${baseName}-%04d.png"`
     );
     const { stdout } = await execAsync(`ls -1 "${outputDir}/${baseName}"-*.png 2>/dev/null || true`);
     const files = stdout.trim().split("\n").filter((f) => f.length > 0);
@@ -893,9 +1004,97 @@ async function replaceColor(inputPath, outputPath, fromColor, toColor, fuzz) {
     return false;
   }
 }
+async function deleteGifFrame(inputPath, outputPath, frameIndex) {
+  try {
+    const originalCount = await getFrameCount(inputPath);
+    if (originalCount <= 1) {
+      return { success: false };
+    }
+    if (frameIndex < 0 || frameIndex >= originalCount) {
+      return { success: false };
+    }
+    await execAsync(
+      `convert "${inputPath}" -coalesce -delete ${frameIndex} -dispose Background -layers OptimizePlus "${outputPath}"`
+    );
+    const newCount = await getFrameCount(outputPath);
+    return { success: true, frameCount: newCount };
+  } catch {
+    return { success: false };
+  }
+}
+async function replaceGifFrame(inputPath, outputPath, frameIndex, replacementPath) {
+  try {
+    const frameCount = await getFrameCount(inputPath);
+    if (frameIndex < 0 || frameIndex >= frameCount) {
+      return { success: false };
+    }
+    const dims = await getDimensions(inputPath);
+    if (!dims) return { success: false };
+    const tempReplacement = `${outputPath}.tmp.png`;
+    await execAsync(
+      `convert "${replacementPath}" -resize ${dims[0]}x${dims[1]}^ -gravity center -extent ${dims[0]}x${dims[1]} "${tempReplacement}"`
+    );
+    if (frameIndex === 0) {
+      await execAsync(
+        `convert "${tempReplacement}" \\( "${inputPath}" -coalesce \\) -delete 1 -dispose Background -layers OptimizePlus "${outputPath}"`
+      );
+    } else if (frameIndex === frameCount - 1) {
+      await execAsync(
+        `convert \\( "${inputPath}" -coalesce -delete -1 \\) "${tempReplacement}" -dispose Background -layers OptimizePlus "${outputPath}"`
+      );
+    } else {
+      await execAsync(
+        `convert \\( "${inputPath}" -coalesce \\) -delete ${frameIndex} "${outputPath}.frames.gif" && convert "${outputPath}.frames.gif[0-${frameIndex - 1}]" "${tempReplacement}" "${outputPath}.frames.gif[${frameIndex}-]" -dispose Background -layers OptimizePlus "${outputPath}" && rm -f "${outputPath}.frames.gif"`
+      );
+    }
+    try {
+      unlinkSync(tempReplacement);
+    } catch {
+    }
+    const newCount = await getFrameCount(outputPath);
+    return { success: true, frameCount: newCount };
+  } catch {
+    return { success: false };
+  }
+}
+async function simplifyGif(inputPath, outputPath, skipFactor) {
+  if (skipFactor < 2) {
+    if (inputPath !== outputPath) {
+      try {
+        copyFileSync(inputPath, outputPath);
+        const count2 = await getFrameCount(outputPath);
+        return { success: true, frameCount: count2 };
+      } catch {
+        return { success: false };
+      }
+    }
+    const count = await getFrameCount(inputPath);
+    return { success: true, frameCount: count };
+  }
+  try {
+    const originalCount = await getFrameCount(inputPath);
+    if (originalCount <= 1) {
+      copyFileSync(inputPath, outputPath);
+      return { success: true, frameCount: 1 };
+    }
+    const frameIndices = [];
+    for (let i = 0; i < originalCount; i += skipFactor) {
+      frameIndices.push(i);
+    }
+    const keepPattern = frameIndices.join(",");
+    await execAsync(
+      `convert "${inputPath}[${keepPattern}]" -coalesce -dispose Background -layers OptimizePlus "${outputPath}"`
+    );
+    const newCount = await getFrameCount(outputPath);
+    return { success: true, frameCount: newCount };
+  } catch {
+    return { success: false };
+  }
+}
 
 // src/lib/paths.ts
-import { basename, dirname as dirname4, extname, resolve } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { basename, dirname as dirname4, extname as extname2, join as join3, resolve } from "path";
 function windowsToWsl(winPath) {
   if (winPath.startsWith("/mnt/")) {
     return winPath;
@@ -926,7 +1125,7 @@ function normalizePath(inputPath) {
 function getFileInfo(filePath) {
   const dir = dirname4(filePath);
   const base = basename(filePath);
-  const ext = extname(filePath);
+  const ext = extname2(filePath);
   const name = base.slice(0, -ext.length);
   return {
     dirname: dir,
@@ -935,6 +1134,20 @@ function getFileInfo(filePath) {
     extension: ext
   };
 }
+function getOutputDir(inputPath) {
+  const dir = dirname4(inputPath);
+  if (basename(dir) === "PicLet") {
+    return dir;
+  }
+  return join3(dir, "PicLet");
+}
+function ensureOutputDir(inputPath) {
+  const outDir = getOutputDir(inputPath);
+  if (!existsSync4(outDir)) {
+    mkdirSync3(outDir, { recursive: true });
+  }
+  return outDir;
+}
 
 // src/lib/prompts.ts
 import prompts from "prompts";
@@ -1083,7 +1296,7 @@ async function run(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync3(input)) {
+  if (!existsSync5(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -1102,7 +1315,7 @@ async function run(inputRaw) {
 }
 async function runGUI(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync3(input)) {
+  if (!existsSync5(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -1170,8 +1383,8 @@ async function runGUI(inputRaw) {
 async function generatePreview(input, options) {
   const tempDir = tmpdir();
   const timestamp = Date.now();
-  const tempSource = join3(tempDir, `piclet-preview-${timestamp}-src.png`);
-  const tempOutput = join3(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempSource = join4(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join4(tempDir, `piclet-preview-${timestamp}.png`);
   try {
     let previewInput = input;
     if (isMultiFrame(input)) {
@@ -1185,7 +1398,7 @@ async function generatePreview(input, options) {
       cleanup(tempSource, tempOutput);
       return { success: false, error: "Border failed" };
     }
-    const buffer = readFileSync2(tempOutput);
+    const buffer = readFileSync3(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
@@ -1208,16 +1421,10 @@ var config = {
   extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp"]
 };
 
-// src/cli/utils.ts
-import { extname as extname3 } from "path";
-import { dirname as dirname9 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import chalk from "chalk";
-
 // src/tools/extract-frames.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename3, join as join4 } from "path";
+import { basename as basename3, join as join5 } from "path";
 async function run2(inputRaw) {
   if (!await checkImageMagick()) {
     error("ImageMagick not found. Please install it:");
@@ -1226,7 +1433,7 @@ async function run2(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync4(input)) {
+  if (!existsSync6(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -1257,7 +1464,7 @@ async function run2(inputRaw) {
   const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_frames`;
   console.log("");
   wip("Extracting frames...");
-  mkdirSync3(outputDir, { recursive: true });
+  mkdirSync4(outputDir, { recursive: true });
   const frames = await extractAllFrames(input, outputDir, "frame");
   if (frames.length === 0) {
     wipDone(false, "Extraction failed");
@@ -1270,7 +1477,7 @@ async function run2(inputRaw) {
 }
 async function runGUI2(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync4(input)) {
+  if (!existsSync6(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -1309,7 +1516,7 @@ async function runGUI2(inputRaw) {
       }
       logs.push({ type: "info", message: `Extracting ${frameCount} frames...` });
       const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_frames`;
-      mkdirSync3(outputDir, { recursive: true });
+      mkdirSync4(outputDir, { recursive: true });
       const frames = await extractAllFrames(input, outputDir, "frame");
       if (frames.length > 0) {
         logs.push({ type: "success", message: `Extracted ${frames.length} frames` });
@@ -1327,12 +1534,12 @@ async function runGUI2(inputRaw) {
 async function generateFramePreview(input, frameIndex) {
   const tempDir = tmpdir2();
   const timestamp = Date.now();
-  const tempOutput = join4(tempDir, `piclet-frame-${timestamp}.png`);
+  const tempOutput = join5(tempDir, `piclet-frame-${timestamp}.png`);
   try {
     if (!await extractFirstFrame(input, tempOutput, frameIndex)) {
       return { success: false, error: "Failed to extract frame" };
     }
-    const buffer = readFileSync3(tempOutput);
+    const buffer = readFileSync4(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
@@ -1356,9 +1563,9 @@ var config2 = {
 };
 
 // src/tools/filter.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { basename as basename4, join as join5 } from "path";
+import { basename as basename4, join as join6 } from "path";
 var FILTER_LABELS = {
   "grayscale": "Grayscale",
   "sepia": "Sepia",
@@ -1432,7 +1639,7 @@ async function run3(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync5(input)) {
+  if (!existsSync7(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -1451,7 +1658,7 @@ async function run3(inputRaw) {
 }
 async function runGUI3(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync5(input)) {
+  if (!existsSync7(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -1516,8 +1723,8 @@ async function runGUI3(inputRaw) {
 async function generatePreview2(input, options) {
   const tempDir = tmpdir3();
   const timestamp = Date.now();
-  const tempSource = join5(tempDir, `piclet-preview-${timestamp}-src.png`);
-  const tempOutput = join5(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempSource = join6(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join6(tempDir, `piclet-preview-${timestamp}.png`);
   try {
     let previewInput = input;
     if (isMultiFrame(input)) {
@@ -1531,7 +1738,7 @@ async function generatePreview2(input, options) {
       cleanup(tempSource, tempOutput);
       return { success: false, error: "Filter failed" };
     }
-    const buffer = readFileSync4(tempOutput);
+    const buffer = readFileSync5(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
@@ -1555,7 +1762,7 @@ var config3 = {
 };
 
 // src/tools/iconpack.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
 import { basename as basename5, dirname as dirname5 } from "path";
 var WEB_ICONS = [
   { filename: "favicon-16x16.png", size: 16 },
@@ -1606,8 +1813,8 @@ async function generateIcons(outputDir, sourceImg, icons) {
     current++;
     const outputPath = `${outputDir}/${icon.filename}`;
     const subdir = dirname5(outputPath);
-    if (!existsSync6(subdir)) {
-      mkdirSync4(subdir, { recursive: true });
+    if (!existsSync8(subdir)) {
+      mkdirSync5(subdir, { recursive: true });
     }
     clearLine();
     wip(`[${current}/${total}] Generating ${icon.filename}...`);
@@ -1652,7 +1859,7 @@ async function run4(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync6(input)) {
+  if (!existsSync8(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -1694,7 +1901,7 @@ async function run4(inputRaw) {
   const doAndroid = platforms.includes("android");
   const doIos = platforms.includes("ios");
   const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_icons`;
-  mkdirSync4(outputDir, { recursive: true });
+  mkdirSync5(outputDir, { recursive: true });
   info(`Output directory: ${outputDir}`);
   console.log("");
   wip("Preparing source image...");
@@ -1716,7 +1923,7 @@ async function run4(inputRaw) {
     console.log("");
     header("Web Icons");
     const webDir = `${outputDir}/web`;
-    mkdirSync4(webDir, { recursive: true });
+    mkdirSync5(webDir, { recursive: true });
     if (!await generateFavicon(webDir, tempSource)) {
       totalFailed++;
     }
@@ -1726,14 +1933,14 @@ async function run4(inputRaw) {
     console.log("");
     header("Android Icons");
     const androidDir = `${outputDir}/android`;
-    mkdirSync4(androidDir, { recursive: true });
+    mkdirSync5(androidDir, { recursive: true });
     totalFailed += await generateIcons(androidDir, tempSource, ANDROID_ICONS);
   }
   if (doIos) {
     console.log("");
     header("iOS Icons");
     const iosDir = `${outputDir}/ios`;
-    mkdirSync4(iosDir, { recursive: true });
+    mkdirSync5(iosDir, { recursive: true });
     totalFailed += await generateIcons(iosDir, tempSource, IOS_ICONS);
   }
   cleanup(tempSource);
@@ -1759,7 +1966,7 @@ async function run4(inputRaw) {
 }
 async function runGUI4(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync6(input)) {
+  if (!existsSync8(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -1804,7 +2011,7 @@ async function runGUI4(inputRaw) {
         };
       }
       const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_icons`;
-      mkdirSync4(outputDir, { recursive: true });
+      mkdirSync5(outputDir, { recursive: true });
       logs.push({ type: "info", message: `Output: ${outputDir}` });
       logs.push({ type: "info", message: "Preparing source image..." });
       const tempSource = `${outputDir}/.source_1024.png`;
@@ -1822,7 +2029,7 @@ async function runGUI4(inputRaw) {
       if (doWeb) {
         logs.push({ type: "info", message: "Generating Web icons..." });
         const webDir = `${outputDir}/web`;
-        mkdirSync4(webDir, { recursive: true });
+        mkdirSync5(webDir, { recursive: true });
         if (!await generateFaviconSilent(webDir, tempSource)) {
           totalFailed++;
         }
@@ -1832,14 +2039,14 @@ async function runGUI4(inputRaw) {
       if (doAndroid) {
         logs.push({ type: "info", message: "Generating Android icons..." });
         const androidDir = `${outputDir}/android`;
-        mkdirSync4(androidDir, { recursive: true });
+        mkdirSync5(androidDir, { recursive: true });
         totalFailed += await generateIconsSilent(androidDir, tempSource, ANDROID_ICONS, logs);
         logs.push({ type: "success", message: `Android: ${ANDROID_ICONS.length} icons` });
       }
       if (doIos) {
         logs.push({ type: "info", message: "Generating iOS icons..." });
         const iosDir = `${outputDir}/ios`;
-        mkdirSync4(iosDir, { recursive: true });
+        mkdirSync5(iosDir, { recursive: true });
         totalFailed += await generateIconsSilent(iosDir, tempSource, IOS_ICONS, logs);
         logs.push({ type: "success", message: `iOS: ${IOS_ICONS.length} icons` });
       }
@@ -1864,8 +2071,8 @@ async function generateIconsSilent(outputDir, sourceImg, icons, _logs) {
   for (const icon of icons) {
     const outputPath = `${outputDir}/${icon.filename}`;
     const subdir = dirname5(outputPath);
-    if (!existsSync6(subdir)) {
-      mkdirSync4(subdir, { recursive: true });
+    if (!existsSync8(subdir)) {
+      mkdirSync5(subdir, { recursive: true });
     }
     if (!await scaleToSize(sourceImg, outputPath, icon.size)) {
       failed++;
@@ -1895,9 +2102,9 @@ var config4 = {
 };
 
 // src/tools/makeicon.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { basename as basename6, join as join6 } from "path";
+import { basename as basename6, join as join7 } from "path";
 async function run5(inputRaw) {
   if (!await checkImageMagick()) {
     error("ImageMagick not found. Please install it:");
@@ -1906,7 +2113,7 @@ async function run5(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync7(input)) {
+  if (!existsSync9(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -2004,9 +2211,9 @@ async function processForIcon(input, output, options, logs) {
 async function generatePreview3(input, options) {
   const tempDir = tmpdir4();
   const timestamp = Date.now();
-  const tempTrimmed = join6(tempDir, `piclet-preview-trimmed-${timestamp}.png`);
-  const tempSquare = join6(tempDir, `piclet-preview-square-${timestamp}.png`);
-  const tempOutput = join6(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempTrimmed = join7(tempDir, `piclet-preview-trimmed-${timestamp}.png`);
+  const tempSquare = join7(tempDir, `piclet-preview-square-${timestamp}.png`);
+  const tempOutput = join7(tempDir, `piclet-preview-${timestamp}.png`);
   try {
     let currentInput = input;
     if (options.trim) {
@@ -2030,7 +2237,7 @@ async function generatePreview3(input, options) {
     }
     if (currentInput === tempSquare) cleanup(tempSquare);
     else if (currentInput === tempTrimmed) cleanup(tempTrimmed);
-    const buffer = readFileSync5(tempOutput);
+    const buffer = readFileSync6(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
@@ -2048,7 +2255,7 @@ async function generatePreview3(input, options) {
 }
 async function runGUI5(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync7(input)) {
+  if (!existsSync9(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -2113,16 +2320,16 @@ var config5 = {
 };
 
 // src/tools/piclet-main.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { basename as basename7, dirname as dirname6, extname as extname2, join as join7 } from "path";
+import { basename as basename7, dirname as dirname6, extname as extname3, join as join8 } from "path";
 var TOOL_ORDER = ["removebg", "scale", "icons", "storepack"];
 async function generateCombinedPreview(input, borderColor, opts) {
   const tempDir = tmpdir5();
   const ts = Date.now();
   const temps = [];
   const makeTempPath = (suffix) => {
-    const p = join7(tempDir, `piclet-${ts}-${suffix}.png`);
+    const p = join8(tempDir, `piclet-${ts}-${suffix}.png`);
     temps.push(p);
     return p;
   };
@@ -2144,7 +2351,7 @@ async function generateCombinedPreview(input, borderColor, opts) {
           previewPath2 = scaled;
         }
       }
-      const buffer2 = readFileSync6(previewPath2);
+      const buffer2 = readFileSync7(previewPath2);
       const finalDims2 = await getDimensions(previewPath2);
       cleanup(...temps);
       return {
@@ -2161,7 +2368,9 @@ async function generateCombinedPreview(input, borderColor, opts) {
           const rbOpts = opts.removebg;
           const out = makeTempPath("removebg");
           let success2 = false;
-          if (rbOpts.preserveInner && borderColor) {
+          if (rbOpts.edgeDetect && borderColor) {
+            success2 = await removeBackgroundEdgeAware(current, out, borderColor, rbOpts.fuzz, rbOpts.edgeStrength);
+          } else if (rbOpts.preserveInner && borderColor) {
             success2 = await removeBackgroundBorderOnly(current, out, borderColor, rbOpts.fuzz);
           }
           if (!success2 && borderColor) {
@@ -2227,7 +2436,7 @@ async function generateCombinedPreview(input, borderColor, opts) {
         previewPath = scaled;
       }
     }
-    const buffer = readFileSync6(previewPath);
+    const buffer = readFileSync7(previewPath);
     const finalDims = await getDimensions(previewPath);
     cleanup(...temps);
     return {
@@ -2245,6 +2454,7 @@ async function processCombined(input, borderColor, opts, logs) {
   const fileInfo = getFileInfo(input);
   const outputs = [];
   const temps = [];
+  let singleFilePath;
   const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
   const makeTempPath = (suffix) => {
     const p = `${fileInfo.dirname}/${fileInfo.filename}_${suffix}${outputExt}`;
@@ -2260,7 +2470,13 @@ async function processCombined(input, borderColor, opts, logs) {
         const rbOpts = opts.removebg;
         const out = makeTempPath("nobg");
         let success2 = false;
-        if (rbOpts.preserveInner && borderColor) {
+        if (rbOpts.edgeDetect && borderColor) {
+          logs.push({ type: "info", message: "Using edge feathering..." });
+          success2 = await removeBackgroundEdgeAware(current, out, borderColor, rbOpts.fuzz, rbOpts.edgeStrength);
+          if (!success2) {
+            logs.push({ type: "warn", message: "Edge feathering failed, trying standard removal" });
+          }
+        } else if (rbOpts.preserveInner && borderColor) {
           success2 = await removeBackgroundBorderOnly(current, out, borderColor, rbOpts.fuzz);
           if (!success2) {
             logs.push({ type: "warn", message: "Border-only failed, trying full removal" });
@@ -2272,7 +2488,7 @@ async function processCombined(input, borderColor, opts, logs) {
         if (!success2) {
           logs.push({ type: "error", message: "Background removal failed" });
           cleanup(...temps);
-          return [];
+          return { outputs: [] };
         }
         logs.push({ type: "success", message: "Background removed" });
         if (rbOpts.trim) {
@@ -2290,10 +2506,12 @@ async function processCombined(input, borderColor, opts, logs) {
           current = out;
         }
         if (activeTools.indexOf(tool) === activeTools.length - 1) {
-          const finalOut = `${fileInfo.dirname}/${fileInfo.filename}_nobg${outputExt}`;
+          const outDir = ensureOutputDir(input);
+          const finalOut = join8(outDir, `${fileInfo.filename}_nobg${outputExt}`);
           renameSync(current, finalOut);
           temps.splice(temps.indexOf(current), 1);
           outputs.push(basename7(finalOut));
+          singleFilePath = finalOut;
         }
         break;
       }
@@ -2311,7 +2529,7 @@ async function processCombined(input, borderColor, opts, logs) {
         if (!success2) {
           logs.push({ type: "error", message: "Scale failed" });
           cleanup(...temps);
-          return [];
+          return { outputs: [] };
         }
         const dims = await getDimensions(out);
         logs.push({ type: "success", message: `Scaled to ${dims?.[0]}\xD7${dims?.[1]}` });
@@ -2321,10 +2539,12 @@ async function processCombined(input, borderColor, opts, logs) {
         }
         current = out;
         if (activeTools.indexOf(tool) === activeTools.length - 1) {
-          const finalOut = `${fileInfo.dirname}/${fileInfo.filename}_scaled${outputExt}`;
+          const outDir = ensureOutputDir(input);
+          const finalOut = join8(outDir, `${fileInfo.filename}_scaled${outputExt}`);
           renameSync(current, finalOut);
           temps.splice(temps.indexOf(current), 1);
           outputs.push(basename7(finalOut));
+          singleFilePath = finalOut;
         }
         break;
       }
@@ -2333,7 +2553,7 @@ async function processCombined(input, borderColor, opts, logs) {
         const icOpts = opts.icons;
         if (!icOpts.ico && !icOpts.web && !icOpts.android && !icOpts.ios) {
           logs.push({ type: "error", message: "No output format selected" });
-          return [];
+          return { outputs: [] };
         }
         let iconSource = current;
         if (icOpts.trim && current === input) {
@@ -2358,13 +2578,14 @@ async function processCombined(input, borderColor, opts, logs) {
         if (!await scaleToSize(iconSource, srcTemp, maxSize)) {
           logs.push({ type: "error", message: "Failed to prepare icon source" });
           cleanup(...temps);
-          return [];
+          return { outputs: [] };
         }
         if (iconSource !== current && iconSource !== input) cleanup(iconSource);
         let totalCount = 0;
         if (icOpts.ico) {
           logs.push({ type: "info", message: "Creating ICO file..." });
-          const icoOut = `${fileInfo.dirname}/${fileInfo.filename}.ico`;
+          const outDir = ensureOutputDir(input);
+          const icoOut = join8(outDir, `${fileInfo.filename}.ico`);
           if (await createIco(srcTemp, icoOut)) {
             logs.push({ type: "success", message: "ICO: 6 sizes (256, 128, 64, 48, 32, 16)" });
             outputs.push(basename7(icoOut));
@@ -2375,12 +2596,13 @@ async function processCombined(input, borderColor, opts, logs) {
         }
         const needsPacks = icOpts.web || icOpts.android || icOpts.ios;
         if (needsPacks) {
-          const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_icons`;
-          mkdirSync5(outputDir, { recursive: true });
+          const outDir = ensureOutputDir(input);
+          const outputDir = join8(outDir, `${fileInfo.filename}_icons`);
+          mkdirSync6(outputDir, { recursive: true });
           if (icOpts.web) {
             logs.push({ type: "info", message: "Generating Web icons..." });
             const webDir = `${outputDir}/web`;
-            mkdirSync5(webDir, { recursive: true });
+            mkdirSync6(webDir, { recursive: true });
             const t16 = `${webDir}/.t16.png`, t32 = `${webDir}/.t32.png`, t48 = `${webDir}/.t48.png`;
             await scaleToSize(srcTemp, t16, 16);
             await scaleToSize(srcTemp, t32, 32);
@@ -2415,7 +2637,7 @@ async function processCombined(input, borderColor, opts, logs) {
             ];
             for (const i of androidIcons) {
               const p = `${androidDir}/${i.name}`;
-              mkdirSync5(dirname6(p), { recursive: true });
+              mkdirSync6(dirname6(p), { recursive: true });
               await scaleToSize(srcTemp, p, i.size);
               totalCount++;
             }
@@ -2424,7 +2646,7 @@ async function processCombined(input, borderColor, opts, logs) {
           if (icOpts.ios) {
             logs.push({ type: "info", message: "Generating iOS icons..." });
             const iosDir = `${outputDir}/ios`;
-            mkdirSync5(iosDir, { recursive: true });
+            mkdirSync6(iosDir, { recursive: true });
             const iosSizes = [20, 29, 40, 58, 60, 76, 80, 87, 120, 152, 167, 180, 1024];
             for (const s of iosSizes) {
               await scaleToSize(srcTemp, `${iosDir}/AppIcon-${s}.png`, s);
@@ -2443,15 +2665,16 @@ async function processCombined(input, borderColor, opts, logs) {
         const spOpts = opts.storepack;
         if (!spOpts.dimensions || spOpts.dimensions.length === 0) {
           logs.push({ type: "error", message: "No dimensions specified" });
-          return [];
+          return { outputs: [] };
         }
         const folderName = spOpts.presetName || "assets";
-        const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${folderName}`;
-        mkdirSync5(outputDir, { recursive: true });
+        const outDir = ensureOutputDir(input);
+        const outputDir = join8(outDir, `${fileInfo.filename}_${folderName}`);
+        mkdirSync6(outputDir, { recursive: true });
         let count = 0;
         for (const dim of spOpts.dimensions) {
           const filename = dim.filename || `${dim.width}x${dim.height}.png`;
-          const out = join7(outputDir, filename);
+          const out = join8(outputDir, filename);
           let success2 = false;
           switch (spOpts.scaleMode) {
             case "fill":
@@ -2472,11 +2695,11 @@ async function processCombined(input, borderColor, opts, logs) {
     }
   }
   cleanup(...temps);
-  return outputs;
+  return { outputs, singleFilePath };
 }
 async function runGUI6(inputRaw) {
   let currentInput = normalizePath(inputRaw);
-  if (!existsSync8(currentInput)) {
+  if (!existsSync10(currentInput)) {
     error(`File not found: ${currentInput}`);
     return false;
   }
@@ -2490,14 +2713,14 @@ async function runGUI6(inputRaw) {
   const presets = loadPresets();
   async function generateFrameThumbnail(frameIndex) {
     const tempDir = tmpdir5();
-    const tempOutput = join7(tempDir, `piclet-frame-${Date.now()}-${frameIndex}.png`);
+    const tempOutput = join8(tempDir, `piclet-frame-${Date.now()}-${frameIndex}.png`);
     try {
       if (!await extractFirstFrame(currentInput, tempOutput, frameIndex)) {
         return { success: false, error: "Failed to extract frame" };
       }
-      const thumbOutput = join7(tempDir, `piclet-thumb-${Date.now()}-${frameIndex}.png`);
+      const thumbOutput = join8(tempDir, `piclet-thumb-${Date.now()}-${frameIndex}.png`);
       await scaleToSize(tempOutput, thumbOutput, 96);
-      const buffer = readFileSync6(thumbOutput);
+      const buffer = readFileSync7(thumbOutput);
       cleanup(tempOutput, thumbOutput);
       return {
         success: true,
@@ -2511,7 +2734,7 @@ async function runGUI6(inputRaw) {
   async function generateFramePreview2(frameIndex, opts) {
     const tempDir = tmpdir5();
     const ts = Date.now();
-    const frameFile = join7(tempDir, `piclet-fp-${ts}-${frameIndex}.png`);
+    const frameFile = join8(tempDir, `piclet-fp-${ts}-${frameIndex}.png`);
     const temps = [frameFile];
     try {
       if (!await extractFirstFrame(currentInput, frameFile, frameIndex)) {
@@ -2520,7 +2743,7 @@ async function runGUI6(inputRaw) {
       let current = frameFile;
       const activeTools = ["removebg", "scale", "icons"].filter((t) => opts.tools.includes(t));
       for (const tool of activeTools) {
-        const tempOut = join7(tempDir, `piclet-fp-${ts}-${frameIndex}-${tool}.png`);
+        const tempOut = join8(tempDir, `piclet-fp-${ts}-${frameIndex}-${tool}.png`);
         temps.push(tempOut);
         switch (tool) {
           case "removebg": {
@@ -2534,7 +2757,7 @@ async function runGUI6(inputRaw) {
             }
             if (success2) {
               if (rbOpts.trim) {
-                const trimOut = join7(tempDir, `piclet-fp-${ts}-${frameIndex}-trim.png`);
+                const trimOut = join8(tempDir, `piclet-fp-${ts}-${frameIndex}-trim.png`);
                 temps.push(trimOut);
                 if (await trim(tempOut, trimOut)) {
                   current = trimOut;
@@ -2564,7 +2787,7 @@ async function runGUI6(inputRaw) {
           case "icons": {
             const icOpts = opts.icons;
             if (icOpts.trim) {
-              const trimOut = join7(tempDir, `piclet-fp-${ts}-${frameIndex}-ictrim.png`);
+              const trimOut = join8(tempDir, `piclet-fp-${ts}-${frameIndex}-ictrim.png`);
               temps.push(trimOut);
               if (await trim(current, trimOut)) {
                 current = trimOut;
@@ -2579,10 +2802,10 @@ async function runGUI6(inputRaw) {
           }
         }
       }
-      const thumbOut = join7(tempDir, `piclet-fp-${ts}-${frameIndex}-thumb.png`);
+      const thumbOut = join8(tempDir, `piclet-fp-${ts}-${frameIndex}-thumb.png`);
       temps.push(thumbOut);
       await scaleToSize(current, thumbOut, 96);
-      const buffer = readFileSync6(thumbOut);
+      const buffer = readFileSync7(thumbOut);
       cleanup(...temps);
       return {
         success: true,
@@ -2621,7 +2844,7 @@ async function runGUI6(inputRaw) {
       if (isMultiFrame(currentInput) && typeof toolOpts.frameIndex === "number") {
         const tempDir = tmpdir5();
         const ts = Date.now();
-        const frameFile = join7(tempDir, `piclet-prev-${ts}.png`);
+        const frameFile = join8(tempDir, `piclet-prev-${ts}.png`);
         if (!await extractFirstFrame(currentInput, frameFile, toolOpts.frameIndex)) {
           return { success: false, error: "Failed to extract frame" };
         }
@@ -2647,11 +2870,12 @@ async function runGUI6(inputRaw) {
           logs: [{ type: "error", message: "ImageMagick not found. Install: sudo apt install imagemagick" }]
         };
       }
-      const outputs = await processCombined(currentInput, currentBorderColor, toolOpts, logs);
-      if (outputs.length > 0) {
+      const result = await processCombined(currentInput, currentBorderColor, toolOpts, logs);
+      if (result.outputs.length > 0) {
         return {
           success: true,
-          output: outputs.join("\n"),
+          output: result.outputs.join("\n"),
+          outputPath: result.singleFilePath,
           logs
         };
       }
@@ -2659,8 +2883,8 @@ async function runGUI6(inputRaw) {
     },
     onLoadImage: async (data) => {
       try {
-        const ext = extname2(data.fileName) || ".png";
-        const tempPath = join7(tmpdir5(), `piclet-load-${Date.now()}${ext}`);
+        const ext = extname3(data.fileName) || ".png";
+        const tempPath = join8(tmpdir5(), `piclet-load-${Date.now()}${ext}`);
         const buffer = Buffer.from(data.data, "base64");
         writeFileSync2(tempPath, buffer);
         const newDims = await getDimensions(tempPath);
@@ -2691,6 +2915,64 @@ async function runGUI6(inputRaw) {
       const toolOpts = opts;
       if (!toolOpts.tools) toolOpts.tools = [];
       return generateFramePreview2(frameIndex, toolOpts);
+    },
+    onSimplifyGif: async (skipFactor) => {
+      try {
+        const tempPath = join8(tmpdir5(), `piclet-simplified-${Date.now()}.gif`);
+        const result = await simplifyGif(currentInput, tempPath, skipFactor);
+        if (!result.success) {
+          return { success: false, error: "Failed to simplify GIF" };
+        }
+        const newDims = await getDimensions(tempPath);
+        if (!newDims) {
+          cleanup(tempPath);
+          return { success: false, error: "Failed to read simplified GIF dimensions" };
+        }
+        currentInput = tempPath;
+        currentFrameCount = result.frameCount ?? 1;
+        return {
+          success: true,
+          filePath: tempPath,
+          fileName: basename7(currentInput),
+          width: newDims[0],
+          height: newDims[1],
+          frameCount: currentFrameCount
+        };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    },
+    onDeleteFrame: async (frameIndex) => {
+      try {
+        const tempPath = join8(tmpdir5(), `piclet-edited-${Date.now()}.gif`);
+        const result = await deleteGifFrame(currentInput, tempPath, frameIndex);
+        if (!result.success) {
+          return { success: false, error: "Failed to delete frame" };
+        }
+        currentInput = tempPath;
+        currentFrameCount = result.frameCount ?? 1;
+        return { success: true, frameCount: currentFrameCount };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    },
+    onReplaceFrame: async (frameIndex, imageData) => {
+      try {
+        const buffer = Buffer.from(imageData, "base64");
+        const tempImagePath = join8(tmpdir5(), `piclet-replace-${Date.now()}.png`);
+        writeFileSync2(tempImagePath, buffer);
+        const tempPath = join8(tmpdir5(), `piclet-edited-${Date.now()}.gif`);
+        const result = await replaceGifFrame(currentInput, tempPath, frameIndex, tempImagePath);
+        cleanup(tempImagePath);
+        if (!result.success) {
+          return { success: false, error: "Failed to replace frame" };
+        }
+        currentInput = tempPath;
+        currentFrameCount = result.frameCount ?? currentFrameCount;
+        return { success: true, frameCount: currentFrameCount };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
     }
   });
 }
@@ -2709,7 +2991,7 @@ async function processGifExport(input, borderColor, opts, logs) {
     case "frame": {
       const frameIndex = opts.frameIndex ?? 0;
       logs.push({ type: "info", message: `Exporting frame ${frameIndex + 1}...` });
-      const frameFile = join7(tempDir, `piclet-export-${ts}.png`);
+      const frameFile = join8(tempDir, `piclet-export-${ts}.png`);
       if (!await extractFirstFrame(input, frameFile, frameIndex)) {
         logs.push({ type: "error", message: "Failed to extract frame" });
         return { success: false, error: "Failed to extract frame", logs };
@@ -2717,14 +2999,15 @@ async function processGifExport(input, borderColor, opts, logs) {
       let outputFile = frameFile;
       if (opts.tools && opts.tools.length > 0) {
         const processedLogs = [];
-        const outputs = await processCombined(frameFile, borderColor, opts, processedLogs);
+        const result = await processCombined(frameFile, borderColor, opts, processedLogs);
         logs.push(...processedLogs);
-        if (outputs.length === 0) {
+        if (result.outputs.length === 0) {
           cleanup(frameFile);
           return { success: false, error: "Processing failed", logs };
         }
       }
-      const finalOutput = `${fileInfo.dirname}/${fileInfo.filename}_frame${frameIndex + 1}.png`;
+      const frameOutDir = ensureOutputDir(input);
+      const finalOutput = join8(frameOutDir, `${fileInfo.filename}_frame${frameIndex + 1}.png`);
       if (outputFile === frameFile) {
         renameSync(frameFile, finalOutput);
       }
@@ -2733,8 +3016,9 @@ async function processGifExport(input, borderColor, opts, logs) {
     }
     case "all-frames": {
       logs.push({ type: "info", message: "Extracting all frames..." });
-      const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_frames`;
-      mkdirSync5(outputDir, { recursive: true });
+      const framesOutDir = ensureOutputDir(input);
+      const outputDir = join8(framesOutDir, `${fileInfo.filename}_frames`);
+      mkdirSync6(outputDir, { recursive: true });
       const frames = await extractAllFrames(input, outputDir, "frame");
       if (frames.length === 0) {
         logs.push({ type: "error", message: "Failed to extract frames" });
@@ -2753,9 +3037,9 @@ async function processGifExport(input, borderColor, opts, logs) {
     }
     case "gif": {
       logs.push({ type: "info", message: "Processing GIF..." });
-      const outputs = await processCombined(input, borderColor, opts, logs);
-      if (outputs.length > 0) {
-        return { success: true, output: outputs.join("\n"), logs };
+      const result = await processCombined(input, borderColor, opts, logs);
+      if (result.outputs.length > 0) {
+        return { success: true, output: result.outputs.join("\n"), outputPath: result.singleFilePath, logs };
       }
       return { success: false, error: "Processing failed", logs };
     }
@@ -2771,9 +3055,9 @@ var config6 = {
 };
 
 // src/tools/recolor.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { basename as basename8, join as join8 } from "path";
+import { basename as basename8, join as join9 } from "path";
 async function processImage3(input, options) {
   const fileInfo = getFileInfo(input);
   const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
@@ -2836,7 +3120,7 @@ async function run6(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync9(input)) {
+  if (!existsSync11(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -2859,7 +3143,7 @@ async function run6(inputRaw) {
 }
 async function runGUI7(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync9(input)) {
+  if (!existsSync11(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -2931,8 +3215,8 @@ async function runGUI7(inputRaw) {
 async function generatePreview4(input, options) {
   const tempDir = tmpdir6();
   const timestamp = Date.now();
-  const tempSource = join8(tempDir, `piclet-preview-${timestamp}-src.png`);
-  const tempOutput = join8(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempSource = join9(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join9(tempDir, `piclet-preview-${timestamp}.png`);
   try {
     let previewInput = input;
     if (isMultiFrame(input)) {
@@ -2952,7 +3236,7 @@ async function generatePreview4(input, options) {
       cleanup(tempSource, tempOutput);
       return { success: false, error: "Color replacement failed" };
     }
-    const buffer = readFileSync7(tempOutput);
+    const buffer = readFileSync8(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
@@ -2976,13 +3260,13 @@ var config7 = {
 };
 
 // src/tools/remove-bg.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, renameSync as renameSync2 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync10, renameSync as renameSync2 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { basename as basename9, join as join10 } from "path";
+import { basename as basename9, join as join11 } from "path";
 
 // src/lib/config.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname7, join as join9 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname7, join as join10 } from "path";
 import { homedir as homedir2 } from "os";
 var DEFAULT_CONFIG = {
   removeBg: {
@@ -3000,18 +3284,18 @@ var DEFAULT_CONFIG = {
   }
 };
 function getConfigDir() {
-  return join9(homedir2(), ".config", "piclet");
+  return join10(homedir2(), ".config", "piclet");
 }
 function getConfigPath() {
-  return join9(getConfigDir(), "config.json");
+  return join10(getConfigDir(), "config.json");
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!existsSync10(configPath)) {
+  if (!existsSync12(configPath)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const content = readFileSync8(configPath, "utf-8");
+    const content = readFileSync9(configPath, "utf-8");
     const loaded = JSON.parse(content);
     return {
       removeBg: { ...DEFAULT_CONFIG.removeBg, ...loaded.removeBg },
@@ -3025,8 +3309,8 @@ function loadConfig() {
 function resetConfig() {
   const configPath = getConfigPath();
   const configDir = dirname7(configPath);
-  if (!existsSync10(configDir)) {
-    mkdirSync6(configDir, { recursive: true });
+  if (!existsSync12(configDir)) {
+    mkdirSync7(configDir, { recursive: true });
   }
   writeFileSync3(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
 }
@@ -3129,7 +3413,7 @@ async function run7(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync11(input)) {
+  if (!existsSync13(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -3152,7 +3436,7 @@ async function run7(inputRaw) {
 }
 async function runGUI8(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync11(input)) {
+  if (!existsSync13(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -3190,15 +3474,12 @@ async function runGUI8(inputRaw) {
       return generatePreview5(input, borderColor, options);
     },
     onProcess: async (opts) => {
-      const logs = [];
       if (!await checkImageMagick()) {
         return {
           success: false,
-          error: "ImageMagick not found",
-          logs: [{ type: "error", message: "ImageMagick not found. Install with: sudo apt install imagemagick" }]
+          error: "ImageMagick not found"
         };
       }
-      logs.push({ type: "info", message: `Processing ${basename9(input)}...` });
       const options = {
         fuzz: opts.fuzz ?? defaults.fuzz,
         doTrim: opts.trim ?? defaults.trim,
@@ -3206,22 +3487,25 @@ async function runGUI8(inputRaw) {
         makeSquare: opts.makeSquare ?? defaults.makeSquare
       };
       const fileInfo = getFileInfo(input);
-      const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg.png`;
-      logs.push({ type: "info", message: "Removing background..." });
+      const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+      const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg${outputExt}`;
+      const logs = [];
       const success2 = await processImageSilent(input, borderColor, options, logs);
-      if (success2) {
+      if (success2 && existsSync13(output)) {
         const finalDims = await getDimensions(output);
         const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
+        const buffer = readFileSync10(output);
+        const mimeType = outputExt === ".gif" ? "image/gif" : "image/png";
+        const imageData = `data:${mimeType};base64,${buffer.toString("base64")}`;
         return {
           success: true,
           output: `${basename9(output)}${sizeStr}`,
-          logs
+          imageData
         };
       }
       return {
         success: false,
-        error: "Processing failed",
-        logs
+        error: "Processing failed"
       };
     }
   });
@@ -3280,9 +3564,9 @@ async function processImageSilent(input, borderColor, options, logs) {
 async function generatePreview5(input, borderColor, options) {
   const tempDir = tmpdir7();
   const timestamp = Date.now();
-  const tempSource = join10(tempDir, `piclet-preview-${timestamp}-src.png`);
-  const tempFile = join10(tempDir, `piclet-preview-${timestamp}.png`);
-  const tempOutput = join10(tempDir, `piclet-preview-${timestamp}-out.png`);
+  const tempSource = join11(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempFile = join11(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempOutput = join11(tempDir, `piclet-preview-${timestamp}-out.png`);
   try {
     let previewInput = input;
     if (isMultiFrame(input)) {
@@ -3310,13 +3594,13 @@ async function generatePreview5(input, borderColor, options) {
       }
     }
     if (options.makeSquare) {
-      const squareFile = join10(tempDir, `piclet-preview-${timestamp}-sq.png`);
+      const squareFile = join11(tempDir, `piclet-preview-${timestamp}-sq.png`);
       if (await squarify(currentFile, squareFile)) {
         cleanup(currentFile);
         currentFile = squareFile;
       }
     }
-    const buffer = readFileSync9(currentFile);
+    const buffer = readFileSync10(currentFile);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(currentFile);
@@ -3340,9 +3624,9 @@ var config8 = {
 };
 
 // src/tools/rescale.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { basename as basename10, join as join11 } from "path";
+import { basename as basename10, join as join12 } from "path";
 async function run8(inputRaw) {
   if (!await checkImageMagick()) {
     error("ImageMagick not found. Please install it:");
@@ -3351,7 +3635,7 @@ async function run8(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync12(input)) {
+  if (!existsSync14(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -3412,7 +3696,7 @@ async function run8(inputRaw) {
   } else {
     scaled = await resize(input, output, targetW, targetH);
   }
-  if (!scaled || !existsSync12(output)) {
+  if (!scaled || !existsSync14(output)) {
     wipDone(false, "Scaling failed");
     return false;
   }
@@ -3428,7 +3712,7 @@ async function run8(inputRaw) {
 }
 async function runGUI9(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync12(input)) {
+  if (!existsSync14(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -3482,7 +3766,7 @@ async function runGUI9(inputRaw) {
       } else {
         scaled = await resize(input, output, options.width, options.height);
       }
-      if (scaled && existsSync12(output)) {
+      if (scaled && existsSync14(output)) {
         const finalDims = await getDimensions(output);
         const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
         logs.push({ type: "success", message: "Scaled successfully" });
@@ -3500,8 +3784,8 @@ async function runGUI9(inputRaw) {
 async function generatePreview6(input, options) {
   const tempDir = tmpdir8();
   const timestamp = Date.now();
-  const tempSource = join11(tempDir, `piclet-preview-${timestamp}-src.png`);
-  const tempOutput = join11(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempSource = join12(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join12(tempDir, `piclet-preview-${timestamp}.png`);
   try {
     let previewInput = input;
     if (isMultiFrame(input)) {
@@ -3521,11 +3805,11 @@ async function generatePreview6(input, options) {
     } else {
       scaled = await resize(previewInput, tempOutput, targetW, targetH);
     }
-    if (!scaled || !existsSync12(tempOutput)) {
+    if (!scaled || !existsSync14(tempOutput)) {
       cleanup(tempSource);
       return { success: false, error: "Scaling failed" };
     }
-    const buffer = readFileSync10(tempOutput);
+    const buffer = readFileSync11(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
@@ -3549,8 +3833,8 @@ var config9 = {
 };
 
 // src/tools/storepack.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7 } from "fs";
-import { basename as basename11, join as join12 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8 } from "fs";
+import { basename as basename11, join as join13 } from "path";
 async function scaleImage(input, output, width, height, mode) {
   switch (mode) {
     case "fill":
@@ -3567,7 +3851,7 @@ async function generatePresetImages(sourceImg, outputDir, preset, scaleMode = "f
   const total = preset.icons.length;
   for (let i = 0; i < total; i++) {
     const icon = preset.icons[i];
-    const outputPath = join12(outputDir, icon.filename);
+    const outputPath = join13(outputDir, icon.filename);
     if (logs) {
       logs.push({ type: "info", message: `[${i + 1}/${total}] ${icon.filename}` });
     } else {
@@ -3603,7 +3887,7 @@ async function run9(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync13(input)) {
+  if (!existsSync15(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -3631,11 +3915,11 @@ async function run9(inputRaw) {
     return false;
   }
   const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${preset.id}`;
-  mkdirSync7(outputDir, { recursive: true });
+  mkdirSync8(outputDir, { recursive: true });
   info(`Output: ${outputDir}`);
   console.log("");
   wip("Preparing source...");
-  const tempSource = join12(outputDir, ".source.png");
+  const tempSource = join13(outputDir, ".source.png");
   if (!await squarify(input, tempSource)) {
     wipDone(false, "Failed to prepare source");
     return false;
@@ -3656,7 +3940,7 @@ async function run9(inputRaw) {
 }
 async function runGUI10(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync13(input)) {
+  if (!existsSync15(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -3705,7 +3989,7 @@ async function runGUI10(inputRaw) {
         };
       }
       const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${preset.id}`;
-      mkdirSync7(outputDir, { recursive: true });
+      mkdirSync8(outputDir, { recursive: true });
       logs.push({ type: "info", message: `Output: ${outputDir}` });
       logs.push({ type: "info", message: `Scale mode: ${scaleMode}` });
       logs.push({ type: "info", message: `Generating ${preset.icons.length} images...` });
@@ -3734,9 +4018,9 @@ var config10 = {
 };
 
 // src/tools/transform.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
 import { tmpdir as tmpdir9 } from "os";
-import { basename as basename12, join as join13 } from "path";
+import { basename as basename12, join as join14 } from "path";
 var TRANSFORM_LABELS = {
   "flip-h": "Flip Horizontal",
   "flip-v": "Flip Vertical",
@@ -3812,7 +4096,7 @@ async function run10(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync14(input)) {
+  if (!existsSync16(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -3831,7 +4115,7 @@ async function run10(inputRaw) {
 }
 async function runGUI11(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync14(input)) {
+  if (!existsSync16(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -3914,8 +4198,8 @@ async function runGUI11(inputRaw) {
 async function generatePreview7(input, options) {
   const tempDir = tmpdir9();
   const timestamp = Date.now();
-  const tempSource = join13(tempDir, `piclet-preview-${timestamp}-src.png`);
-  const tempOutput = join13(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempSource = join14(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join14(tempDir, `piclet-preview-${timestamp}.png`);
   try {
     let previewInput = input;
     if (isMultiFrame(input)) {
@@ -3946,7 +4230,7 @@ async function generatePreview7(input, options) {
       cleanup(tempSource, tempOutput);
       return { success: false, error: "Transform failed" };
     }
-    const buffer = readFileSync11(tempOutput);
+    const buffer = readFileSync12(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
@@ -4003,6 +4287,10 @@ function getToolsForExtension(extension) {
 }
 
 // src/cli/utils.ts
+import { extname as extname4 } from "path";
+import { dirname as dirname9 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk from "chalk";
 function getDistDir() {
   const currentFile = fileURLToPath2(import.meta.url);
   return dirname9(currentFile);
@@ -4014,7 +4302,7 @@ function validateExtensions(files, allowedExtensions) {
   const valid = [];
   const invalid = [];
   for (const file of files) {
-    const ext = extname3(file).toLowerCase();
+    const ext = extname4(file).toLowerCase();
     if (allowedExtensions.includes(ext)) {
       valid.push(file);
     } else {
@@ -4074,7 +4362,7 @@ function registerBorderCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -4118,7 +4406,7 @@ function registerExtractFramesCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI2(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -4145,7 +4433,7 @@ function registerFilterCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI3(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -4179,7 +4467,7 @@ function registerIconpackCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI4(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -4196,7 +4484,7 @@ import chalk7 from "chalk";
 
 // src/lib/registry.ts
 import { exec as exec2 } from "child_process";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { dirname as dirname10 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { promisify as promisify2 } from "util";
@@ -4205,7 +4493,7 @@ function isWSL() {
   return process.platform === "linux" && (process.env.WSL_DISTRO_NAME !== void 0 || process.env.WSLENV !== void 0);
 }
 function isWSLInteropEnabled() {
-  return existsSync15("/proc/sys/fs/binfmt_misc/WSLInterop");
+  return existsSync17("/proc/sys/fs/binfmt_misc/WSLInterop");
 }
 async function addRegistryKey(keyPath, valueName, value, type = "REG_SZ") {
   const valueArg = valueName ? `/v "${valueName}"` : "/ve";
@@ -4247,7 +4535,7 @@ async function deleteRegistryKey(keyPath) {
 
 // src/cli/registry.ts
 import { writeFile } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 async function registerUnifiedMenu(extension, iconsDir, launcherPath) {
   const basePath = `HKCU\\Software\\Classes\\SystemFileAssociations\\${extension}\\shell\\PicLet`;
   const iconsDirWin = wslToWindows(iconsDir);
@@ -4283,8 +4571,8 @@ async function unregisterMenuForExtension(extension) {
 }
 async function registerAllTools() {
   const distDir = getDistDir();
-  const iconsDir = join14(distDir, "icons");
-  const launcherPath = join14(distDir, "launcher.vbs");
+  const iconsDir = join15(distDir, "icons");
+  const launcherPath = join15(distDir, "launcher.vbs");
   const results = [];
   for (const extension of picletTool.config.extensions) {
     const result = await registerUnifiedMenu(extension, iconsDir, launcherPath);
@@ -4360,8 +4648,8 @@ function escapeRegValue(value) {
 }
 function generateRegContent() {
   const distDir = getDistDir();
-  const iconsDir = join14(distDir, "icons");
-  const launcherPath = join14(distDir, "launcher.vbs");
+  const iconsDir = join15(distDir, "icons");
+  const launcherPath = join15(distDir, "launcher.vbs");
   const iconsDirWin = wslToWindows(iconsDir);
   const launcherWin = wslToWindows(launcherPath);
   const lines = ["Windows Registry Editor Version 5.00", ""];
@@ -4398,14 +4686,14 @@ function generateUninstallRegContent() {
 }
 async function generateRegFile() {
   const distDir = getDistDir();
-  const regPath = join14(distDir, "piclet-install.reg");
+  const regPath = join15(distDir, "piclet-install.reg");
   const content = generateRegContent();
   await writeFile(regPath, content, "utf-8");
   return regPath;
 }
 async function generateUninstallRegFile() {
   const distDir = getDistDir();
-  const regPath = join14(distDir, "piclet-uninstall.reg");
+  const regPath = join15(distDir, "piclet-uninstall.reg");
   const content = generateUninstallRegContent();
   await writeFile(regPath, content, "utf-8");
   return regPath;
@@ -4458,9 +4746,22 @@ function registerInstallCommand(program2) {
         chalk7.yellow(`! Registered ${successCount}/${results.length} entries.`)
       );
     }
-    console.log(chalk7.bold("\nUsage:"));
+    console.log(chalk7.bold("\nContext Menu Usage:"));
     console.log("  Right-click any supported image in Windows Explorer.");
     console.log("  Multi-select supported for batch processing.");
+    console.log(chalk7.bold("\nCLI Usage:"));
+    console.log(chalk7.cyan("  piclet <image>") + chalk7.dim("         Open GUI editor"));
+    console.log(chalk7.cyan("  piclet makeicon <img>") + chalk7.dim("  Convert to .ico"));
+    console.log(chalk7.cyan("  piclet remove-bg <img>") + chalk7.dim(" Remove background"));
+    console.log(chalk7.cyan("  piclet scale <img>") + chalk7.dim("     Resize image"));
+    console.log(chalk7.cyan("  piclet iconpack <img>") + chalk7.dim("  Generate icon pack"));
+    console.log(chalk7.cyan("  piclet storepack <img>") + chalk7.dim(" Generate store assets"));
+    console.log(chalk7.cyan("  piclet transform <img>") + chalk7.dim(" Rotate/flip image"));
+    console.log(chalk7.cyan("  piclet filter <img>") + chalk7.dim("    Apply filters"));
+    console.log(chalk7.cyan("  piclet border <img>") + chalk7.dim("    Add border"));
+    console.log(chalk7.cyan("  piclet recolor <img>") + chalk7.dim("   Replace colors"));
+    console.log(chalk7.cyan("  piclet extract-frames <gif>") + chalk7.dim(" Extract GIF frames"));
+    console.log(chalk7.dim('\n  Run "piclet --help" for full documentation.'));
     console.log();
   });
 }
@@ -4480,7 +4781,7 @@ function registerMakeiconCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI5(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -4522,7 +4823,7 @@ function registerRecolorCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI7(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -4549,7 +4850,7 @@ function registerRemoveBgCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI8(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     if (options.fuzz !== void 0) {
@@ -4589,7 +4890,7 @@ function registerScaleCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI9(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -4616,7 +4917,7 @@ function registerStorepackCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI10(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -4643,7 +4944,7 @@ function registerTransformCommand(program2) {
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI11(valid[0]);
+      const result = await picletTool.runGUI(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(