optimo 0.0.15 → 0.0.17

package/README.md

@@ -6,29 +6,54 @@
   <img alt="Last version" src="https://img.shields.io/github/tag/kikobeats/optimo.svg?style=flat-square">
   <a href="https://www.npmjs.org/package/optimo"><img alt="NPM Status" src="https://img.shields.io/npm/dm/optimo.svg?style=flat-square"></a>
   <br><br>
+  optimo reduces image file size aggressively, and safely.
 </div>
 
-`optimo` is an CLI for aggressively reducing image file size with sane defaults. It's implemented on top of [ImageMagick](https://imagemagick.org/#gsc.tab=0).
+## Highlights
+
+- Format-specific tuning for stronger size reduction.
+- Safety guard: if optimized output is not smaller, original file is kept.
+- Backed by proven tools: ImageMagick, SVGO, Gifsicle, and MozJPEG.
+- Resizing supports percentage values (`50%`), max file size targets (`100kB`), width (`w960`), & height (`h480`).
 
-## Install
+## Usage
 
 ```bash
 npx -y optimo public/media            # for a directory
 npx -y optimo public/media/banner.png # for a file
-npx -y optimo public/media/banner.png -f jpeg # convert + optimize
-npx -y optimo public/media/banner.png -r 50% # resize + optimize
-npx -y optimo public/media/banner.png -r 100kB # resize to max file size
-npx -y optimo public/media/banner.png -r w960 # resize to max width
-npx -y optimo public/media/banner.png -r h480 # resize to max height
+npx -y optimo public/media/banner.png --losy # enable lossy + lossless mode
+npx -y optimo public/media/banner.png --format jpeg # convert + optimize
+npx -y optimo public/media/banner.png --resize 50% # resize + optimize
+npx -y optimo public/media/banner.png --resize 100kB # resize to max file size
+npx -y optimo public/media/banner.png --resize w960 # resize to max width
+npx -y optimo public/media/banner.png --resize h480 # resize to max height
+npx -y optimo public/media/banner.heic --dry-run --verbose # inspect unsupported failures
 ```
 
-## Highlights
+## Pipelines
 
-- Metadata stripping.
-- Compression-first per format.
-- Format-specific tuning for stronger size reduction.
-- Safety guard: if optimized output is not smaller, original file is kept.
-- Resizing supports percentage values (`50%`), max file size targets (`100kB`), width (`w960`), & height (`h480`).
+When `optimo` is executed, a pipeline of compressors is chosen based on the output file format:
+
+- `.png` -> `magick.png`
+- `.svg` -> `svgo.svg`
+- `.jpg/.jpeg` -> `magick.jpg/jpeg` + `mozjpegtran.jpg/jpeg`
+- `.gif` -> `magick.gif` + `gifsicle.gif`
+- other formats (`webp`, `avif`, `heic`, `heif`, `jxl`, etc.) -> `magick.<format>`
+
+Mode behavior:
+
+- default: lossless-first pipeline.
+- `-l, --losy`: lossy + lossless pass per matching compressor.
+- `-v, --verbose`: print debug logs (selected pipeline, binaries, executed commands, and errors).
+
+
+Example output:
+
+```
+✓ banner.jpg  1.2MB → 348kB  (-71%)
+```
+
+If the optimized file isn’t smaller, the original is kept.
 
 ## Programmatic API
 
@@ -38,6 +63,7 @@ const optimo = require('optimo')
 // optimize a single file
 await optimo.file('/absolute/path/image.jpg', {
   dryRun: false,
+  losy: false,
   format: 'webp',
   resize: '50%',
   onLogs: console.log

package/bin/help.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { gray, blue } = require('../src/colors')
+const { gray, blue } = require('../src/util/colors')
 
 module.exports = gray(`Efortless image optimizer
 
@@ -8,12 +8,15 @@ Usage
   $ ${blue('optimo')} <file|dir> [options]
 
 Options
+  -l, --losy  Enable lossy + lossless pass (ImgBot-style aggressive mode)
   -d, --dry-run  Show what would be optimized without making changes
   -f, --format   Convert output format (e.g. jpeg, webp, avif)
   -r, --resize   Resize by percentage (50%), size (100kB), width (w960), or height (h480)
+  -v, --verbose  Print debug logs (commands, pipeline, and errors)
 
 Examples
   $ optimo image.jpg
+  $ optimo image.jpg --losy
   $ optimo image.png --dry-run
   $ optimo image.jpg -d
   $ optimo image.png -f jpeg
@@ -21,4 +24,5 @@ Examples
   $ optimo image.png -r 100kB
   $ optimo image.png -r w960
   $ optimo image.png -r h480
+  $ optimo image.heic -d -v
 `)

package/bin/index.js

@@ -2,18 +2,18 @@
 'use strict'
 
 const { stat } = require('node:fs/promises')
-const optimo = require('optimo')
+const colors = require('../src/util/colors')
 const mri = require('mri')
 
-const colors = require('../src/colors')
-
 async function main () {
   const argv = mri(process.argv.slice(2), {
     alias: {
       'dry-run': 'd',
       format: 'f',
+      losy: 'l',
       resize: 'r',
-      silent: 's'
+      silent: 's',
+      verbose: 'v'
     }
   })
 
@@ -22,11 +22,7 @@ async function main () {
 
   if (resize !== undefined && resize !== null) {
     const unitToken = argv._[1]
-    if (
-      unitToken &&
-      /^[kmg]?b$/i.test(unitToken) &&
-      /^\d*\.?\d+$/.test(String(resize))
-    ) {
+    if (unitToken && /^[kmg]?b$/i.test(unitToken) && /^\d*\.?\d+$/.test(String(resize))) {
       resize = `${resize}${unitToken}`
     }
   }
@@ -36,14 +32,19 @@ async function main () {
     process.exit(0)
   }
 
+  if (argv.verbose) {
+    process.env.DEBUG = `${process.env.DEBUG ? `${process.env.DEBUG},` : ''}optimo*`
+  }
+
   const stats = await stat(input)
   const isDirectory = stats.isDirectory()
-  const fn = isDirectory ? optimo.dir : optimo.file
+  const fn = isDirectory ? require('optimo').dir : require('optimo').file
 
   const logger = argv.silent ? () => {} : logEntry => console.log(logEntry)
   !argv.silent && console.log()
 
   await fn(input, {
+    losy: argv.losy,
     dryRun: argv['dry-run'],
     format: argv.format,
     resize,

package/package.json

@@ -2,7 +2,7 @@
   "name": "optimo",
   "description": "The no-brainer ImageMagick CLI for optimizing images",
   "homepage": "https://github.com/kikobeats/optimo",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "exports": {
     ".": "./src/index.js"
   },
@@ -32,6 +32,7 @@
     "optimize"
   ],
   "dependencies": {
+    "debug-logfmt": "~1.4.7",
     "mri": "~1.2.0",
     "tinyspawn": "~1.5.5"
   },

package/src/compressor/gifsicle.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const { unlink } = require('node:fs/promises')
+const $ = require('tinyspawn')
+
+const resolveBinary = require('../util/resolve-binary')
+
+const binaryPath = resolveBinary('gifsicle')
+
+const withMeta = (format, fn) => {
+  const wrapped = async ctx => fn(ctx)
+  wrapped.binaryName = 'gifsicle'
+  wrapped.binaryPath = binaryPath
+  wrapped.format = format
+  return wrapped
+}
+
+const runLossless = async ({ inputPath, outputPath }) =>
+  $(binaryPath, ['-O3', inputPath, '-o', outputPath])
+
+const runLossy = async ({ inputPath, outputPath }) =>
+  $(binaryPath, ['-O3', '--lossy=80', inputPath, '-o', outputPath])
+
+const gif = withMeta('gif', async ({ inputPath, outputPath, losy = false }) => {
+  if (!losy) return runLossless({ inputPath, outputPath })
+
+  const lossyPath = `${outputPath}.lossy.gif`
+  try {
+    await runLossy({ inputPath, outputPath: lossyPath })
+    return runLossless({ inputPath: lossyPath, outputPath })
+  } finally {
+    try {
+      await unlink(lossyPath)
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        // Ignore cleanup failures.
+      }
+    }
+  }
+})
+
+module.exports = { binaryPath, gif }

package/src/compressor/index.js

@@ -0,0 +1,46 @@
+'use strict'
+
+const path = require('node:path')
+
+const mozjpegtran = require('./mozjpegtran')
+const gifsicle = require('./gifsicle')
+const magick = require('./magick')
+const svgo = require('./svgo')
+
+const PIPELINES = {
+  '.png': [magick.png],
+  '.svg': [svgo.svg],
+  '.jpg': [magick.jpg, mozjpegtran.jpg],
+  '.jpeg': [magick.jpeg, mozjpegtran.jpeg],
+  '.gif': [magick.gif, gifsicle.gif],
+  '.webp': [magick.webp],
+  '.avif': [magick.avif],
+  '.heic': [magick.heic],
+  '.heif': [magick.heif],
+  '.jxl': [magick.jxl]
+}
+
+const getPipeline = filePath => {
+  const ext = path.extname(filePath).toLowerCase()
+  return PIPELINES[ext] || [magick.file]
+}
+
+const getRequiredBinaries = (pipeline, opts = {}) => {
+  const binaries = []
+
+  for (const step of pipeline.filter(Boolean)) {
+    if (typeof step.getRequiredBinaries === 'function') {
+      binaries.push(...step.getRequiredBinaries(opts))
+      continue
+    }
+
+    binaries.push({
+      name: step.binaryName,
+      binaryPath: step.binaryPath || false
+    })
+  }
+
+  return Array.from(new Map(binaries.map(binary => [binary.name, binary])).values())
+}
+
+module.exports = { getPipeline, getRequiredBinaries }

package/src/compressor/magick.js

@@ -0,0 +1,274 @@
+'use strict'
+
+const { stat, rename, unlink } = require('node:fs/promises')
+const { execFileSync } = require('node:child_process')
+const path = require('node:path')
+const $ = require('tinyspawn')
+
+const resolveBinary = require('../util/resolve-binary')
+
+const binaryPath = resolveBinary('magick')
+
+const PNG_QUALITY_CANDIDATES = [91, 94, 95, 97]
+
+const withMeta = (format, fn) => {
+  const wrapped = async ctx => fn(ctx)
+  wrapped.binaryName = 'magick'
+  wrapped.binaryPath = binaryPath
+  wrapped.format = format
+  return wrapped
+}
+
+const MAGICK_JPEG_LOSSY_FLAGS = [
+  '-strip',
+  '-sampling-factor',
+  '4:2:0',
+  '-define',
+  'jpeg:optimize-coding=true',
+  '-define',
+  'jpeg:dct-method=float',
+  '-quality',
+  '80',
+  '-interlace',
+  'Plane'
+]
+
+const MAGICK_JPEG_LOSSLESS_FLAGS = ['-define', 'jpeg:optimize-coding=true', '-interlace', 'Plane']
+
+const MAGICK_PNG_LOSSLESS_FLAGS = []
+const MAGICK_PNG_LOSSY_FLAGS = [
+  '-strip',
+  '-define',
+  'png:exclude-chunks=all',
+  '-define',
+  'png:include-chunks=tRNS,gAMA'
+]
+
+const MAGICK_GIF_FLAGS = ['-strip', '-coalesce', '-layers', 'OptimizePlus']
+
+const MAGICK_WEBP_FLAGS = ['-strip', '-define', 'webp:method=6', '-define', 'webp:thread-level=1', '-quality', '80']
+
+const MAGICK_AVIF_FLAGS = ['-strip', '-define', 'heic:speed=1', '-quality', '50']
+
+const MAGICK_HEIC_FLAGS = ['-strip', '-quality', '75']
+
+const MAGICK_JXL_FLAGS = ['-strip', '-define', 'jxl:effort=9', '-quality', '75']
+
+const MAGICK_SVG_FLAGS = ['-strip']
+
+const MAGICK_GENERIC_FLAGS = ['-strip']
+
+const flagsByExt = ({ ext, losy = false }) => {
+  if (ext === '.jpg' || ext === '.jpeg') return losy ? MAGICK_JPEG_LOSSY_FLAGS : MAGICK_JPEG_LOSSLESS_FLAGS
+  if (ext === '.png') return losy ? MAGICK_PNG_LOSSY_FLAGS : MAGICK_PNG_LOSSLESS_FLAGS
+  if (ext === '.gif') return MAGICK_GIF_FLAGS
+  if (ext === '.webp') return MAGICK_WEBP_FLAGS
+  if (ext === '.avif') return MAGICK_AVIF_FLAGS
+  if (ext === '.heic' || ext === '.heif') return MAGICK_HEIC_FLAGS
+  if (ext === '.jxl') return MAGICK_JXL_FLAGS
+  if (ext === '.svg') return MAGICK_SVG_FLAGS
+  return MAGICK_GENERIC_FLAGS
+}
+
+const isAnimatedPng = ({ filePath }) => {
+  try {
+    const frames = execFileSync(binaryPath, ['identify', '-format', '%n', filePath], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    })
+      .trim()
+      .split(/\s+/)
+      .map(value => Number.parseInt(value, 10))
+      .find(value => Number.isFinite(value) && value > 0)
+
+    const animated = (frames || 1) > 1
+    return animated
+  } catch (error) {
+    return false
+  }
+}
+
+const writePng = async ({ inputPath, outputPath, flags, resizeGeometry }) => {
+  const writeCandidates = isAnimatedPng({ filePath: inputPath }) ? [90] : PNG_QUALITY_CANDIDATES
+  const candidatePaths = []
+  let bestPath = null
+  let bestSize = Number.POSITIVE_INFINITY
+
+  try {
+    for (const quality of writeCandidates) {
+      const candidatePath = `${outputPath}.q${quality}.png`
+      candidatePaths.push(candidatePath)
+
+      const args = [
+        inputPath,
+        ...(resizeGeometry ? ['-resize', resizeGeometry] : []),
+        ...flags,
+        '-quality',
+        String(quality),
+        candidatePath
+      ]
+
+      await $(binaryPath, args)
+      const size = (await stat(candidatePath)).size
+
+      if (size < bestSize) {
+        bestSize = size
+        bestPath = candidatePath
+      }
+    }
+
+    if (!bestPath) throw new Error('No PNG candidate was generated')
+
+    await rename(bestPath, outputPath)
+  } finally {
+    for (const candidatePath of candidatePaths) {
+      if (candidatePath === bestPath) continue
+      try {
+        await unlink(candidatePath)
+      } catch (error) {
+        if (error.code !== 'ENOENT') {
+          // Ignore cleanup failures to avoid masking optimization results.
+        }
+      }
+    }
+  }
+}
+
+const runOnce = async ({ inputPath, outputPath, resizeGeometry, losy = false }) => {
+  const ext = path.extname(outputPath).toLowerCase()
+  const flags = flagsByExt({ ext, losy })
+
+  if (ext === '.png') {
+    return writePng({ inputPath, outputPath, flags, resizeGeometry })
+  }
+
+  return $(binaryPath, [inputPath, ...(resizeGeometry ? ['-resize', resizeGeometry] : []), ...flags, outputPath])
+}
+
+const runMaxSize = async ({ inputPath, outputPath, maxSize, losy = false }) => {
+  const resultByScale = new Map()
+
+  const measureScale = async scale => {
+    if (resultByScale.has(scale)) return resultByScale.get(scale)
+
+    const candidatePath = `${outputPath}.scale${scale}${path.extname(outputPath)}`
+    const resizeGeometry = scale === 100 ? null : `${scale}%`
+
+    await runOnce({
+      inputPath,
+      outputPath: candidatePath,
+      resizeGeometry,
+      losy
+    })
+
+    const size = (await stat(candidatePath)).size
+    resultByScale.set(scale, { size, candidatePath })
+    return resultByScale.get(scale)
+  }
+
+  const full = await measureScale(100)
+  if (full.size <= maxSize) return rename(full.candidatePath, outputPath)
+
+  const min = await measureScale(1)
+  if (min.size > maxSize) return rename(min.candidatePath, outputPath)
+
+  let low = 1
+  let high = 100
+  let bestScale = 1
+
+  while (high - low > 1) {
+    const mid = Math.floor((low + high) / 2)
+    const { size } = await measureScale(mid)
+
+    if (size <= maxSize) {
+      low = mid
+      bestScale = mid
+    } else {
+      high = mid
+    }
+  }
+
+  const best = await measureScale(bestScale)
+  await rename(best.candidatePath, outputPath)
+
+  for (const [scale, value] of resultByScale.entries()) {
+    if (scale === bestScale) continue
+    try {
+      await unlink(value.candidatePath)
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        // Ignore cleanup failures.
+      }
+    }
+  }
+}
+
+const run = async ({ inputPath, outputPath, resizeConfig, losy = false }) => {
+  if (resizeConfig?.mode === 'max-size') {
+    return runMaxSize({
+      inputPath,
+      outputPath,
+      maxSize: resizeConfig.value,
+      losy
+    })
+  }
+
+  if (!losy) {
+    return runOnce({
+      inputPath,
+      outputPath,
+      resizeGeometry: resizeConfig?.value,
+      losy: false
+    })
+  }
+
+  const lossyPath = `${outputPath}.lossy${path.extname(outputPath)}`
+  try {
+    await runOnce({
+      inputPath,
+      outputPath: lossyPath,
+      resizeGeometry: resizeConfig?.value,
+      losy: true
+    })
+    await runOnce({
+      inputPath: lossyPath,
+      outputPath,
+      losy: false
+    })
+  } finally {
+    try {
+      await unlink(lossyPath)
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        // Ignore cleanup failures.
+      }
+    }
+  }
+}
+
+const jpg = withMeta('jpg', run)
+const jpeg = withMeta('jpeg', run)
+const png = withMeta('png', run)
+const gif = withMeta('gif', run)
+const webp = withMeta('webp', run)
+const avif = withMeta('avif', run)
+const heic = withMeta('heic', run)
+const heif = withMeta('heif', run)
+const jxl = withMeta('jxl', run)
+const svg = withMeta('svg', run)
+const file = withMeta('file', run)
+
+module.exports = {
+  binaryPath,
+  jpg,
+  jpeg,
+  png,
+  gif,
+  webp,
+  avif,
+  heic,
+  heif,
+  jxl,
+  svg,
+  file
+}

package/src/compressor/mozjpegtran.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const $ = require('tinyspawn')
+const resolveBinary = require('../util/resolve-binary')
+
+const mozjpegtranPath =
+  resolveBinary('mozjpegtran') || resolveBinary('jpegtran')
+
+const withMeta = (format, fn) => {
+  const wrapped = async ctx => fn(ctx)
+  wrapped.binaryName = 'mozjpegtran'
+  wrapped.binaryPath = mozjpegtranPath
+  wrapped.getRequiredBinaries = () => [
+    { name: 'mozjpegtran/jpegtran', binaryPath: mozjpegtranPath || false }
+  ]
+  wrapped.format = format
+  return wrapped
+}
+
+const run = async ({ inputPath, outputPath }) =>
+  $(mozjpegtranPath, [
+    '-copy',
+    'none',
+    '-optimize',
+    '-outfile',
+    outputPath,
+    inputPath
+  ])
+
+const jpg = withMeta('jpg', run)
+const jpeg = withMeta('jpeg', run)
+
+module.exports = { binaryPath: mozjpegtranPath, jpg, jpeg }

package/src/compressor/svgo.js

@@ -0,0 +1,98 @@
+'use strict'
+
+const { unlink } = require('node:fs/promises')
+const $ = require('tinyspawn')
+
+const resolveBinary = require('../util/resolve-binary')
+
+const binaryPath = resolveBinary('svgo')
+
+const withMeta = (format, fn) => {
+  const wrapped = async ctx => fn(ctx)
+  wrapped.binaryName = 'svgo'
+  wrapped.binaryPath = binaryPath
+  wrapped.format = format
+  return wrapped
+}
+
+const COMMON_PLUGINS = [
+  'cleanupAttrs',
+  'cleanupListOfValues',
+  'cleanupNumericValues',
+  'convertColors',
+  'minifyStyles',
+  'moveGroupAttrsToElems',
+  'removeComments',
+  'removeDoctype',
+  'removeEditorsNSData',
+  'removeEmptyAttrs',
+  'removeEmptyContainers',
+  'removeEmptyText',
+  'removeNonInheritableGroupAttrs',
+  'removeXMLProcInst',
+  'sortAttrs'
+]
+
+const AGGRESSIVE_PLUGINS = COMMON_PLUGINS.concat([
+  'cleanupEnableBackground',
+  'cleanupIDs',
+  'collapseGroups',
+  'convertPathData',
+  'convertShapeToPath',
+  'convertTransform',
+  'mergePaths',
+  'moveElemsAttrsToGroup',
+  'removeAttrs',
+  'removeDesc',
+  'removeDimensions',
+  'removeElementsByAttr',
+  'removeHiddenElems',
+  'removeMetadata',
+  'removeRasterImages',
+  'removeStyleElement',
+  'removeTitle',
+  'removeUnknownsAndDefaults',
+  'removeUnusedNS',
+  'removeUselessDefs',
+  'removeUselessStrokeAndFill',
+  'removeViewBox',
+  'removeXMLNS'
+])
+
+const run = async ({ inputPath, outputPath, plugins }) =>
+  $(binaryPath, [
+    inputPath,
+    '--config={"full":true}',
+    '--multipass',
+    `--enable=${plugins.join(',')}`,
+    '--output',
+    outputPath
+  ])
+
+const svg = withMeta('svg', async ({ inputPath, outputPath, losy = false }) => {
+  if (!losy) return run({ inputPath, outputPath, plugins: COMMON_PLUGINS })
+
+  const lossyPath = `${outputPath}.lossy.svg`
+  try {
+    await run({
+      inputPath,
+      outputPath: lossyPath,
+      plugins: AGGRESSIVE_PLUGINS
+    })
+    await run({
+      inputPath: lossyPath,
+      outputPath,
+      plugins: COMMON_PLUGINS
+    })
+  } finally {
+    try {
+      await unlink(lossyPath)
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        // Ignore cleanup failures.
+      }
+    }
+  }
+})
+
+module.exports = { binaryPath, svg }

package/src/index.js

@@ -1,108 +1,83 @@
 'use strict'
 
-const { stat, unlink, rename, readdir } = require('node:fs/promises')
-
+const { stat, unlink, rename, readdir, copyFile } = require('node:fs/promises')
 const path = require('node:path')
-const $ = require('tinyspawn')
-
-const { magickPath, magickFlags } = require('./magick')
-const { yellow, gray, green } = require('./colors')
-
-const {
-  formatBytes,
-  formatLog,
-  normalizeFormat,
-  parseResize,
-  percentage
-} = require('./util')
-
-const getOutputPath = (filePath, format) => {
-  const normalizedFormat = normalizeFormat(format)
-  if (!normalizedFormat) return filePath
-  const parsed = path.parse(filePath)
-  return path.join(parsed.dir, `${parsed.name}.${normalizedFormat}`)
-}
 
-const runMagick = async ({
-  filePath,
-  optimizedPath,
-  flags,
-  resizeGeometry = null
-}) => {
-  const magickArgs = [
-    filePath,
-    ...(resizeGeometry ? ['-resize', resizeGeometry] : []),
-    ...flags,
-    optimizedPath
-  ]
-
-  await $('magick', magickArgs)
-  return (await stat(optimizedPath)).size
+const { getPipeline, getRequiredBinaries } = require('./compressor')
+const ensureBinaries = require('./util/ensure-binaries')
+const { yellow, gray, green } = require('./util/colors')
+const getOutputPath = require('./util/get-output-path')
+const formatBytes = require('./util/format-bytes')
+const parseResize = require('./util/parse-resize')
+const percentage = require('./util/percentage')
+const formatLog = require('./util/format-log')
+const debug = require('./util/debug')
+
+const runStepInPlaceIfSmaller = async ({ currentPath, extension, step }) => {
+  const candidatePath = `${currentPath}.candidate${extension}`
+
+  await step({
+    inputPath: currentPath,
+    outputPath: candidatePath,
+    resizeConfig: null,
+    losy: false
+  })
+
+  const [currentSize, candidateSize] = await Promise.all([
+    stat(currentPath).then(value => value.size),
+    stat(candidatePath).then(value => value.size)
+  ])
+
+  if (candidateSize < currentSize) {
+    await unlink(currentPath)
+    await rename(candidatePath, currentPath)
+  } else {
+    await unlink(candidatePath)
+  }
 }
 
-const optimizeForMaxSize = async ({
-  filePath,
-  optimizedPath,
-  flags,
-  maxSize
-}) => {
-  const resultByScale = new Map()
-
-  const measureScale = async scale => {
-    if (resultByScale.has(scale)) return resultByScale.get(scale)
-    const resizeGeometry = scale === 100 ? null : `${scale}%`
-    const size = await runMagick({
-      filePath,
-      optimizedPath,
-      flags,
-      resizeGeometry
+const executePipeline = async ({ pipeline, filePath, optimizedPath, resizeConfig, losy }) => {
+  const extension = path.extname(optimizedPath) || '.tmp'
+
+  await pipeline[0]({
+    inputPath: filePath,
+    outputPath: optimizedPath,
+    resizeConfig,
+    losy
+  })
+
+  for (const step of pipeline.slice(1)) {
+    await runStepInPlaceIfSmaller({
+      currentPath: optimizedPath,
+      extension,
+      step: async args => step({ ...args, losy })
     })
-    resultByScale.set(scale, size)
-    return size
-  }
-
-  const fullSize = await measureScale(100)
-  if (fullSize <= maxSize) {
-    return fullSize
-  }
-
-  const minScaleSize = await measureScale(1)
-  if (minScaleSize > maxSize) {
-    return minScaleSize
-  }
-
-  let low = 1
-  let high = 100
-  let bestScale = 1
-
-  while (high - low > 1) {
-    const mid = Math.floor((low + high) / 2)
-    const size = await measureScale(mid)
-
-    if (size <= maxSize) {
-      low = mid
-      bestScale = mid
-    } else {
-      high = mid
-    }
   }
 
-  await measureScale(bestScale)
-  return resultByScale.get(bestScale)
+  return (await stat(optimizedPath)).size
 }
 
-const file = async (
-  filePath,
-  { onLogs = () => {}, dryRun, format: outputFormat, resize } = {}
-) => {
-  if (!magickPath) {
-    throw new Error('ImageMagick is not installed')
-  }
+const file = async (filePath, { onLogs = () => {}, dryRun, format: outputFormat, resize, losy = false } = {}) => {
   const outputPath = getOutputPath(filePath, outputFormat)
   const resizeConfig = parseResize(resize)
-  const flags = magickFlags(outputPath)
+  const filePipeline = getPipeline(outputPath)
+  const executionPipeline = [...filePipeline]
+
+  const needsMagickForTransform = Boolean(resizeConfig) || outputPath !== filePath
+  if (needsMagickForTransform && executionPipeline[0]?.binaryName !== 'magick') {
+    const magick = require('./compressor/magick')
+    const ext = path.extname(outputPath).toLowerCase().replace(/^\./, '')
+    const magickStep = magick[ext] || magick.file
+    executionPipeline.unshift(magickStep)
+  }
+
+  ensureBinaries(
+    getRequiredBinaries(executionPipeline, {
+      losy
+    })
+  )
 
-  const optimizedPath = `${outputPath}.optimized`
+  const optimizedPath = `${outputPath}.optimized${path.extname(outputPath)}`
   const isConverting = outputPath !== filePath
 
   let originalSize
@@ -111,22 +86,36 @@ const file = async (
   try {
     originalSize = (await stat(filePath)).size
 
-    if (resizeConfig?.mode === 'max-size') {
-      optimizedSize = await optimizeForMaxSize({
-        filePath,
-        optimizedPath,
-        flags,
-        maxSize: resizeConfig.value
-      })
+    if (executionPipeline.length === 0) {
+      await copyFile(filePath, optimizedPath)
+      optimizedSize = (await stat(optimizedPath)).size
     } else {
-      optimizedSize = await runMagick({
+      optimizedSize = await executePipeline({
+        pipeline: executionPipeline,
         filePath,
         optimizedPath,
-        flags,
-        resizeGeometry: resizeConfig?.value
+        resizeConfig,
+        losy
       })
     }
-  } catch {
+  } catch (error) {
+    try {
+      await unlink(optimizedPath)
+    } catch (cleanupError) {
+      if (cleanupError.code !== 'ENOENT') {
+        debug.warn('file=optimize stage=cleanup-error', {
+          filePath: optimizedPath,
+          message: cleanupError?.message || 'cleanup failed'
+        })
+      }
+    }
+
+    debug.error('file=optimize stage=error', {
+      filePath,
+      message: error?.message || 'unknown',
+      code: error?.code || 'unknown',
+      name: error?.name || 'Error'
+    })
     onLogs(formatLog('[unsupported]', yellow, filePath))
     return { originalSize: 0, optimizedSize: 0 }
   }
@@ -169,9 +158,7 @@ const file = async (
 }
 
 const dir = async (folderPath, opts) => {
-  const items = (await readdir(folderPath, { withFileTypes: true })).filter(
-    item => !item.name.startsWith('.')
-  )
+  const items = (await readdir(folderPath, { withFileTypes: true })).filter(item => !item.name.startsWith('.'))
   let totalOriginalSize = 0
   let totalOptimizedSize = 0
 

package/src/util/debug.js

@@ -0,0 +1 @@
+module.exports = require('debug-logfmt')('optimo')

package/src/util/ensure-binaries.js

@@ -0,0 +1,12 @@
+'use strict'
+
+module.exports = binaries => {
+  const missing = binaries.filter(binary => !binary.binaryPath)
+  if (missing.length !== 0) {
+    throw new Error(
+      `Missing required binaries: ${missing
+        .map(binary => binary.name)
+        .join(', ')}`
+    )
+  }
+}

package/src/util/format-bytes.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = bytes => {
+  if (bytes === 0) return '0 B'
+  const k = 1024
+  const sizes = ['B', 'KB', 'MB', 'GB']
+  const i = Math.floor(Math.log(bytes) / Math.log(k))
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i]
+}

package/src/util/format-log.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const { gray } = require('./colors')
+
+const MAX_STATUS_LENGTH = 13 // Length of '[unsupported]'
+
+module.exports = (plainStatus, colorize, filePath) => {
+  const padding = MAX_STATUS_LENGTH - plainStatus.length
+  const paddedPlainStatus = plainStatus + ' '.repeat(Math.max(0, padding))
+  return `${colorize(paddedPlainStatus)} ${gray(filePath)}`
+}

package/src/util/get-output-path.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const path = require('path')
+
+const normalizeFormat = require('./normalize-format')
+
+module.exports = (filePath, format) => {
+  const normalizedFormat = normalizeFormat(format)
+  if (!normalizedFormat) return filePath
+  const parsed = path.parse(filePath)
+  return path.join(parsed.dir, `${parsed.name}.${normalizedFormat}`)
+}

package/src/util/normalize-format.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = format => {
+  if (!format) return null
+  const normalized = String(format).trim().toLowerCase().replace(/^\./, '')
+  if (normalized === 'jpg') return 'jpeg'
+  if (normalized === 'tif') return 'tiff'
+  return normalized
+}

package/src/{util.js → util/parse-resize.js}

@@ -1,35 +1,6 @@
 'use strict'
 
-const { gray } = require('./colors')
-
-const MAX_STATUS_LENGTH = 13 // Length of '[unsupported]'
-
-const formatBytes = bytes => {
-  if (bytes === 0) return '0 B'
-  const k = 1024
-  const sizes = ['B', 'KB', 'MB', 'GB']
-  const i = Math.floor(Math.log(bytes) / Math.log(k))
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i]
-}
-
-const formatLog = (plainStatus, colorize, filePath) => {
-  const padding = MAX_STATUS_LENGTH - plainStatus.length
-  const paddedPlainStatus = plainStatus + ' '.repeat(Math.max(0, padding))
-  return `${colorize(paddedPlainStatus)} ${gray(filePath)}`
-}
-
-const percentage = (partial, total) =>
-  (((partial - total) / total) * 100).toFixed(1)
-
-const normalizeFormat = format => {
-  if (!format) return null
-  const normalized = String(format).trim().toLowerCase().replace(/^\./, '')
-  if (normalized === 'jpg') return 'jpeg'
-  if (normalized === 'tif') return 'tiff'
-  return normalized
-}
-
-const parseResize = resize => {
+module.exports = resize => {
   if (resize === undefined || resize === null || resize === '') return null
 
   const raw = String(resize).trim()
@@ -84,11 +55,3 @@ const parseResize = resize => {
     value: `${value}%`
   }
 }
-
-module.exports = {
-  formatBytes,
-  formatLog,
-  normalizeFormat,
-  parseResize,
-  percentage
-}

package/src/util/percentage.js

@@ -0,0 +1,4 @@
+'use strict'
+
+module.exports = (partial, total) =>
+  (((partial - total) / total) * 100).toFixed(1)

package/src/util/resolve-binary.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { execSync } = require('node:child_process')
+
+module.exports = binary => {
+  try {
+    return execSync(`which ${binary}`, {
+      stdio: ['pipe', 'pipe', 'ignore']
+    })
+      .toString()
+      .trim()
+  } catch {
+    return false
+  }
+}

package/src/magick.js

@@ -1,128 +0,0 @@
-'use strict'
-
-const path = require('node:path')
-const { execSync } = require('child_process')
-
-const magickPath = (() => {
-  try {
-    return execSync('which magick', {
-      stdio: ['pipe', 'pipe', 'ignore']
-    })
-      .toString()
-      .trim()
-  } catch {
-    return false
-  }
-})()
-
-/*
- * JPEG preset (compression-first):
- * - Favor smaller output via chroma subsampling and optimized Huffman coding.
- * - Progressive scan improves perceived loading on the web.
- */
-const MAGICK_JPEG_FLAGS = [
-  '-strip',
-  '-sampling-factor',
-  '4:2:0',
-  '-define',
-  'jpeg:optimize-coding=true',
-  '-define',
-  'jpeg:dct-method=float',
-  '-quality',
-  '80',
-  '-interlace',
-  'Plane'
-]
-
-/*
- * PNG preset (maximum deflate effort):
- * - Strip metadata payloads.
- * - Use highest compression level with explicit strategy/filter tuning.
- */
-const MAGICK_PNG_FLAGS = [
-  '-strip',
-  '-define',
-  'png:compression-level=9',
-  '-define',
-  'png:compression-strategy=1',
-  '-define',
-  'png:compression-filter=5'
-]
-
-/*
- * GIF preset (animation optimization):
- * - Coalesce frames before layer optimization to maximize delta compression.
- * - OptimizePlus is more aggressive for animated GIF size reduction.
- */
-const MAGICK_GIF_FLAGS = ['-strip', '-coalesce', '-layers', 'OptimizePlus']
-
-/*
- * WebP preset (compression-first):
- * - Use a strong encoder method and preserve compatibility with lossy output.
- */
-const MAGICK_WEBP_FLAGS = [
-  '-strip',
-  '-define',
-  'webp:method=6',
-  '-define',
-  'webp:thread-level=1',
-  '-quality',
-  '80'
-]
-
-/*
- * AVIF preset (compression-first):
- * - Slow encoder speed for stronger compression.
- */
-const MAGICK_AVIF_FLAGS = [
-  '-strip',
-  '-define',
-  'heic:speed=1',
-  '-quality',
-  '50'
-]
-
-/*
- * HEIC/HEIF preset (compression-first):
- * - Slow encoder speed for stronger compression.
- */
-const MAGICK_HEIC_FLAGS = [
-  '-strip',
-  '-define',
-  'heic:speed=1',
-  '-quality',
-  '75'
-]
-
-/*
- * JPEG XL preset (compression-first):
- * - Use max effort where supported.
- */
-const MAGICK_JXL_FLAGS = ['-strip', '-define', 'jxl:effort=9', '-quality', '75']
-
-/*
- * SVG preset:
- * - Keep optimization minimal to avoid destructive transformations.
- */
-const MAGICK_SVG_FLAGS = ['-strip']
-
-/*
- * Generic preset for any other format:
- * - Keep it broadly safe across decoders while still reducing size.
- */
-const MAGICK_GENERIC_FLAGS = ['-strip']
-
-const magickFlags = filePath => {
-  const ext = path.extname(filePath).toLowerCase()
-  if (ext === '.jpg' || ext === '.jpeg') return MAGICK_JPEG_FLAGS
-  if (ext === '.png') return MAGICK_PNG_FLAGS
-  if (ext === '.gif') return MAGICK_GIF_FLAGS
-  if (ext === '.webp') return MAGICK_WEBP_FLAGS
-  if (ext === '.avif') return MAGICK_AVIF_FLAGS
-  if (ext === '.heic' || ext === '.heif') return MAGICK_HEIC_FLAGS
-  if (ext === '.jxl') return MAGICK_JXL_FLAGS
-  if (ext === '.svg') return MAGICK_SVG_FLAGS
-  return MAGICK_GENERIC_FLAGS
-}
-
-module.exports = { magickPath, magickFlags }