@dooph-software/fluid-gradients 1.0.0

package/dist/cli.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { randomBytes } from "crypto";
+import { mkdirSync, realpathSync, writeFileSync } from "fs";
+import { dirname, extname, join } from "path";
+import { fileURLToPath } from "url";
+import { parseArgs } from "util";
+
+// src/render.ts
+import { createCanvas, ImageData } from "@napi-rs/canvas";
+import sharp from "sharp";
+import { createNoise2D } from "simplex-noise";
+
+// src/color.ts
+var ACHROMATIC_CHROMA = 0.01;
+var HUE_TRUST_CHROMA = 0.03;
+var VIVID_L_MIN = 50;
+var VIVID_L_MAX = 80;
+var VIVID_MAX_CHROMA = 0.2;
+var CHROMA_SEARCH_MAX = 0.4;
+var GAMUT_STEPS = 24;
+var toLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+var toGamma = (c) => c <= 31308e-7 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
+function hexToRgb(hex) {
+  return [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
+}
+function rgbToHex(rgb) {
+  return "#" + rgb.map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0")).join("");
+}
+function hexToOklab(hex) {
+  const [r, g, b] = hexToRgb(hex).map(toLinear);
+  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  ];
+}
+function oklabToSrgb([L, a, b]) {
+  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  return [
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  ].map(toGamma);
+}
+var inGamut = (rgb) => rgb.every((c) => c >= 0 && c <= 1);
+var atLch = (L, C, hue) => oklabToSrgb([L, C * Math.cos(hue), C * Math.sin(hue)]);
+function maxChroma(L, hue) {
+  let low = 0;
+  let high = CHROMA_SEARCH_MAX;
+  for (let step = 0; step < GAMUT_STEPS; step++) {
+    const mid = (low + high) / 2;
+    if (inGamut(atLch(L, mid, hue))) low = mid;
+    else high = mid;
+  }
+  return low;
+}
+function vividOpposite(a, b) {
+  const hue = Math.atan2(b, a) + Math.PI;
+  let bestL = VIVID_L_MIN / 100;
+  let bestC = -1;
+  for (let l = VIVID_L_MIN; l <= VIVID_L_MAX; l++) {
+    const chroma = maxChroma(l / 100, hue);
+    if (chroma > bestC) {
+      bestC = chroma;
+      bestL = l / 100;
+    }
+  }
+  return rgbToHex(atLch(bestL, Math.min(bestC, VIVID_MAX_CHROMA), hue));
+}
+function oppositeGray(L) {
+  return rgbToHex(atLch(L > 0.5 ? 0.25 : 0.85, 0, 0));
+}
+function paletteComplementColor(accent, ramp) {
+  const [L, a, b] = hexToOklab(accent);
+  if (Math.hypot(a, b) >= HUE_TRUST_CHROMA) return vividOpposite(a, b);
+  let sumA = 0;
+  let sumB = 0;
+  for (const color of ramp) {
+    const [, ca, cb] = hexToOklab(color);
+    sumA += ca;
+    sumB += cb;
+  }
+  const meanA = sumA / ramp.length;
+  const meanB = sumB / ramp.length;
+  return Math.hypot(meanA, meanB) < ACHROMATIC_CHROMA / 2 ? oppositeGray(L) : vividOpposite(meanA, meanB);
+}
+
+// src/random.ts
+function hashStringToInt(seed) {
+  let hash = 2166136261 >>> 0;
+  for (let i = 0; i < seed.length; i++) {
+    hash ^= seed.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function createSeededRandom(seedInt) {
+  let state = seedInt;
+  return function nextRandom() {
+    state |= 0;
+    state = state + 1831565813 | 0;
+    let mixed = Math.imul(state ^ state >>> 15, 1 | state);
+    mixed = mixed + Math.imul(mixed ^ mixed >>> 7, 61 | mixed) ^ mixed;
+    return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// src/palettes.ts
+var MIN_PALETTE_COLORS = 3;
+var MAX_PALETTE_COLORS = 5;
+var colorPalettes = [
+  // ── Warm: amber / cream / clay / terracotta (analogous) ──
+  { name: "amber-latte", colors: ["#faf4ea", "#f2d29b", "#e0a45c", "#b9722f"] },
+  { name: "terracotta-sand", colors: ["#f6ede1", "#e8c9a0", "#cf8f63", "#9c4e33"] },
+  { name: "peach-blush", colors: ["#fdf1ec", "#f8cbb6", "#ef9a8a", "#d76e73"] },
+  { name: "coral-cream", colors: ["#fbe9df", "#f5b79a", "#e8735a", "#c33f36"] },
+  { name: "honey-espresso", colors: ["#f7ecd9", "#e5b877", "#b9793f", "#5f3418"] },
+  { name: "apricot-plum", colors: ["#fdf0e6", "#f6c79a", "#e58b6f", "#7d4a6b"] },
+  { name: "golden-hour", colors: ["#fdf3e1", "#f7cf8a", "#e89a5a", "#9a4a3a"] },
+  { name: "vermilion-blush", colors: ["#fbe8e2", "#f7c6a8", "#e4562f", "#a82a1c"] },
+  { name: "ivory-gilt", colors: ["#fffdf7", "#f7ecd0", "#e0c47e", "#b08c3a"] },
+  { name: "rose-gold", colors: ["#fceee8", "#f2cdbd", "#dba18c", "#b3705c"] },
+  { name: "peony-glow", colors: ["#fdeef3", "#f9b3c8", "#f78a5c", "#f2a93f"] },
+  // ── Pink / violet / mauve ──
+  { name: "lavender-rose", colors: ["#f4eefb", "#d9c2ef", "#c98fb8", "#8a5fd0"] },
+  { name: "violet-mist", colors: ["#f1eefb", "#c9b8ef", "#8f7fe0", "#4a3d9c"] },
+  { name: "mauve-plum", colors: ["#f6f0f2", "#d8b8c6", "#a5738c", "#5f3a55"] },
+  { name: "periwinkle-blush", colors: ["#f0f0fb", "#c3c6f0", "#cf9fc6", "#6a5fd0"] },
+  { name: "orchid-frost", colors: ["#f6eff6", "#e0c2e0", "#b98fc4", "#7a5aa6", "#3f2f5c"] },
+  { name: "quartz-rose", colors: ["#faf1f1", "#ecc9cc", "#c99aa3", "#8a5f6a"] },
+  { name: "wisteria-sky", colors: ["#f2f0fb", "#cfc6ef", "#9fb2e6", "#4f6aa6"] },
+  { name: "zephyr-dawn", colors: ["#fdf3f5", "#f2d6e2", "#c6d6f2", "#7f9fd8"] },
+  { name: "candy-sky", colors: ["#f6e8ff", "#f7a3e8", "#9aa8f5", "#3fa0f5"] },
+  // ── Cool: blue / slate / sky (analogous) ──
+  { name: "sky-slate", colors: ["#eef4fb", "#bcd2ef", "#6f8fc4", "#2f3f66"] },
+  { name: "teal-fog", colors: ["#eef7f6", "#b6dcd8", "#5fa39c", "#234a49"] },
+  { name: "arctic-ink", colors: ["#f2f6f8", "#cddbe2", "#7f96a3", "#1c2630"] },
+  { name: "cloud-navy", colors: ["#f0f3f7", "#c6d1de", "#7488a3", "#1f2c44"] },
+  { name: "denim-clay", colors: ["#eef2f6", "#aebfd0", "#5f7794", "#b06a4e"] },
+  { name: "cobalt-ice", colors: ["#e8eeff", "#b9cdfb", "#2f4fd8", "#1836b8"] },
+  // ── Green: sage / moss / mint / olive (analogous) ──
+  { name: "sage-mist", colors: ["#f2f5ee", "#cdd8bd", "#8fa579", "#4a5c3a"] },
+  { name: "mint-sea", colors: ["#eef8f4", "#b6e2d2", "#5fb39c", "#1f5c4d"] },
+  { name: "olive-cream", colors: ["#f6f3e6", "#dbd09b", "#a39a5c", "#5f5a2f"] },
+  { name: "eucalyptus-fog", colors: ["#eff4f1", "#cbdcd2", "#94b3a6", "#4f6b60"] },
+  { name: "kelp-forest", colors: ["#eef3ea", "#a9c49a", "#4f7a5a", "#1f3a2f"] },
+  { name: "yuzu-mint", colors: ["#fbfbe6", "#eef29a", "#b3d98a", "#3f8f7a"] },
+  { name: "lime-lagoon", colors: ["#f8ffe8", "#c8f56a", "#6fe3d8", "#2fc6d8"] },
+  { name: "bliss-meadow", colors: ["#f4fbff", "#8ed0f2", "#6cb03a", "#2d6b22"] },
+  // ── Analogous + a single contrasting splash ──
+  { name: "periwinkle-gold", colors: ["#dfe6ff", "#a9b6f0", "#5b6bd6", "#e6c25a"] },
+  { name: "lilac-lemon", colors: ["#f3eefb", "#d3c2ef", "#9f8fd0", "#e6d25a"] },
+  { name: "blush-teal", colors: ["#fbeee9", "#f2c2b0", "#d78a8f", "#3f9c94"] },
+  { name: "sage-coral", colors: ["#f2f5ee", "#cdd8bd", "#8fa579", "#e0755a"] },
+  { name: "slate-amber", colors: ["#eef2f6", "#bcc9d8", "#5f7794", "#e0a24e"] },
+  { name: "ultramarine-sand", colors: ["#dfe8ff", "#e6c27a", "#4757dd", "#232a9c"] },
+  { name: "amber-tide", colors: ["#eef4f8", "#a9c8ef", "#f2b96b", "#df8a33"] },
+  // ── Colorful / multi-hue (rich & saturated, jewel tones) ──
+  { name: "sunset-rose", colors: ["#fce9d6", "#f6a95c", "#e8617a", "#8a3d7a"] },
+  { name: "berry-bloom", colors: ["#fbe9f2", "#e88fb8", "#c94f8f", "#7a2f6a"] },
+  { name: "jewel-peacock", colors: ["#e6f5f0", "#4fb3a6", "#1f7a99", "#243f8a"] },
+  { name: "iris-meadow", colors: ["#eaf5ec", "#7cc48f", "#3f8fb3", "#5f4fb0"] },
+  { name: "autumn-spice", colors: ["#f7ecd6", "#dba24f", "#b5522f", "#6e2f4a"] },
+  { name: "ultraviolet-sea", colors: ["#e9f0fb", "#6f9fe0", "#4a5fc4", "#6a3da6"] },
+  { name: "purple-rain", colors: ["#f1ebf7", "#b69ad6", "#6f3fa8", "#2a1740"] },
+  { name: "nectarine-fizz", colors: ["#fff1e6", "#ffc59a", "#ff8a5c", "#d9485f"] },
+  { name: "raspberry-cream", colors: ["#fdeef1", "#f4a9bd", "#d9537a", "#8a1f45"] },
+  { name: "pastel-confetti", colors: ["#ffffff", "#f9f3cf", "#cbbcf2", "#e8798f"] },
+  { name: "burgundy-velvet", colors: ["#f2dfe0", "#c98a91", "#8a2740", "#4a0f22"] },
+  { name: "indigo-beam", colors: ["#ffffff", "#a9b6f7", "#4a3fe0", "#2a1fb0"] },
+  { name: "crimson-ice", colors: ["#f2f7fc", "#f8d7e0", "#e0517f", "#a81050"] },
+  // ── Muted / dusty / earthy ──
+  { name: "fog-plum", colors: ["#f2f0f3", "#cfc6d2", "#9a8a9c", "#5f4a5c"] },
+  { name: "sand-sky", colors: ["#f4efe4", "#e0d3b8", "#a9bcc4", "#5f7f8c"] },
+  { name: "xanadu-sage", colors: ["#f1f4f1", "#c8d3c8", "#738678", "#36443a"] },
+  { name: "walnut-grain", colors: ["#e8d5b7", "#c49a6c", "#8a5a34", "#4a2c17"] },
+  // ── Dark-focused: ramps that start mid-tone instead of near-white, so the
+  // image reads dark overall with the lighter stop as a glow ──
+  { name: "onyx-gold", colors: ["#e8c877", "#b8862f", "#3a2f14", "#0b0b0d"] },
+  { name: "onyx-silver", colors: ["#d7dade", "#8b9199", "#3a3f45", "#0c0d0f"] },
+  { name: "graphite-royal", colors: ["#9fb0e8", "#3f56c4", "#2a2e38", "#101218"] },
+  { name: "onyx-ultraviolet", colors: ["#c9a6ff", "#7b3ff2", "#2a1450", "#08070d"] },
+  { name: "onyx-snow", colors: ["#ffffff", "#b0b0b0", "#4a4a4a", "#000000"] },
+  { name: "midnight-ember", colors: ["#f0a468", "#c23f1f", "#2a1410", "#0a0a0c"] },
+  { name: "slate-harbor", colors: ["#aeb7bd", "#6f7b84", "#3c454c", "#1a1f24"] },
+  // ── Neutral / mono ──
+  { name: "ivory-ink", colors: ["#f7f4ef", "#d8d2c8", "#8a8378", "#20201d"] },
+  { name: "paper-graphite", colors: ["#f4f4f5", "#cfcfd4", "#83838f", "#1c1c22"] },
+  { name: "bone-coffee", colors: ["#f5efe6", "#d9c9b3", "#9c8468", "#3a2c1e"] },
+  { name: "porcelain-greige", colors: ["#f6f3ef", "#ddd4c9", "#b0a596", "#6a5f52"] },
+  { name: "battleship-steel", colors: ["#e6e9e8", "#b9c0be", "#7d8683", "#3f4745"] },
+  { name: "gunmetal-fog", colors: ["#eceef1", "#c2c7cd", "#7b838d", "#343a42"] }
+];
+function paletteAccent(palette) {
+  const colors = palette.colors;
+  return colors[Math.floor(colors.length / 2)];
+}
+function paletteComplement(palette) {
+  return paletteComplementColor(paletteAccent(palette), palette.colors);
+}
+var HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+function validatePalette(palette) {
+  const label = `Palette "${palette?.name}"`;
+  if (typeof palette?.name !== "string" || palette.name.length === 0) {
+    throw new Error("Palette needs a non-empty name.");
+  }
+  const { colors } = palette;
+  if (!Array.isArray(colors) || colors.length < MIN_PALETTE_COLORS || colors.length > MAX_PALETTE_COLORS) {
+    throw new Error(
+      `${label} needs ${MIN_PALETTE_COLORS}\u2013${MAX_PALETTE_COLORS} colors. Got ${Array.isArray(colors) ? colors.length : typeof colors}.`
+    );
+  }
+  for (const color of colors) {
+    if (typeof color !== "string" || !HEX_COLOR.test(color)) {
+      throw new Error(`${label} has an invalid color "${color}". Use #rrggbb.`);
+    }
+  }
+}
+function validatePalettes(palettes) {
+  if (palettes.length === 0) throw new Error("At least one palette is required.");
+  const seen = /* @__PURE__ */ new Set();
+  for (const palette of palettes) {
+    validatePalette(palette);
+    if (seen.has(palette.name)) throw new Error(`Duplicate palette name "${palette.name}".`);
+    seen.add(palette.name);
+  }
+}
+function findPalette(name, palettes = colorPalettes) {
+  const palette = palettes.find((p) => p.name === name);
+  if (!palette) {
+    throw new Error(`Unknown palette "${name}". Valid: ${palettes.map((p) => p.name).join(", ")}`);
+  }
+  return palette;
+}
+function pickPalette(seed, palettes = colorPalettes) {
+  let best;
+  let bestScore = -1;
+  for (const palette of palettes) {
+    const score = createSeededRandom(hashStringToInt(`${seed}::palette::${palette.name}`))();
+    if (score > bestScore || score === bestScore && palette.name < best.name) {
+      best = palette;
+      bestScore = score;
+    }
+  }
+  if (!best) throw new Error("At least one palette is required.");
+  return best;
+}
+
+// src/render.ts
+var lookDescriptions = {
+  baseNoiseFrequency: "Lower values give broader, softer color regions.",
+  domainWarpStrength: "How much the color field swirls.",
+  fractalOctaveCount: "More octaves add finer detail.",
+  colorTransitionContrast: "Sharpness of the edges between colors.",
+  grainOpacity: "Strength of the film-grain overlay."
+};
+var defaultLook = {
+  baseNoiseFrequency: 0.3,
+  domainWarpStrength: 1,
+  fractalOctaveCount: 2,
+  colorTransitionContrast: 1.75,
+  grainOpacity: 0.09
+};
+var DEFAULT_WIDTH = 1200;
+var DEFAULT_HEIGHT = 1500;
+var DEFAULT_WEBP_QUALITY = 82;
+function hexToRgb2(hex) {
+  const packed = parseInt(hex.slice(1), 16);
+  return [packed >> 16 & 255, packed >> 8 & 255, packed & 255];
+}
+function sampleColorRamp(rgbStops, position) {
+  const clamped = Math.max(0, Math.min(1, position));
+  const scaled = clamped * (rgbStops.length - 1);
+  const lowerIndex = Math.min(rgbStops.length - 2, Math.floor(scaled));
+  const blend = scaled - lowerIndex;
+  const [lowR, lowG, lowB] = rgbStops[lowerIndex];
+  const [highR, highG, highB] = rgbStops[lowerIndex + 1];
+  return [
+    lowR + (highR - lowR) * blend,
+    lowG + (highG - lowG) * blend,
+    lowB + (highB - lowB) * blend
+  ];
+}
+var smoothStep = (edge) => edge * edge * (3 - 2 * edge);
+async function renderCanvas(options) {
+  const { seed, palette, width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT } = options;
+  const look = { ...defaultLook, ...options.look };
+  const random = createSeededRandom(hashStringToInt(seed));
+  const rgbStops = palette.colors.map(hexToRgb2);
+  const horizontalWarpNoise = createNoise2D(random);
+  const verticalWarpNoise = createNoise2D(random);
+  const colorFieldNoise = createNoise2D(random);
+  const sampleFractalNoise = (noise, sampleX, sampleY) => {
+    let total = 0;
+    let amplitude = 0.5;
+    let frequency = 1;
+    for (let octave = 0; octave < look.fractalOctaveCount; octave++) {
+      total += amplitude * noise(sampleX * frequency, sampleY * frequency);
+      amplitude *= 0.5;
+      frequency *= 2;
+    }
+    return total;
+  };
+  const canvas = createCanvas(width, height);
+  const context = canvas.getContext("2d");
+  const image = context.createImageData(width, height);
+  const pixels = image.data;
+  const aspectRatio = width / height;
+  for (let pixelY = 0; pixelY < height; pixelY++) {
+    for (let pixelX = 0; pixelX < width; pixelX++) {
+      const sampleX = pixelX / width * look.baseNoiseFrequency * aspectRatio;
+      const sampleY = pixelY / height * look.baseNoiseFrequency;
+      const horizontalWarpOffset = sampleFractalNoise(horizontalWarpNoise, sampleX, sampleY);
+      const verticalWarpOffset = sampleFractalNoise(verticalWarpNoise, sampleX + 5.2, sampleY + 1.3);
+      const rawFieldValue = sampleFractalNoise(
+        colorFieldNoise,
+        sampleX + look.domainWarpStrength * horizontalWarpOffset,
+        sampleY + look.domainWarpStrength * verticalWarpOffset
+      );
+      const normalizedValue = (rawFieldValue + 1) / 2;
+      const contrastedValue = smoothStep(
+        Math.max(0, Math.min(1, (normalizedValue - 0.5) * look.colorTransitionContrast + 0.5))
+      );
+      const [red, green, blue] = sampleColorRamp(rgbStops, contrastedValue);
+      const pixelIndex = (pixelY * width + pixelX) * 4;
+      pixels[pixelIndex] = red;
+      pixels[pixelIndex + 1] = green;
+      pixels[pixelIndex + 2] = blue;
+      pixels[pixelIndex + 3] = 255;
+    }
+  }
+  context.putImageData(image, 0, 0);
+  const grainPixels = new Uint8ClampedArray(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    const brightness = Math.floor(random() * 256);
+    grainPixels[i * 4] = brightness;
+    grainPixels[i * 4 + 1] = brightness;
+    grainPixels[i * 4 + 2] = brightness;
+    grainPixels[i * 4 + 3] = 255;
+  }
+  const grainCanvas = createCanvas(width, height);
+  grainCanvas.getContext("2d").putImageData(new ImageData(grainPixels, width, height), 0, 0);
+  applyOverlay(context, grainCanvas, look.grainOpacity);
+  return { canvas, palette, accent: paletteAccent(palette), complement: paletteComplement(palette) };
+}
+function applyOverlay(context, overlay, opacity) {
+  context.save();
+  context.globalAlpha = opacity;
+  context.globalCompositeOperation = "overlay";
+  context.drawImage(overlay, 0, 0);
+  context.restore();
+}
+async function generateImage(options) {
+  const { format = "webp", quality = DEFAULT_WEBP_QUALITY } = options;
+  const { canvas, palette, accent, complement } = await renderCanvas(options);
+  const pngBuffer = canvas.encodeSync("png");
+  let buffer = pngBuffer;
+  if (format === "webp") {
+    buffer = await sharp(pngBuffer).webp({ quality }).toBuffer();
+  }
+  return {
+    buffer,
+    format,
+    width: canvas.width,
+    height: canvas.height,
+    seed: options.seed,
+    palette,
+    accent,
+    complement
+  };
+}
+
+// src/flags.ts
+var positiveInteger = (flag) => (raw) => {
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`--${flag} must be a positive integer. Got: ${raw}`);
+  }
+  return value;
+};
+var finiteNumber = (flag) => (raw) => {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) throw new Error(`--${flag} must be a number. Got: ${raw}`);
+  return value;
+};
+var optionFlags = {
+  seed: {
+    flag: "seed",
+    placeholder: "<string>",
+    describe: "Seed string. Same seed \u2192 same image. Default: random.",
+    parse: (raw) => raw
+  },
+  palette: {
+    flag: "palette",
+    placeholder: "<name>",
+    describe: "Built-in palette name. Default: a deterministic pick from the seed.",
+    parse: (raw) => raw
+  },
+  width: {
+    flag: "width",
+    placeholder: "<px>",
+    describe: `Output width. Default ${DEFAULT_WIDTH}.`,
+    parse: positiveInteger("width")
+  },
+  height: {
+    flag: "height",
+    placeholder: "<px>",
+    describe: `Output height. Default ${DEFAULT_HEIGHT}.`,
+    parse: positiveInteger("height")
+  },
+  quality: {
+    flag: "quality",
+    placeholder: "<1-100>",
+    describe: `WebP quality. Default ${DEFAULT_WEBP_QUALITY}.`,
+    parse: positiveInteger("quality")
+  }
+};
+var lookFlags = {
+  baseNoiseFrequency: {
+    flag: "base-noise-frequency",
+    placeholder: "<n>",
+    describe: `${lookDescriptions.baseNoiseFrequency} Default ${defaultLook.baseNoiseFrequency}.`,
+    parse: finiteNumber("base-noise-frequency")
+  },
+  domainWarpStrength: {
+    flag: "domain-warp-strength",
+    placeholder: "<n>",
+    describe: `${lookDescriptions.domainWarpStrength} Default ${defaultLook.domainWarpStrength}.`,
+    parse: finiteNumber("domain-warp-strength")
+  },
+  fractalOctaveCount: {
+    flag: "fractal-octave-count",
+    placeholder: "<n>",
+    describe: `${lookDescriptions.fractalOctaveCount} Default ${defaultLook.fractalOctaveCount}.`,
+    parse: positiveInteger("fractal-octave-count")
+  },
+  colorTransitionContrast: {
+    flag: "color-transition-contrast",
+    placeholder: "<n>",
+    describe: `${lookDescriptions.colorTransitionContrast} Default ${defaultLook.colorTransitionContrast}.`,
+    parse: finiteNumber("color-transition-contrast")
+  },
+  grainOpacity: {
+    flag: "grain-opacity",
+    placeholder: "<0-1>",
+    describe: `${lookDescriptions.grainOpacity} Default ${defaultLook.grainOpacity}.`,
+    parse: finiteNumber("grain-opacity")
+  }
+};
+var cliOnlyFlags = [
+  {
+    flag: "out",
+    placeholder: "<path>",
+    describe: "Output file, .webp or .png. Default: output/<palette>-<seed>.webp"
+  },
+  { flag: "json", placeholder: "", describe: "Print result metadata as JSON." },
+  { flag: "list-palettes", placeholder: "", describe: "Print built-in palette names and exit." },
+  { flag: "help", placeholder: "", describe: "Show this help (-h)." }
+];
+
+// src/create.ts
+function createMeshGradients(options) {
+  const { palettes, width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT } = options;
+  validatePalettes(palettes);
+  validateDimension("width", width);
+  validateDimension("height", height);
+  const resolve = (seed, palette) => {
+    if (palette === void 0) return pickPalette(seed, palettes);
+    if (typeof palette === "string") return findPalette(palette, palettes);
+    validatePalette(palette);
+    return palette;
+  };
+  const resolveSize = (size) => {
+    const resolved = { width: size.width ?? width, height: size.height ?? height };
+    validateDimension("width", resolved.width);
+    validateDimension("height", resolved.height);
+    return resolved;
+  };
+  return {
+    palettes,
+    findPalette: (name) => findPalette(name, palettes),
+    pickPalette: (seed) => pickPalette(seed, palettes),
+    // async so an invalid palette rejects like every other render error.
+    render: async (renderOptions) => renderCanvas({
+      ...renderOptions,
+      ...resolveSize(renderOptions),
+      palette: resolve(renderOptions.seed, renderOptions.palette)
+    }),
+    generate: async (generateOptions) => generateImage({
+      ...generateOptions,
+      ...resolveSize(generateOptions),
+      palette: resolve(generateOptions.seed, generateOptions.palette)
+    })
+  };
+}
+function validateDimension(label, value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${label} must be a positive integer. Got ${value}.`);
+  }
+}
+
+// src/index.ts
+var builtIn = createMeshGradients({ palettes: colorPalettes });
+var generateMeshGradient = builtIn.generate;
+var renderMeshGradient = builtIn.render;
+
+// src/cli.ts
+var allFlags = [...Object.values(optionFlags), ...Object.values(lookFlags)];
+var helpText = (() => {
+  const width = Math.max(
+    ...[...allFlags, ...cliOnlyFlags].map((f) => `--${f.flag} ${f.placeholder}`.trimEnd().length)
+  );
+  const line = (f) => `  ${`--${f.flag} ${f.placeholder}`.trimEnd().padEnd(width)}  ${f.describe}`;
+  return `Usage: fluid-gradient [options]
+
+Every flag is optional. With none, writes one WebP with a random seed and a
+palette picked from that seed.
+
+Options:
+${allFlags.map(line).join("\n")}
+
+Output & info:
+${cliOnlyFlags.map(line).join("\n")}
+`;
+})();
+var parseOptions = {
+  ...Object.fromEntries(allFlags.map((f) => [f.flag, { type: "string" }])),
+  out: { type: "string" },
+  json: { type: "boolean" },
+  "list-palettes": { type: "boolean" },
+  help: { type: "boolean", short: "h" }
+};
+async function runCli(argv) {
+  const values = parseArgs({ args: argv, options: parseOptions }).values;
+  const raw = (flag) => values[flag];
+  if (values.help) {
+    console.log(helpText);
+    return;
+  }
+  if (values["list-palettes"]) {
+    for (const palette2 of colorPalettes) {
+      console.log(`${palette2.name}  ${palette2.colors.join(" ")}`);
+    }
+    return;
+  }
+  const read = (key) => {
+    const spec = optionFlags[key];
+    const value = raw(spec.flag);
+    return value === void 0 ? void 0 : spec.parse(value);
+  };
+  const look = {};
+  for (const [key, spec] of Object.entries(lookFlags)) {
+    const value = raw(spec.flag);
+    if (value !== void 0) look[key] = spec.parse(value);
+  }
+  const seed = read("seed") ?? randomBytes(4).toString("hex");
+  const paletteName = read("palette");
+  const palette = paletteName === void 0 ? pickPalette(seed) : findPalette(paletteName);
+  const out = raw("out") ?? join("output", `${palette.name}-${seed}.webp`);
+  const extension = extname(out).toLowerCase();
+  if (extension !== ".webp" && extension !== ".png") {
+    throw new Error(`--out must end in .webp or .png. Got: ${out}`);
+  }
+  const result = await generateMeshGradient({
+    seed,
+    palette,
+    width: read("width"),
+    height: read("height"),
+    quality: read("quality"),
+    format: extension === ".png" ? "png" : "webp",
+    ...Object.keys(look).length > 0 ? { look } : {}
+  });
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, result.buffer);
+  if (values.json) {
+    const { buffer, palette: used, ...meta } = result;
+    console.log(
+      JSON.stringify({ ...meta, palette: used.name, out, bytes: buffer.length })
+    );
+  } else {
+    console.log(`\u2713 ${out} (${(result.buffer.length / 1024).toFixed(2)} KB)`);
+    console.log(`  seed: ${result.seed}`);
+    console.log(`  palette: ${result.palette.name} (accent: ${result.accent}, complement: ${result.complement})`);
+  }
+}
+var invokedPath = process.argv[1];
+if (invokedPath && realpathSync(invokedPath) === fileURLToPath(import.meta.url)) {
+  runCli(process.argv.slice(2)).catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}
+export {
+  helpText,
+  runCli
+};
+//# sourceMappingURL=cli.js.map