@koda-sl/baker-cli 0.551.0 → 0.552.0

package/dist/normalize-KXI3OOFS.js

@@ -0,0 +1,806 @@
+import {
+  atomicWrite,
+  expandInputs,
+  isDirectory,
+  isRemoteUrl,
+  readImageBuffer,
+  resolveOutputPath
+} from "./chunk-72K4LY24.js";
+import "./chunk-PA5PS5KO.js";
+import "./chunk-O4OPH3ZE.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-VYEFXIEM.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/normalize.ts
+import { defineCommand } from "citty";
+
+// src/lib/image/color-changer.ts
+import quantize from "quantize";
+var COLOR_RANGE_THRESHOLD = 15;
+var HEX_RE = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+function parseHex(hex) {
+  const match = HEX_RE.exec(hex.trim());
+  if (!match) {
+    throw new Error(`Invalid hex color: "${hex}". Expected #RGB or #RRGGBB.`);
+  }
+  let body = match[1];
+  if (body.length === 3) {
+    body = body.split("").map((c) => c + c).join("");
+  }
+  return {
+    r: Number.parseInt(body.slice(0, 2), 16),
+    g: Number.parseInt(body.slice(2, 4), 16),
+    b: Number.parseInt(body.slice(4, 6), 16)
+  };
+}
+function colorDistance(color1, color2) {
+  const rDiff = color1.r - color2.r;
+  const gDiff = color1.g - color2.g;
+  const bDiff = color1.b - color2.b;
+  return Math.sqrt(rDiff * rDiff + gDiff * gDiff + bDiff * bDiff);
+}
+function getDominantEdgeColor(data, width, height) {
+  const colorCount = {};
+  function accumulateColor(i, j) {
+    const idx = (i * width + j) * 4;
+    const colorKey = `${data[idx]},${data[idx + 1]},${data[idx + 2]}`;
+    colorCount[colorKey] = (colorCount[colorKey] ?? 0) + 1;
+  }
+  for (let j = 0; j < width; j++) {
+    accumulateColor(0, j);
+    accumulateColor(height - 1, j);
+  }
+  for (let i = 1; i < height - 1; i++) {
+    accumulateColor(i, 0);
+    accumulateColor(i, width - 1);
+  }
+  let maxCount = 0;
+  let dominantColor = { r: 0, g: 0, b: 0 };
+  for (const key in colorCount) {
+    const count = colorCount[key];
+    if (count > maxCount) {
+      maxCount = count;
+      const parts = key.split(",").map(Number);
+      dominantColor = { r: parts[0], g: parts[1], b: parts[2] };
+    }
+  }
+  return dominantColor;
+}
+function hasTransparency(data, threshold = 0.02) {
+  let transparentPixels = 0;
+  let totalPixels = 0;
+  for (let i = 3; i < data.length; i += 4) {
+    totalPixels++;
+    if (data[i] < 255) {
+      transparentPixels++;
+    }
+  }
+  if (totalPixels === 0) return false;
+  return transparentPixels / totalPixels > threshold;
+}
+function hasGradientColors(data) {
+  const uniqueColors = /* @__PURE__ */ new Set();
+  for (let i = 0; i < data.length; i += 4) {
+    if (data[i + 3] < 10) continue;
+    uniqueColors.add(`${data[i]},${data[i + 1]},${data[i + 2]}`);
+  }
+  return uniqueColors.size > 50;
+}
+function removeIsolatedPixels(data, width, height) {
+  const result = Buffer.from(data);
+  const offsets = [
+    [-1, -1],
+    [0, -1],
+    [1, -1],
+    [-1, 0],
+    [1, 0],
+    [-1, 1],
+    [0, 1],
+    [1, 1]
+  ];
+  for (let y = 1; y < height - 1; y++) {
+    for (let x = 1; x < width - 1; x++) {
+      const idx = (y * width + x) * 4;
+      if (result[idx + 3] < 10) continue;
+      let transparentNeighbors = 0;
+      for (const [dx, dy] of offsets) {
+        const neighborIdx = ((y + dy) * width + (x + dx)) * 4;
+        if (result[neighborIdx + 3] < 10) transparentNeighbors++;
+      }
+      if (transparentNeighbors >= 6) {
+        result[idx + 3] = 0;
+      }
+    }
+  }
+  return result;
+}
+function removeInteriorBackground(data, dominantEdgeColor, threshold) {
+  const result = Buffer.from(data);
+  for (let i = 0; i < result.length; i += 4) {
+    if (result[i + 3] < 10) continue;
+    const pixelColor = { r: result[i], g: result[i + 1], b: result[i + 2] };
+    if (colorDistance(dominantEdgeColor, pixelColor) < threshold) {
+      result[i + 3] = 0;
+    }
+  }
+  return result;
+}
+function removeBackground(data, width, height, colorRangeThreshold = COLOR_RANGE_THRESHOLD) {
+  if (hasTransparency(data)) {
+    return data;
+  }
+  const dominantEdgeColor = getDominantEdgeColor(data, width, height);
+  const isGradient = hasGradientColors(data);
+  const result = Buffer.from(data);
+  if (isGradient) {
+    for (let i = 0; i < result.length; i += 4) {
+      let alpha = result[i + 3];
+      if (alpha < 25.5) {
+        result[i + 3] = 0;
+        continue;
+      }
+      const pixelColor = { r: result[i], g: result[i + 1], b: result[i + 2] };
+      if (colorDistance(dominantEdgeColor, pixelColor) < 40) {
+        alpha = 0;
+      }
+      result[i + 3] = alpha;
+    }
+    const cleaned2 = removeInteriorBackground(result, dominantEdgeColor, 40);
+    return removeIsolatedPixels(cleaned2, width, height);
+  }
+  const colorRange = findColorRange(data, dominantEdgeColor);
+  for (let i = 0; i < result.length; i += 4) {
+    let alpha = result[i + 3];
+    if (alpha < 25.5) {
+      result[i + 3] = 0;
+      continue;
+    }
+    const pixelColor = { r: result[i], g: result[i + 1], b: result[i + 2] };
+    if (colorDistance(dominantEdgeColor, pixelColor) < 50) {
+      alpha = 0;
+    } else {
+      const colorRangeIndex = colorRange.findIndex((c) => colorDistance(c, pixelColor) < colorRangeThreshold);
+      if (colorRangeIndex === -1) {
+        alpha = 0;
+      } else {
+        alpha = Math.max(255 - 255 * colorRangeIndex * 0.35, 50);
+      }
+    }
+    result[i + 3] = alpha;
+  }
+  const cleaned = removeInteriorBackground(result, dominantEdgeColor, 50);
+  return removeIsolatedPixels(cleaned, width, height);
+}
+function findClosestColor(color, palette) {
+  let minDist = Number.POSITIVE_INFINITY;
+  let closestColor = palette[0];
+  for (const palColor of palette) {
+    const dist = colorDistance(color, { r: palColor[0], g: palColor[1], b: palColor[2] });
+    if (dist < minDist) {
+      minDist = dist;
+      closestColor = palColor;
+    }
+  }
+  return closestColor;
+}
+function applyQuantization(data, numColors) {
+  const pixels = [];
+  let hasWhitePixels = false;
+  for (let i = 0; i < data.length; i += 4) {
+    const r = data[i];
+    const g = data[i + 1];
+    const b = data[i + 2];
+    pixels.push([r, g, b]);
+    if (r > 240 && g > 240 && b > 240) hasWhitePixels = true;
+  }
+  const quantizer = quantize(pixels, numColors);
+  if (!quantizer) {
+    throw new Error("Failed to quantize image");
+  }
+  const palette = quantizer.palette();
+  if (hasWhitePixels) {
+    const hasWhiteInPalette = palette.some((c) => c[0] > 240 && c[1] > 240 && c[2] > 240);
+    if (!hasWhiteInPalette) {
+      let darkestIndex = 0;
+      let darkestLuminance = Number.POSITIVE_INFINITY;
+      palette.forEach((color, i) => {
+        const luminance = (0.299 * color[0] + 0.587 * color[1] + 0.114 * color[2]) / 255;
+        if (luminance < darkestLuminance) {
+          darkestLuminance = luminance;
+          darkestIndex = i;
+        }
+      });
+      palette[darkestIndex] = [255, 255, 255];
+    }
+  }
+  const quantizedData = Buffer.from(data);
+  for (let i = 0; i < data.length; i += 4) {
+    const originalColor = { r: data[i], g: data[i + 1], b: data[i + 2] };
+    const closest = findClosestColor(originalColor, palette);
+    quantizedData[i] = closest[0];
+    quantizedData[i + 1] = closest[1];
+    quantizedData[i + 2] = closest[2];
+  }
+  return quantizedData;
+}
+function getLuminance(color) {
+  const r = color.r / 255;
+  const g = color.g / 255;
+  const b = color.b / 255;
+  return 0.299 * r + 0.587 * g + 0.114 * b;
+}
+function getContrastRatio(color1, color2) {
+  const lum1 = getLuminance(color1);
+  const lum2 = getLuminance(color2);
+  const brightest = Math.max(lum1, lum2);
+  const darkest = Math.min(lum1, lum2);
+  return (brightest + 0.05) / (darkest + 0.05);
+}
+function getHueDistance(color1, color2) {
+  const [h1] = rgbToHsl(color1.r, color1.g, color1.b);
+  const [h2] = rgbToHsl(color2.r, color2.g, color2.b);
+  const hue1 = h1 * 360;
+  const hue2 = h2 * 360;
+  const diff = Math.abs(hue1 - hue2);
+  return Math.min(diff, 360 - diff);
+}
+function isHighlySaturated(color) {
+  const [, s] = rgbToHsl(color.r, color.g, color.b);
+  return s > 0.6;
+}
+function findColorRangeInternal(data, ignoredColor = null, customThreshold) {
+  const groups = [];
+  const threshold = customThreshold ?? COLOR_RANGE_THRESHOLD;
+  for (let i = 0; i < data.length; i += 4) {
+    if (data[i + 3] < 10) continue;
+    const color = { r: data[i], g: data[i + 1], b: data[i + 2] };
+    if (ignoredColor && colorDistance(color, ignoredColor) < threshold) continue;
+    let found = false;
+    for (const group of groups) {
+      const distance = colorDistance(group.color, color);
+      const contrastRatio = getContrastRatio(group.color, color);
+      let groupingThreshold = threshold;
+      if (contrastRatio > 3) groupingThreshold = Math.min(groupingThreshold, 8);
+      const hueDistance = getHueDistance(group.color, color);
+      if (hueDistance > 20) groupingThreshold = Math.min(groupingThreshold, 5);
+      if (isHighlySaturated(color) && isHighlySaturated(group.color)) {
+        groupingThreshold = Math.min(groupingThreshold, 10);
+      }
+      if (distance < groupingThreshold) {
+        group.count++;
+        found = true;
+        break;
+      }
+    }
+    if (!found) groups.push({ color, count: 1 });
+  }
+  const sorted = groups.sort((a, b) => b.count - a.count);
+  let filtered = sorted.filter((g) => g.count > sorted[0].count * 0.03).map((g) => g.color);
+  if (filtered.length < 2 && sorted.length >= 2) {
+    filtered = sorted.slice(0, 2).map((g) => g.color);
+  }
+  return filtered.slice(0, 6);
+}
+function findColorRange(data, ignoredColor = null) {
+  return findColorRangeInternal(data, ignoredColor);
+}
+function findColorRangeWithThreshold(data, threshold, ignoredColor = null) {
+  return findColorRangeInternal(data, ignoredColor, threshold);
+}
+function rgbToHsl(r, g, b) {
+  const rNorm = r / 255;
+  const gNorm = g / 255;
+  const bNorm = b / 255;
+  const max = Math.max(rNorm, gNorm, bNorm);
+  const min = Math.min(rNorm, gNorm, bNorm);
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case rNorm:
+        h = (gNorm - bNorm) / d + (gNorm < bNorm ? 6 : 0);
+        break;
+      case gNorm:
+        h = (bNorm - rNorm) / d + 2;
+        break;
+      case bNorm:
+        h = (rNorm - gNorm) / d + 4;
+        break;
+      default:
+        break;
+    }
+    h /= 6;
+  }
+  return [h, s, l];
+}
+function hslToRgb(h, s, l) {
+  let r;
+  let g;
+  let b;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      let tMod = t;
+      if (tMod < 0) tMod += 1;
+      if (tMod > 1) tMod -= 1;
+      if (tMod < 1 / 6) return p2 + (q2 - p2) * 6 * tMod;
+      if (tMod < 1 / 2) return q2;
+      if (tMod < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - tMod) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+function solidifyEdges(data, saturationBoost = 0.25) {
+  const result = Buffer.from(data);
+  for (let i = 0; i < result.length; i += 4) {
+    const alpha = result[i + 3];
+    if (alpha > 0 && alpha < 255) {
+      const r = result[i];
+      const g = result[i + 1];
+      const b = result[i + 2];
+      const hsl = rgbToHsl(r, g, b);
+      const rgb = hslToRgb(hsl[0], Math.min(1, hsl[1] + saturationBoost), hsl[2]);
+      result[i] = rgb[0];
+      result[i + 1] = rgb[1];
+      result[i + 2] = rgb[2];
+      result[i + 3] = 255;
+    }
+  }
+  return result;
+}
+
+// src/lib/image/image-processor.ts
+import sharp from "sharp";
+function hasGradient(data) {
+  const uniqueColors = /* @__PURE__ */ new Set();
+  for (let i = 0; i < data.length; i += 4) {
+    if (data[i + 3] < 10) continue;
+    uniqueColors.add(`${data[i]},${data[i + 1]},${data[i + 2]}`);
+  }
+  return uniqueColors.size > 50;
+}
+function perceivedLuminance(color) {
+  return (0.299 * color.r + 0.587 * color.g + 0.114 * color.b) / 255;
+}
+function createSvgRecolorer(target, palette) {
+  if (palette.length < 2) return () => target;
+  const luminances = palette.map(perceivedLuminance);
+  const min = Math.min(...luminances);
+  const max = Math.max(...luminances);
+  if (max - min < 0.05) return () => target;
+  const [h, s, targetLightness] = rgbToHsl(target.r, target.g, target.b);
+  const lightnessRange = 0.75;
+  const minLightness = targetLightness >= 0.5 ? Math.max(0, targetLightness - lightnessRange) : targetLightness;
+  const maxLightness = targetLightness >= 0.5 ? targetLightness : Math.min(1, targetLightness + lightnessRange);
+  return (source) => {
+    const sourcePosition = (perceivedLuminance(source) - min) / (max - min);
+    const nextLightness = minLightness + sourcePosition * (maxLightness - minLightness);
+    const [r, g, b] = hslToRgb(h, s, Math.max(0, Math.min(1, nextLightness)));
+    return { r, g, b };
+  };
+}
+async function processGradient(data, info) {
+  if (!hasGradient(data)) return { data, info };
+  const solidified = solidifyEdges(data, 0.1);
+  const blurred = await sharp(solidified, {
+    raw: { channels: 4, width: info.width, height: info.height }
+  }).png().blur(0.3).toBuffer();
+  const result = await sharp(blurred).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  return { data: result.data, info: result.info };
+}
+function isSvgBuffer(buffer) {
+  const head = buffer.subarray(0, Math.min(buffer.length, 512)).toString("utf8").trimStart();
+  return head.startsWith("<?xml") ? head.includes("<svg") : head.startsWith("<svg");
+}
+async function processInternal(inputBuffer, isSVG, options) {
+  const stages = [];
+  const metadata = await sharp(inputBuffer).metadata();
+  let alreadyTransparent = false;
+  if (metadata.hasAlpha) {
+    const { data: alphaData } = await sharp(inputBuffer).raw().toBuffer({ resolveWithObject: true });
+    alreadyTransparent = hasTransparency(alphaData, 0.05);
+  }
+  let { data: processedData, info } = await sharp(inputBuffer).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  if (options.color) {
+    stages.push("recolor");
+    processedData = applyQuantization(processedData, 8);
+    let dominantEdgeColor = null;
+    let colorRange = [];
+    if (isSVG) {
+      dominantEdgeColor = getDominantEdgeColor(processedData, info.width, info.height);
+      colorRange = findColorRangeWithThreshold(processedData, 5, null);
+    } else {
+      dominantEdgeColor = alreadyTransparent ? null : getDominantEdgeColor(processedData, info.width, info.height);
+      colorRange = findColorRange(processedData, dominantEdgeColor);
+    }
+    const isMultiFillSvg = isSVG && colorRange.length >= 2;
+    const recolorSvgFill = isMultiFillSvg ? createSvgRecolorer(options.color, colorRange) : null;
+    let didRemoveBackground = false;
+    for (let i = 0; i < processedData.length; i += 4) {
+      let alpha = processedData[i + 3];
+      if (alpha < 25.5) {
+        processedData[i + 3] = 0;
+        continue;
+      }
+      const pixelColor = { r: processedData[i], g: processedData[i + 1], b: processedData[i + 2] };
+      if (isSVG) {
+        const isLight = pixelColor.r > 240 && pixelColor.g > 240 && pixelColor.b > 240;
+        const isEdgeBackground = dominantEdgeColor ? colorDistance(dominantEdgeColor, pixelColor) < 5 : false;
+        if (isLight && (!isMultiFillSvg || isEdgeBackground)) {
+          alpha = 0;
+          didRemoveBackground = true;
+        } else {
+          const idx = colorRange.findIndex((c) => colorDistance(c, pixelColor) < 5);
+          if (idx === -1) {
+            alpha = 0;
+            didRemoveBackground = true;
+          } else if (!isMultiFillSvg) {
+            const levels = [255, 200, 150, 100, 80];
+            alpha = levels[idx] ?? 60;
+          }
+        }
+      } else if (!alreadyTransparent && dominantEdgeColor && colorDistance(dominantEdgeColor, pixelColor) < 25) {
+        alpha = 0;
+        didRemoveBackground = true;
+      } else {
+        const idx = colorRange.findIndex((c) => colorDistance(c, pixelColor) < COLOR_RANGE_THRESHOLD);
+        if (idx === -1) {
+          alpha = 0;
+          didRemoveBackground = true;
+        } else {
+          alpha = Math.max(255 - 255 * idx * 0.35, 50);
+        }
+      }
+      const recolored = recolorSvgFill ? recolorSvgFill(pixelColor) : options.color;
+      processedData[i] = recolored.r;
+      processedData[i + 1] = recolored.g;
+      processedData[i + 2] = recolored.b;
+      processedData[i + 3] = alpha;
+    }
+    if (didRemoveBackground && !alreadyTransparent) {
+      stages.push("solidify-edges");
+      const result = await processGradient(processedData, info);
+      processedData = result.data;
+      info = result.info;
+    }
+  } else if (options.removeBackground && !alreadyTransparent) {
+    stages.push("remove-bg");
+    processedData = removeBackground(processedData, info.width, info.height);
+    stages.push("solidify-edges");
+    const result = await processGradient(processedData, info);
+    processedData = result.data;
+    info = result.info;
+  }
+  let pipeline = sharp(processedData, {
+    raw: { channels: 4, width: info.width, height: info.height }
+  }).png();
+  if (options.shrinkToContent) {
+    stages.push("trim");
+    pipeline = pipeline.trim();
+  }
+  const outputBuffer = await pipeline.toBuffer();
+  return { buffer: outputBuffer, stages };
+}
+function applyResize(buffer, resize) {
+  const transparent = { r: 0, g: 0, b: 0, alpha: 0 };
+  if (resize.size) {
+    return sharp(buffer).resize(resize.size.width, resize.size.height, {
+      fit: resize.fit ?? "contain",
+      background: transparent
+    }).toBuffer();
+  }
+  return sharp(buffer).resize(resize.width ?? null, resize.height ?? null, { fit: "inside", withoutEnlargement: false }).toBuffer();
+}
+async function processImage(inputBuffer, options = {}) {
+  const stages = [];
+  const isSVG = isSvgBuffer(inputBuffer);
+  if (isSVG && !options.color && !options.removeBackground && !options.shrinkToContent) {
+    if (options.resize) {
+      stages.push("resize");
+      const resized = await applyResize(inputBuffer, options.resize);
+      const meta3 = await sharp(resized).metadata();
+      return {
+        buffer: resized,
+        format: "png",
+        width: meta3.width ?? 0,
+        height: meta3.height ?? 0,
+        stages
+      };
+    }
+    const meta2 = await sharp(inputBuffer).metadata();
+    return {
+      buffer: inputBuffer,
+      format: "svg",
+      width: meta2.width ?? 0,
+      height: meta2.height ?? 0,
+      stages
+    };
+  }
+  let workingBuffer = inputBuffer;
+  if (isSVG) {
+    stages.push("rasterize-svg");
+    workingBuffer = await sharp(inputBuffer).png({ compressionLevel: 0, force: true, palette: false, quality: 100 }).toBuffer();
+  }
+  const pass = await processInternal(workingBuffer, isSVG, options);
+  stages.push(...pass.stages);
+  let processed = pass.buffer;
+  if (options.resize) {
+    stages.push("resize");
+    processed = await applyResize(processed, options.resize);
+  }
+  const meta = await sharp(processed).metadata();
+  return {
+    buffer: processed,
+    format: "png",
+    width: meta.width ?? 0,
+    height: meta.height ?? 0,
+    stages
+  };
+}
+
+// src/commands/images/normalize.ts
+registerSchema({
+  command: "images.normalize",
+  description: "Normalize one or more local images: recolor, two-pass background removal, trim, and resize. Multi-fill SVG recolor preserves relative contrast. Declarative \u2014 describe the desired final state via flags; the pipeline runs the needed stages in order. Writes in-place by default. For upscaling, use 'baker images upscale <imageId>' after uploading.",
+  args: {
+    files: {
+      type: "string",
+      description: "Single path, glob (quote it), or comma-separated list. Commas are treated as separators \u2014 paths containing commas are not supported. Use 'logos/*.png', 'a.png,b.png', or 'logo.png'.",
+      required: true
+    },
+    color: {
+      type: "string",
+      description: "Recolor target as hex (e.g. '#FFFFFF', '#fff'). Omit to keep original colors.",
+      required: false
+    },
+    "remove-bg": {
+      type: "boolean",
+      description: "Two-pass background removal. Default true when --color is set, false otherwise. Idempotent on already-transparent input.",
+      required: false
+    },
+    "shrink-to-content": {
+      type: "boolean",
+      description: "Trim transparent borders after bg removal. Default true when --remove-bg is on.",
+      required: false
+    },
+    height: {
+      type: "number",
+      description: "Resize to N pixels tall, width auto (preserves aspect). Mutex with --size.",
+      required: false
+    },
+    width: {
+      type: "number",
+      description: "Resize to N pixels wide, height auto (preserves aspect). Mutex with --size.",
+      required: false
+    },
+    size: {
+      type: "string",
+      description: "Fit into a W\xD7H box. Format 'WxH' (e.g. '200x200'). Mutex with --height/--width.",
+      required: false
+    },
+    fit: {
+      type: "string",
+      description: "Used with --size: 'contain' (default, letterbox transparent) or 'cover' (crop to fill).",
+      required: false,
+      enum: ["contain", "cover"]
+    },
+    output: {
+      type: "string",
+      description: "Output path. Default: in-place. With multiple inputs, must be a directory.",
+      required: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Resolve inputs + pipeline without writing any files.",
+      required: false,
+      default: false
+    }
+  }
+});
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function parseSize(raw) {
+  const match = /^(\d+)x(\d+)$/i.exec(raw.trim());
+  if (!match || match.length < 3) {
+    throw new ValidationError(`Invalid --size value "${raw}". Expected WxH (e.g. 200x200).`);
+  }
+  const [, w, h] = match;
+  return { width: Number.parseInt(w ?? "", 10), height: Number.parseInt(h ?? "", 10) };
+}
+function parseResize(args) {
+  const hasSize = typeof args.size === "string" && args.size.length > 0;
+  const hasHeight = typeof args.height === "number";
+  const hasWidth = typeof args.width === "number";
+  if (hasSize && (hasHeight || hasWidth)) {
+    throw new ValidationError("--height/--width and --size are mutually exclusive");
+  }
+  if (args.fit !== void 0 && !hasSize) {
+    throw new ValidationError("--fit requires --size");
+  }
+  if (hasSize && typeof args.size === "string") {
+    return {
+      size: parseSize(args.size),
+      fit: args.fit ?? "contain"
+    };
+  }
+  if (hasHeight || hasWidth) {
+    return { width: args.width, height: args.height };
+  }
+  return void 0;
+}
+function parseColor(raw) {
+  if (typeof raw !== "string" || raw.length === 0) return void 0;
+  try {
+    return parseHex(raw);
+  } catch (err) {
+    throw new ValidationError(err instanceof Error ? err.message : "Invalid --color");
+  }
+}
+function buildOptions(args) {
+  const resize = parseResize(args);
+  const color = parseColor(args.color);
+  const removeBackground2 = typeof args["remove-bg"] === "boolean" ? args["remove-bg"] : color !== void 0;
+  const shrinkToContent = typeof args["shrink-to-content"] === "boolean" ? args["shrink-to-content"] : removeBackground2;
+  return {
+    options: { color, removeBackground: removeBackground2, shrinkToContent, resize },
+    outputArg: typeof args.output === "string" && args.output.length > 0 ? args.output : void 0,
+    dryRun: args["dry-run"] === true
+  };
+}
+function colorToHex(color) {
+  if (!color) return null;
+  return `#${[color.r, color.g, color.b].map((n) => n.toString(16).padStart(2, "0")).join("")}`;
+}
+async function processFile(inputPath, options, outputArg, multipleInputs) {
+  const inputBuffer = await readImageBuffer(inputPath);
+  const result = await processImage(inputBuffer, options);
+  const newExt = result.format === "png" ? ".png" : ".svg";
+  const outputPath = await resolveOutputPath(inputPath, outputArg, { multipleInputs, newExtension: newExt });
+  await atomicWrite(outputPath, result.buffer);
+  return {
+    input: inputPath,
+    output: outputPath,
+    format: result.format,
+    width: result.width,
+    height: result.height,
+    sizeBytes: result.buffer.length,
+    stages: result.stages
+  };
+}
+async function resolveInputs(spec) {
+  const all = await expandInputs(spec);
+  if (all.length === 0) {
+    throw new ValidationError(`No files matched "${spec}"`);
+  }
+  const remote = all.filter(isRemoteUrl);
+  if (remote.length > 0) {
+    throw new ValidationError(
+      "Remote URLs are not supported by 'normalize'. Download the file first or use a local path."
+    );
+  }
+  return all;
+}
+function emitDryRun(inputs, normalized) {
+  writeJson({
+    ok: true,
+    dryRun: true,
+    operation: "images.normalize",
+    params: {
+      inputs,
+      options: {
+        color: colorToHex(normalized.options.color),
+        removeBackground: normalized.options.removeBackground ?? false,
+        shrinkToContent: normalized.options.shrinkToContent ?? false,
+        resize: normalized.options.resize ?? null
+      },
+      outputArg: normalized.outputArg ?? null
+    }
+  });
+}
+function emitError(err) {
+  if (err instanceof ValidationError) {
+    writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: err.message } });
+  } else {
+    const message = err instanceof Error ? err.message : "Unexpected error";
+    writeJson({ ok: false, error: { code: "IMAGE_PROCESSING_ERROR", message } });
+  }
+  process.exit(1);
+}
+function coerceRawArgs(args) {
+  const num = (v) => {
+    if (typeof v === "number") return v;
+    if (typeof v === "string" && v.length > 0) {
+      const n = Number(v);
+      return Number.isFinite(n) ? n : void 0;
+    }
+    return void 0;
+  };
+  const str = (v) => typeof v === "string" ? v : void 0;
+  const bool = (v) => typeof v === "boolean" ? v : void 0;
+  return {
+    files: str(args.files),
+    color: str(args.color),
+    "remove-bg": bool(args["remove-bg"]),
+    "shrink-to-content": bool(args["shrink-to-content"]),
+    height: num(args.height),
+    width: num(args.width),
+    size: str(args.size),
+    fit: str(args.fit),
+    output: str(args.output),
+    "dry-run": bool(args["dry-run"])
+  };
+}
+var normalizeCommand = defineCommand({
+  meta: {
+    name: "normalize",
+    description: `Normalize logos / images: declarative recolor + bg removal + trim + resize. Operates on local files; writes in-place by default.
+
+Examples:
+  baker images normalize "logos/*.png" --color '#FFFFFF' --height 200
+  baker images normalize logo.png --remove-bg --shrink-to-content
+  baker images normalize "a.png,b.png" --size 200x200 --fit cover --output ./out`
+  },
+  args: {
+    files: {
+      type: "positional",
+      description: "Single path, glob (quote it), or comma-separated list",
+      required: false
+    },
+    color: { type: "string", description: "Recolor target as hex", required: false },
+    "remove-bg": { type: "boolean", description: "Two-pass background removal", required: false },
+    "shrink-to-content": { type: "boolean", description: "Trim transparent borders", required: false },
+    height: { type: "string", description: "Resize to N px tall, width auto", required: false },
+    width: { type: "string", description: "Resize to N px wide, height auto", required: false },
+    size: { type: "string", description: "Fit into a WxH box (e.g. 200x200)", required: false },
+    fit: { type: "string", description: "contain (default) or cover (with --size)", required: false },
+    output: { type: "string", description: "Output path or directory", required: false },
+    "dry-run": { type: "boolean", description: "Preview without writing", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const raw = coerceRawArgs(args);
+      if (!raw.files) {
+        throw new ValidationError("files argument is required");
+      }
+      const inputs = await resolveInputs(raw.files);
+      const normalized = buildOptions(raw);
+      if (inputs.length > 1 && normalized.outputArg && !await isDirectory(normalized.outputArg)) {
+        throw new ValidationError(
+          `--output must be an existing directory when processing multiple files (got "${normalized.outputArg}")`
+        );
+      }
+      if (normalized.dryRun) {
+        emitDryRun(inputs, normalized);
+        return;
+      }
+      const processed = [];
+      for (const inputPath of inputs) {
+        processed.push(await processFile(inputPath, normalized.options, normalized.outputArg, inputs.length > 1));
+      }
+      writeJson({ ok: true, data: { processed } });
+    } catch (err) {
+      emitError(err);
+    }
+  }
+});
+export {
+  normalizeCommand
+};
+//# sourceMappingURL=normalize-KXI3OOFS.js.map