@koda-sl/baker-cli 0.467.0 → 0.469.0

package/dist/normalize-P5Q3F7FU.js

@@ -1,806 +0,0 @@
-import {
-  atomicWrite,
-  expandInputs,
-  isDirectory,
-  isRemoteUrl,
-  readImageBuffer,
-  resolveOutputPath
-} from "./chunk-6HPIWZHS.js";
-import "./chunk-CECS3DHZ.js";
-import "./chunk-QXDEZKAR.js";
-import {
-  registerSchema,
-  writeJson
-} from "./chunk-4DM6OAQ6.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-P5Q3F7FU.js.map