@qrdx/cli 0.0.4 → 0.0.6

package/dist/index.js

@@ -1,39 +1,220 @@
 #!/usr/bin/env node
-'use strict';
+import { readFileSync, mkdirSync, writeFileSync, createReadStream } from 'fs';
+import { join, resolve, extname } from 'path';
+import { readFile } from 'fs/promises';
+import { BODY_PATTERN, CORNER_EYE_PATTERNS, CORNER_EYE_DOT_PATTERNS, getTemplateIds, FRAME_STYLES, DEFAULT_FRAME_TEXT, FRAME_TEXT_MAX_LENGTH, DEFAULT_MARGIN, getFrameDimensions, colorConfigSchema, errorLevelSchema, QRCodeSVG, svgToEPS } from 'qrdx';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import * as readline from 'readline';
+import * as p from '@clack/prompts';
 
-var fs = require('fs');
-var path = require('path');
-var p = require('@clack/prompts');
-var qrdx = require('qrdx');
-var react = require('react');
-var server = require('react-dom/server');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
+var CsvParser = class {
+  row = [];
+  field = "";
+  quoted = false;
+  /** A quote seen inside a quoted field: the end, or the first of "". */
+  quote = false;
+  started = false;
+  first = true;
+  /** Rows completed by this chunk. */
+  push(chunk) {
+    const rows = [];
+    let text2 = chunk;
+    if (this.first) {
+      this.first = false;
+      if (text2.charCodeAt(0) === 65279) text2 = text2.slice(1);
+    }
+    for (const char of text2) {
+      if (this.quoted) {
+        if (this.quote) {
+          this.quote = false;
+          if (char === '"') {
+            this.field += '"';
+            continue;
+          }
+          this.quoted = false;
+        } else if (char === '"') {
+          this.quote = true;
+          continue;
+        } else {
+          this.field += char;
+          continue;
+        }
       }
-    });
+      if (char === '"' && this.field === "" && !this.started) {
+        this.quoted = true;
+        this.started = true;
+      } else if (char === ",") {
+        this.endField();
+      } else if (char === "\n") {
+        this.endRow(rows);
+      } else if (char === "\r") ; else {
+        this.field += char;
+        this.started = true;
+      }
+    }
+    return rows;
+  }
+  /** The last row, when the file doesn't end with a line break. */
+  end() {
+    const rows = [];
+    if (this.quote) {
+      this.quote = false;
+      this.quoted = false;
+    }
+    if (this.started || this.row.length > 0) this.endRow(rows);
+    return rows;
+  }
+  endField() {
+    this.row.push(this.field);
+    this.field = "";
+    this.started = false;
+  }
+  endRow(rows) {
+    this.endField();
+    if (this.row.some((cell) => cell.trim() !== "")) rows.push(this.row);
+    this.row = [];
+  }
+};
+async function* readCsvRows(path) {
+  const parser = new CsvParser();
+  const stream = createReadStream(path, { encoding: "utf8" });
+  for await (const chunk of stream) {
+    yield* parser.push(chunk);
   }
-  n.default = e;
-  return Object.freeze(n);
+  yield* parser.end();
 }
-
-var p__namespace = /*#__PURE__*/_interopNamespace(p);
-
+var VALUE_COLUMN = /^(value|url|link|data|content|text|qr|qr ?code)$/i;
+var FILENAME_COLUMN = /^(file ?name|name|label|id|title|sku)$/i;
+function guessValueColumn(columns) {
+  const index = columns.findIndex((name) => VALUE_COLUMN.test(name.trim()));
+  return index === -1 ? 0 : index;
+}
+function guessFilenameColumn(columns, valueColumn) {
+  return columns.findIndex(
+    (name, i) => i !== valueColumn && FILENAME_COLUMN.test(name.trim())
+  );
+}
+function resolveColumn(spec, columns, flag) {
+  if (/^\d+$/.test(spec)) {
+    const index = Number(spec) - 1;
+    if (index >= 0 && index < columns.length) return index;
+  } else {
+    const index = columns.findIndex(
+      (name) => name.trim().toLowerCase() === spec.trim().toLowerCase()
+    );
+    if (index >= 0) return index;
+  }
+  throw new Error(
+    `${flag} "${spec}" isn't a column of this file. Columns: ${columns.map((name, i) => `${i + 1}. ${name}`).join(", ")}`
+  );
+}
+function sanitizeFilename(raw) {
+  return raw.normalize("NFKC").replace(/[\u0000-\u001f\u007f<>:"/\\|?*]+/g, "-").replace(/\s+/g, " ").trim().replace(/^[.\-\s]+|[.\s]+$/g, "").slice(0, 100);
+}
+function createFilenameAllocator() {
+  const used = /* @__PURE__ */ new Set();
+  const next = /* @__PURE__ */ new Map();
+  return (base, extension) => {
+    const key = base.toLowerCase();
+    let n = next.get(key) ?? 1;
+    let candidate = n === 1 ? `${base}.${extension}` : `${base}-${n}.${extension}`;
+    while (used.has(candidate.toLowerCase())) {
+      n++;
+      candidate = `${base}-${n}.${extension}`;
+    }
+    next.set(key, n + 1);
+    used.add(candidate.toLowerCase());
+    return candidate;
+  };
+}
+function csvCell(value) {
+  const text2 = String(value);
+  return /[",\n\r]/.test(text2) ? `"${text2.replaceAll('"', '""')}"` : text2;
+}
+var OUTPUT_FORMATS = [
+  "svg",
+  "png",
+  "webp",
+  "eps"
+];
+var encodeRaster = (image, format) => format === "webp" ? image.webp({ lossless: true }) : image.png();
 function buildSVGString(props) {
-  const element = react.createElement(qrdx.QRCodeSVG, {
+  const element = createElement(QRCodeSVG, {
     size: props.size ?? 512,
     ...props
   });
-  return server.renderToStaticMarkup(element);
+  return renderToStaticMarkup(element);
+}
+async function loadLogo(src) {
+  if (src.startsWith("data:")) {
+    const comma = src.indexOf(",");
+    const payload = src.slice(comma + 1);
+    return src.slice(0, comma).endsWith(";base64") ? Buffer.from(payload, "base64") : Buffer.from(decodeURIComponent(payload));
+  }
+  if (/^https?:\/\//i.test(src)) {
+    const res = await fetch(src);
+    if (!res.ok) {
+      throw new Error(
+        `Could not download logo (${res.status} ${res.statusText}): ${src}`
+      );
+    }
+    return Buffer.from(await res.arrayBuffer());
+  }
+  return readFile(src);
+}
+async function logoAsEmbeddableDataUrl(src) {
+  const bytes = await loadLogo(src);
+  if (bytes[0] === 137 && bytes[1] === 80) {
+    return `data:image/png;base64,${bytes.toString("base64")}`;
+  }
+  if (bytes[0] === 255 && bytes[1] === 216) {
+    return `data:image/jpeg;base64,${bytes.toString("base64")}`;
+  }
+  try {
+    const mod = await import('sharp');
+    const sharp = mod.default;
+    const png = await sharp(bytes).png().toBuffer();
+    return `data:image/png;base64,${png.toString("base64")}`;
+  } catch {
+    return null;
+  }
+}
+async function buildEPSString(props) {
+  const src = props.imageSettings?.src;
+  let epsProps = props;
+  if (src && props.imageSettings) {
+    const dataUrl = await logoAsEmbeddableDataUrl(src);
+    if (dataUrl) {
+      epsProps = {
+        ...props,
+        imageSettings: { ...props.imageSettings, src: dataUrl }
+      };
+    } else {
+      console.warn(
+        "The logo could not be converted for EPS (PNG or JPEG work best), so it was left out."
+      );
+    }
+  }
+  return await svgToEPS(buildSVGString(epsProps));
+}
+async function findLogoBox(sharp, svgString) {
+  const imageTag = svgString.match(/<image\b[^>]*?(?:\/>|><\/image>)/)?.[0];
+  if (!imageTag) {
+    return null;
+  }
+  const markerTag = imageTag.replace(/^<image\b/, '<rect class="qrdx-logo-box"').replace(/\shref="[^"]*"/, "").replace(/(?:\/>|><\/image>)$/, ' fill="#000"/>');
+  const markerSvg = svgString.replace(imageTag, markerTag).replace(
+    /<svg\b[^>]*>/,
+    (open) => `${open}<style>*{visibility:hidden}.qrdx-logo-box{visibility:visible}</style>`
+  );
+  const { info } = await sharp(Buffer.from(markerSvg, "utf-8")).png().trim().toBuffer({ resolveWithObject: true });
+  return {
+    left: -(info.trimOffsetLeft ?? 0),
+    top: -(info.trimOffsetTop ?? 0),
+    width: info.width,
+    height: info.height
+  };
 }
 async function saveOutput(options) {
   const { outputPath, format, ...qrProps } = options;
@@ -41,93 +222,259 @@ async function saveOutput(options) {
   if (format === "svg") {
     const svgContent = `<?xml version="1.0" encoding="UTF-8"?>
 ${svgString}`;
-    fs.writeFileSync(outputPath, svgContent, "utf-8");
+    writeFileSync(outputPath, svgContent, "utf-8");
     return;
   }
-  const sharp = (await import('sharp')).default;
+  if (format === "eps") {
+    writeFileSync(outputPath, await buildEPSString(qrProps), "utf-8");
+    return;
+  }
+  let sharp;
+  try {
+    const mod = await import('sharp');
+    sharp = mod.default;
+  } catch {
+    throw new Error(
+      `${format === "webp" ? "WebP" : "PNG"} output needs the sharp package (native binaries). It is optional and may not have installed; use SVG or reinstall: https://sharp.pixelplumbing.com/install`
+    );
+  }
   const svgBuffer = Buffer.from(svgString, "utf-8");
   const size = qrProps.size ?? 512;
-  await sharp(svgBuffer).resize(size, size).png().toFile(outputPath);
+  const { width, height } = getFrameDimensions(size, qrProps.frame);
+  const qrImage = sharp(svgBuffer).resize(
+    Math.round(width),
+    Math.round(height)
+  );
+  const logoSrc = qrProps.imageSettings?.src;
+  const box = logoSrc ? await findLogoBox(sharp, svgString) : null;
+  if (!(logoSrc && box)) {
+    await encodeRaster(qrImage, format).toFile(outputPath);
+    return;
+  }
+  const logo = await sharp(await loadLogo(logoSrc)).resize(box.width, box.height, { fit: "fill" }).png().toBuffer();
+  const composited = sharp(await qrImage.png().toBuffer()).composite([
+    { input: logo, left: box.left, top: box.top }
+  ]);
+  await encodeRaster(composited, format).toFile(outputPath);
 }
-
-// src/commands/generate.ts
 var RESET = "\x1B[0m";
 var TEXT = "\x1B[38;5;145m";
 var GREEN = "\x1B[38;5;114m";
 var DIM = "\x1B[38;5;102m";
+var HEX_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var MAX_PNG_SIZE = 1e4;
 function parseColorFlag(value) {
   const trimmed = value.trim();
-  if (trimmed.startsWith("{")) {
+  if (!trimmed.startsWith("{")) {
+    return trimmed;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error(`Invalid gradient JSON: ${trimmed}`);
+  }
+  const result = colorConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid gradient: ${trimmed}
+Expected {"type":"linear"|"radial"|"angular","stops":[{"color":"#hex","offset":0-100}, ...]} with at least 2 stops.`
+    );
+  }
+  return result.data;
+}
+function assertOneOf(flag, value, allowed) {
+  if (value !== void 0 && !allowed.includes(value)) {
+    throw new Error(
+      `Invalid ${flag} "${value}". Expected one of: ${allowed.join(", ")}`
+    );
+  }
+}
+function parseIntegerFlag(flag, value, min) {
+  const parsed = Number(value);
+  if (!(value && Number.isInteger(parsed) && parsed >= min)) {
+    throw new Error(
+      `Invalid ${flag} "${value ?? ""}". Expected a whole number \u2265 ${min}.`
+    );
+  }
+  return parsed;
+}
+function assertHexColor(flag, value) {
+  if (value !== void 0 && !HEX_COLOR.test(value)) {
+    throw new Error(
+      `Invalid ${flag} "${value}". Expected a hex color like #000000.`
+    );
+  }
+}
+function requireValue(flag, value) {
+  if (value === void 0 || /^--?[a-z]/i.test(value)) {
+    throw new Error(`${flag} needs a value. Run qrdx --help to see options.`);
+  }
+  return value;
+}
+function frameFromFlags(flags) {
+  const style = flags.frame ?? (flags.frameText !== void 0 || flags.frameColor !== void 0 || flags.frameTextColor !== void 0 ? "banner-bottom" : void 0);
+  if (!style || style === "none") {
+    return void 0;
+  }
+  return {
+    style,
+    ...flags.frameText !== void 0 && { text: flags.frameText },
+    ...flags.frameColor && { color: flags.frameColor },
+    ...flags.frameTextColor && { textColor: flags.frameTextColor }
+  };
+}
+function validateFlags(flags) {
+  assertOneOf("--level", flags.level, errorLevelSchema.options);
+  assertOneOf("--body", flags.body, BODY_PATTERN);
+  assertOneOf("--eye", flags.eye, CORNER_EYE_PATTERNS);
+  assertOneOf("--dot", flags.dot, CORNER_EYE_DOT_PATTERNS);
+  assertOneOf(
+    "--template",
+    flags.template,
+    getTemplateIds().filter((id) => id !== "default")
+  );
+  assertOneOf("--frame", flags.frame, FRAME_STYLES);
+  if (flags.frameText !== void 0 && flags.frameText.length > FRAME_TEXT_MAX_LENGTH) {
+    throw new Error(
+      `Invalid --frame-text "${flags.frameText}". Use ${FRAME_TEXT_MAX_LENGTH} characters or fewer.`
+    );
+  }
+  assertHexColor("--frame-color", flags.frameColor);
+  assertHexColor("--frame-text-color", flags.frameTextColor);
+  assertOneOf("--format", flags.format, OUTPUT_FORMATS);
+  if (flags.output !== void 0) {
+    const ext = extname(flags.output).toLowerCase();
+    if (!["", ".svg", ".png", ".webp", ".eps"].includes(ext)) {
+      throw new Error(
+        `Unsupported output format "${ext}". Use a .svg, .png, .webp or .eps file name.`
+      );
+    }
+    if (ext && flags.format && ext !== `.${flags.format}`) {
+      throw new Error(
+        `--format ${flags.format} does not match the output file "${flags.output}". Use a .${flags.format} file name or drop --format.`
+      );
+    }
+  }
+  const raster = [
+    extname(flags.output ?? "").toLowerCase().slice(1),
+    flags.format
+  ].find((format) => format === "png" || format === "webp");
+  if (raster && flags.size !== void 0 && flags.size > MAX_PNG_SIZE) {
+    throw new Error(
+      `Invalid --size "${flags.size}". ${raster === "webp" ? "WebP" : "PNG"} output is at most ${MAX_PNG_SIZE} px; use .svg or .eps for larger prints.`
+    );
+  }
+}
+var isCI = process.env.CI === "true";
+var canUseClack = process.stdin.isTTY === true && process.stdout.isTTY === true && !isCI;
+function readLineFromTTY(question) {
+  if (process.platform === "win32") {
+    return Promise.resolve(void 0);
+  }
+  return new Promise((resolve2) => {
+    let stream;
     try {
-      return JSON.parse(trimmed);
+      stream = createReadStream("/dev/tty", { flags: "r" });
     } catch {
+      resolve2(void 0);
+      return;
     }
-  }
-  return trimmed;
+    const rl = readline.createInterface({
+      input: stream,
+      output: process.stdout
+    });
+    const finish = (answer) => {
+      rl.close();
+      stream.destroy();
+      resolve2(answer);
+    };
+    stream.once("error", () => finish(void 0));
+    rl.question(question, (answer) => finish(answer));
+  });
 }
-var IS_TTY = Boolean(process.stdin.isTTY);
 function parseFlags(args) {
   const flags = {};
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
     if (!arg.startsWith("-")) {
-      if (!flags.value) {
-        flags.value = arg;
+      if (flags.value !== void 0) {
+        throw new Error(
+          `Unexpected argument "${arg}". Quote text with spaces: qrdx generate "${flags.value} ${arg}"`
+        );
       }
+      flags.value = arg;
       i++;
       continue;
     }
     const next = args[i + 1];
     switch (arg) {
+      case "-h":
+      case "--help":
+        flags.help = true;
+        i++;
+        break;
+      case "-v":
+      case "--version":
+        flags.version = true;
+        i++;
+        break;
       case "-o":
       case "--output":
+        if (!next || /^--?[a-z]/i.test(next)) {
+          throw new Error(`${arg} needs a file path, e.g. ${arg} qr.svg`);
+        }
         flags.output = next;
         i += 2;
         break;
+      case "--format":
+        flags.format = requireValue(arg, next).toLowerCase();
+        i += 2;
+        break;
       case "-l":
       case "--level":
-        flags.level = next;
+        flags.level = requireValue(arg, next).toUpperCase();
         i += 2;
         break;
       case "--body":
-        flags.body = next;
+        flags.body = requireValue(arg, next);
         i += 2;
         break;
       case "--eye":
-        flags.eye = next;
+        flags.eye = requireValue(arg, next);
         i += 2;
         break;
       case "--dot":
-        flags.dot = next;
+        flags.dot = requireValue(arg, next);
         i += 2;
         break;
       case "--fg":
-        flags.fg = next ? parseColorFlag(next) : void 0;
+        flags.fg = parseColorFlag(requireValue(arg, next));
         i += 2;
         break;
       case "--bg":
-        flags.bg = next ? parseColorFlag(next) : void 0;
+        flags.bg = parseColorFlag(requireValue(arg, next));
         i += 2;
         break;
       case "--eye-color":
-        flags.eyeColor = next ? parseColorFlag(next) : void 0;
+        flags.eyeColor = parseColorFlag(requireValue(arg, next));
         i += 2;
         break;
       case "--dot-color":
-        flags.dotColor = next ? parseColorFlag(next) : void 0;
+        flags.dotColor = parseColorFlag(requireValue(arg, next));
         i += 2;
         break;
       case "--logo":
-        flags.logo = next;
+        flags.logo = requireValue(arg, next);
         i += 2;
         break;
       case "--margin":
-        flags.margin = next ? Number.parseInt(next, 10) : qrdx.DEFAULT_MARGIN;
+        flags.margin = parseIntegerFlag(arg, next, 0);
         i += 2;
         break;
       case "--size":
-        flags.size = next ? Number.parseInt(next, 10) : 512;
+        flags.size = parseIntegerFlag(arg, next, 1);
         i += 2;
         break;
       case "--no-logo":
@@ -135,77 +482,193 @@ function parseFlags(args) {
         i++;
         break;
       case "--template":
-        flags.template = next;
+        flags.template = requireValue(arg, next);
+        i += 2;
+        break;
+      case "--frame":
+        flags.frame = requireValue(arg, next);
+        i += 2;
+        break;
+      case "--frame-text":
+        flags.frameText = requireValue(arg, next);
+        i += 2;
+        break;
+      case "--frame-color":
+        flags.frameColor = requireValue(arg, next);
+        i += 2;
+        break;
+      case "--frame-text-color":
+        flags.frameTextColor = requireValue(arg, next);
         i += 2;
         break;
       default:
-        i++;
+        throw new Error(
+          `Unknown option "${arg}". Run qrdx --help to see all options.`
+        );
     }
   }
+  if (!(flags.help || flags.version)) validateFlags(flags);
   return flags;
 }
+function buildQrProps(value, settings) {
+  const { size, logo, template, frame, eyeColor, dotColor } = settings;
+  return {
+    value,
+    level: settings.level,
+    bodyPattern: settings.body,
+    cornerEyePattern: settings.eye,
+    cornerEyeDotPattern: settings.dot,
+    fgColor: settings.fg,
+    bgColor: settings.bg,
+    ...eyeColor ? { eyeColor } : {},
+    ...dotColor ? { dotColor } : {},
+    margin: settings.margin,
+    size,
+    ...template ? { templateId: template } : {},
+    ...frame ? { frame } : {},
+    ...logo ? {
+      imageSettings: {
+        src: logo,
+        height: Math.round(size * 0.2),
+        width: Math.round(size * 0.2),
+        excavate: true
+      }
+    } : {}
+  };
+}
+function styleFromArgs(args) {
+  const flags = parseFlags(args);
+  return {
+    flags,
+    settings: {
+      level: flags.level ?? "Q",
+      body: flags.body ?? "square",
+      eye: flags.eye ?? "square",
+      dot: flags.dot ?? "square",
+      fg: flags.fg ?? "#000000",
+      bg: flags.bg ?? "#ffffff",
+      eyeColor: flags.eyeColor,
+      dotColor: flags.dotColor,
+      margin: flags.margin ?? DEFAULT_MARGIN,
+      size: flags.size ?? 512,
+      template: flags.template,
+      frame: frameFromFlags(flags),
+      logo: flags.logo
+    }
+  };
+}
 function isCancel2(value) {
-  return p__namespace.isCancel(value);
+  return p.isCancel(value);
 }
 function handleCancel() {
-  p__namespace.cancel("Cancelled.");
+  p.cancel("Cancelled.");
+  console.error(
+    `${DIM}Tip:${RESET} ${TEXT}qrdx generate "https://\u2026" -o qr.svg${RESET} \u2014 local dev: ${TEXT}pnpm qrdx -- generate \u2026${RESET}`
+  );
   process.exit(0);
 }
-function inferFormat(outputPath) {
-  const ext = path.extname(outputPath).toLowerCase();
+function inferFormat(outputPath, format) {
+  const ext = extname(outputPath).toLowerCase();
   if (ext === ".png") {
     return "png";
   }
-  return "svg";
+  if (ext === ".webp") {
+    return "webp";
+  }
+  if (ext === ".eps") {
+    return "eps";
+  }
+  return ext === ".svg" ? "svg" : format ?? "svg";
 }
-async function runGenerate(args) {
+async function runGenerate(args, meta) {
   const flags = parseFlags(args);
-  const nonInteractive = !IS_TTY;
+  if (meta && flags.help) return meta.help();
+  if (meta && flags.version) return meta.version();
+  meta?.start?.();
+  const nonInteractive = !canUseClack;
   const hasAdvancedFlags = Boolean(
-    flags.body || flags.eye || flags.dot || flags.fg || flags.bg || flags.eyeColor || flags.dotColor || flags.logo || flags.level || flags.margin !== void 0 || flags.template
+    flags.body || flags.eye || flags.dot || flags.fg || flags.bg || flags.eyeColor || flags.dotColor || flags.logo || flags.level || flags.margin !== void 0 || flags.template || frameFromFlags(flags)
   );
-  p__namespace.intro(`${TEXT}qrdx${RESET} ${DIM}\u2014 QR Code Generator${RESET}`);
+  p.intro(`${TEXT}qrdx${RESET} ${DIM}\u2014 QR Code Generator${RESET}`);
+  if (canUseClack) {
+    process.stdin.resume();
+  }
   let value = flags.value;
   if (!value) {
-    if (nonInteractive) {
-      p__namespace.log.error("No data provided. Pass a URL or text as an argument.");
-      process.exit(1);
-    }
-    const res = await p__namespace.text({
-      message: "URL or text to encode",
-      placeholder: "https://qrdx.dev",
-      validate(v) {
-        if (!v.trim()) {
-          return "Please enter a value to encode.";
+    if (canUseClack) {
+      const promptStart = performance.now();
+      const res = await p.text({
+        message: "URL or text to encode",
+        placeholder: "https://qrdx.dev",
+        validate(v) {
+          if (!v?.trim()) {
+            return "Please enter a value to encode.";
+          }
         }
+      });
+      if (isCancel2(res)) {
+        const instant = performance.now() - promptStart < 120 && process.platform !== "win32" && process.stdout.isTTY && !isCI;
+        if (instant) {
+          const line = await readLineFromTTY(
+            `${TEXT}URL or text to encode${RESET} ${DIM}(e.g. https://qrdx.dev)${RESET}: `
+          );
+          if (line?.trim()) {
+            value = line.trim();
+          } else {
+            handleCancel();
+          }
+        } else {
+          handleCancel();
+        }
+      } else {
+        value = res;
       }
-    });
-    if (isCancel2(res)) {
-      handleCancel();
+    } else if (process.stdout.isTTY && !isCI) {
+      const line = await readLineFromTTY(
+        `${TEXT}URL or text to encode${RESET} ${DIM}(e.g. https://qrdx.dev)${RESET}: `
+      );
+      if (line?.trim()) {
+        value = line.trim();
+      }
+    }
+    if (!value) {
+      console.error(
+        'No data to encode. Example: npx @qrdx/cli generate "https://example.com" -o qr.svg'
+      );
+      process.exit(1);
     }
-    value = res;
   }
   let outputPath = flags.output;
   const size = flags.size ?? 512;
-  if (!(outputPath || nonInteractive)) {
-    const pathRes = await p__namespace.text({
-      message: "Output file (.svg or .png)",
-      placeholder: "qr.svg",
-      defaultValue: "qr.svg",
-      validate(v) {
-        if (!v.trim()) {
-          return "Please enter an output path.";
+  const defaultOutput = `qr.${flags.format ?? "svg"}`;
+  if (!outputPath) {
+    if (canUseClack) {
+      const pathRes = await p.text({
+        message: "Output file (.svg, .png, .webp or .eps)",
+        placeholder: defaultOutput,
+        defaultValue: defaultOutput,
+        validate(v) {
+          if (!v?.trim()) {
+            return "Please enter an output path.";
+          }
         }
+      });
+      if (isCancel2(pathRes)) {
+        handleCancel();
       }
-    });
-    if (isCancel2(pathRes)) {
-      handleCancel();
+      outputPath = pathRes || defaultOutput;
+    } else if (process.stdout.isTTY && !isCI) {
+      const pathAns = await readLineFromTTY(
+        `Output file ${DIM}(.svg, .png, .webp or .eps, Enter = ${defaultOutput})${RESET}: `
+      );
+      outputPath = pathAns?.trim() || defaultOutput;
+    } else {
+      outputPath = defaultOutput;
     }
-    outputPath = pathRes || "qr.svg";
   }
   let wantAdvanced = hasAdvancedFlags;
   if (!(hasAdvancedFlags || nonInteractive)) {
-    const res = await p__namespace.confirm({
+    const res = await p.confirm({
       message: "Advanced customizations?",
       initialValue: false
     });
@@ -223,11 +686,12 @@ async function runGenerate(args) {
   let eyeColor = flags.eyeColor;
   let dotColor = flags.dotColor;
   let logo = flags.logo;
-  let margin = flags.margin ?? qrdx.DEFAULT_MARGIN;
+  let margin = flags.margin ?? DEFAULT_MARGIN;
   let template = flags.template;
+  let frame = frameFromFlags(flags);
   if (wantAdvanced && !nonInteractive) {
     if (!flags.level) {
-      const res = await p__namespace.select({
+      const res = await p.select({
         message: "Error correction level",
         options: [
           {
@@ -247,9 +711,9 @@ async function runGenerate(args) {
       level = res;
     }
     if (!flags.body) {
-      const res = await p__namespace.select({
+      const res = await p.select({
         message: "Body dot pattern",
-        options: qrdx.BODY_PATTERN.map((b) => ({ value: b, label: b })),
+        options: BODY_PATTERN.map((b) => ({ value: b, label: b })),
         initialValue: "square"
       });
       if (isCancel2(res)) {
@@ -258,9 +722,9 @@ async function runGenerate(args) {
       body = res;
     }
     if (!flags.eye) {
-      const res = await p__namespace.select({
+      const res = await p.select({
         message: "Corner eye pattern",
-        options: qrdx.CORNER_EYE_PATTERNS.map((e) => ({ value: e, label: e })),
+        options: CORNER_EYE_PATTERNS.map((e) => ({ value: e, label: e })),
         initialValue: "square"
       });
       if (isCancel2(res)) {
@@ -269,9 +733,9 @@ async function runGenerate(args) {
       eye = res;
     }
     if (!flags.dot) {
-      const res = await p__namespace.select({
+      const res = await p.select({
         message: "Corner dot pattern",
-        options: qrdx.CORNER_EYE_DOT_PATTERNS.map((d) => ({ value: d, label: d })),
+        options: CORNER_EYE_DOT_PATTERNS.map((d) => ({ value: d, label: d })),
         initialValue: "square"
       });
       if (isCancel2(res)) {
@@ -280,13 +744,13 @@ async function runGenerate(args) {
       dot = res;
     }
     if (!flags.fg) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: `Foreground color ${DIM}(hex or JSON gradient)${RESET}`,
         placeholder: "#000000",
         defaultValue: "#000000",
         validate(v) {
           if (!v) {
-            return void 0;
+            return;
           }
           if (v.trim().startsWith("{")) {
             try {
@@ -294,7 +758,7 @@ async function runGenerate(args) {
             } catch {
               return "Enter a valid hex color or JSON gradient object";
             }
-            return void 0;
+            return;
           }
           if (!/^#[0-9a-fA-F]{3,8}$/.test(v)) {
             return "Enter a valid hex color (e.g. #000000) or JSON gradient";
@@ -307,13 +771,13 @@ async function runGenerate(args) {
       fg = parseColorFlag(res || "#000000");
     }
     if (!flags.bg) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: `Background color ${DIM}(hex or JSON gradient)${RESET}`,
         placeholder: "#ffffff",
         defaultValue: "#ffffff",
         validate(v) {
           if (!v) {
-            return void 0;
+            return;
           }
           if (v.trim().startsWith("{")) {
             try {
@@ -321,7 +785,7 @@ async function runGenerate(args) {
             } catch {
               return "Enter a valid hex color or JSON gradient object";
             }
-            return void 0;
+            return;
           }
           if (!/^#[0-9a-fA-F]{3,8}$/.test(v)) {
             return "Enter a valid hex color (e.g. #ffffff) or JSON gradient";
@@ -334,12 +798,12 @@ async function runGenerate(args) {
       bg = parseColorFlag(res || "#ffffff");
     }
     if (eyeColor === void 0) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: `Corner eye color ${DIM}(leave blank to match foreground)${RESET}`,
         placeholder: "leave blank",
         validate(v) {
           if (!v) {
-            return void 0;
+            return;
           }
           if (v.trim().startsWith("{")) {
             try {
@@ -347,7 +811,7 @@ async function runGenerate(args) {
             } catch {
               return "Enter a valid hex color or JSON gradient object";
             }
-            return void 0;
+            return;
           }
           if (!/^#[0-9a-fA-F]{3,8}$/.test(v)) {
             return "Enter a valid hex color or leave blank";
@@ -361,12 +825,12 @@ async function runGenerate(args) {
       eyeColor = eyeVal ? parseColorFlag(eyeVal) : void 0;
     }
     if (dotColor === void 0) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: `Corner dot color ${DIM}(leave blank to match foreground)${RESET}`,
         placeholder: "leave blank",
         validate(v) {
           if (!v) {
-            return void 0;
+            return;
           }
           if (v.trim().startsWith("{")) {
             try {
@@ -374,7 +838,7 @@ async function runGenerate(args) {
             } catch {
               return "Enter a valid hex color or JSON gradient object";
             }
-            return void 0;
+            return;
           }
           if (!/^#[0-9a-fA-F]{3,8}$/.test(v)) {
             return "Enter a valid hex color or leave blank";
@@ -388,8 +852,8 @@ async function runGenerate(args) {
       dotColor = dotVal ? parseColorFlag(dotVal) : void 0;
     }
     if (!flags.template) {
-      const templateIds = qrdx.getTemplateIds();
-      const res = await p__namespace.select({
+      const templateIds = getTemplateIds();
+      const res = await p.select({
         message: `Template ${DIM}(decorative wrapper around the QR code)${RESET}`,
         options: [
           { value: "", label: "none" },
@@ -402,8 +866,37 @@ async function runGenerate(args) {
       }
       template = res || void 0;
     }
+    if (flags.frame === void 0 && !frame) {
+      const res = await p.select({
+        message: `Frame ${DIM}(call-to-action label around the code)${RESET}`,
+        options: FRAME_STYLES.map((style) => ({ value: style, label: style })),
+        initialValue: "none"
+      });
+      if (isCancel2(res)) {
+        handleCancel();
+      }
+      if (res !== "none") {
+        const text2 = await p.text({
+          message: `Frame text ${DIM}(up to ${FRAME_TEXT_MAX_LENGTH} characters)${RESET}`,
+          placeholder: DEFAULT_FRAME_TEXT,
+          defaultValue: DEFAULT_FRAME_TEXT,
+          validate(v) {
+            if (v && v.length > FRAME_TEXT_MAX_LENGTH) {
+              return `Use ${FRAME_TEXT_MAX_LENGTH} characters or fewer`;
+            }
+          }
+        });
+        if (isCancel2(text2)) {
+          handleCancel();
+        }
+        frame = {
+          style: res,
+          text: text2 || DEFAULT_FRAME_TEXT
+        };
+      }
+    }
     if (logo === void 0 && !flags.noLogo) {
-      const addLogo = await p__namespace.confirm({
+      const addLogo = await p.confirm({
         message: "Add a logo to the center?",
         initialValue: false
       });
@@ -411,16 +904,14 @@ async function runGenerate(args) {
         handleCancel();
       }
       if (addLogo) {
-        const res = await p__namespace.text({
+        const res = await p.text({
           message: "Logo URL",
           placeholder: "https://qrdx.dev/logo.png",
           validate(v) {
-            if (!v.trim()) {
+            if (!v?.trim()) {
               return "Please enter a URL for the logo.";
             }
-            try {
-              new URL(v);
-            } catch {
+            if (!URL.canParse(v)) {
               return "Please enter a valid URL.";
             }
           }
@@ -432,10 +923,10 @@ async function runGenerate(args) {
       }
     }
     if (flags.margin === void 0) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: "Quiet zone margin (modules)",
-        placeholder: String(qrdx.DEFAULT_MARGIN),
-        defaultValue: String(qrdx.DEFAULT_MARGIN),
+        placeholder: String(DEFAULT_MARGIN),
+        defaultValue: String(DEFAULT_MARGIN),
         validate(v) {
           if (v && Number.isNaN(Number.parseInt(v, 10))) {
             return "Enter a number";
@@ -448,57 +939,247 @@ async function runGenerate(args) {
       if (isCancel2(res)) {
         handleCancel();
       }
-      margin = Number.parseInt(res || String(qrdx.DEFAULT_MARGIN), 10);
+      margin = Number.parseInt(res || String(DEFAULT_MARGIN), 10);
     }
   }
-  const spinner2 = p__namespace.spinner();
+  const spinner2 = p.spinner();
   spinner2.start("Generating QR code...");
   try {
-    const qrProps = {
-      value,
+    const qrProps = buildQrProps(value, {
       level,
-      bodyPattern: body,
-      cornerEyePattern: eye,
-      cornerEyeDotPattern: dot,
-      fgColor: fg,
-      bgColor: bg,
-      ...eyeColor ? { eyeColor } : {},
-      ...dotColor ? { dotColor } : {},
+      body,
+      eye,
+      dot,
+      fg,
+      bg,
+      eyeColor,
+      dotColor,
       margin,
       size,
-      ...template ? { templateId: template } : {},
-      ...logo ? {
-        imageSettings: {
-          src: logo,
-          height: Math.round(size * 0.2),
-          width: Math.round(size * 0.2),
-          excavate: true
-        }
-      } : {}
-    };
+      template,
+      frame,
+      logo
+    });
     if (outputPath) {
-      const format = inferFormat(outputPath);
+      const format = inferFormat(outputPath, flags.format);
       await saveOutput({ ...qrProps, outputPath, format });
+      const dimensions = getFrameDimensions(size, frame);
       spinner2.stop(
-        `${GREEN}\u2714${RESET}  Saved to ${TEXT}${outputPath}${RESET} ${DIM}(${size}\xD7${size})${RESET}`
+        `${GREEN}\u2714${RESET}  Saved to ${TEXT}${outputPath}${RESET} ${DIM}(${Math.round(dimensions.width)}\xD7${Math.round(dimensions.height)})${RESET}`
       );
     } else {
       spinner2.stop("QR code ready");
     }
   } catch (err) {
-    spinner2.stop("Failed to generate QR code");
+    spinner2.error("Failed to generate QR code");
     const msg = err instanceof Error ? err.message : String(err);
-    p__namespace.log.error(msg);
+    p.log.error(msg);
     process.exit(1);
   }
-  p__namespace.outro(`${DIM}Done!${RESET}`);
+  p.outro(`${DIM}Done!${RESET}`);
 }
 
-// src/index.ts
+// src/commands/batch.ts
 var RESET2 = "\x1B[0m";
-var BOLD = "\x1B[1m";
-var DIM2 = "\x1B[38;5;102m";
 var TEXT2 = "\x1B[38;5;145m";
+var GREEN2 = "\x1B[38;5;114m";
+var DIM2 = "\x1B[38;5;102m";
+var BATCH_FLAGS = /* @__PURE__ */ new Set([
+  "-o",
+  "--out",
+  "--output",
+  "--value-column",
+  "--name-column",
+  "--jobs"
+]);
+function parseBatchArgs(args) {
+  const options = { out: "qr-codes", header: true, style: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+    } else if (arg === "-v" || arg === "--version") {
+      options.version = true;
+    } else if (arg === "--no-header") {
+      options.header = false;
+    } else if (BATCH_FLAGS.has(arg)) {
+      if (next === void 0 || /^--?[a-z]/i.test(next)) {
+        throw new Error(`${arg} needs a value. Run qrdx batch --help.`);
+      }
+      i++;
+      if (arg === "--value-column") options.valueColumn = next;
+      else if (arg === "--name-column") options.nameColumn = next;
+      else if (arg === "--jobs") {
+        const jobs = Number(next);
+        if (!(Number.isInteger(jobs) && jobs >= 1 && jobs <= 64)) {
+          throw new Error(
+            `Invalid --jobs "${next}". Use a number from 1 to 64.`
+          );
+        }
+        options.jobs = jobs;
+      } else options.out = next;
+    } else if (!arg.startsWith("-") && options.file === void 0) {
+      options.file = arg;
+    } else {
+      options.style.push(arg);
+      if (next !== void 0 && !/^--?[a-z]/i.test(next) && !isSwitch(arg)) {
+        options.style.push(next);
+        i++;
+      }
+    }
+  }
+  return options;
+}
+var isSwitch = (arg) => arg === "--no-logo";
+function readableError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /too long|data too big|overflow/i.test(message) ? "Too much data for one QR code" : message || "Could not generate";
+}
+async function logoDataUrl(src) {
+  if (src.startsWith("data:")) return src;
+  let bytes;
+  let type = "image/png";
+  if (/^https?:\/\//i.test(src)) {
+    const response = await fetch(src);
+    if (!response.ok) {
+      throw new Error(`Could not download logo (${response.status}): ${src}`);
+    }
+    type = response.headers.get("content-type")?.split(";")[0] ?? type;
+    bytes = Buffer.from(await response.arrayBuffer());
+  } else {
+    bytes = readFileSync(src);
+    if (/\.svg$/i.test(src)) type = "image/svg+xml";
+    else if (/\.jpe?g$/i.test(src)) type = "image/jpeg";
+    else if (/\.webp$/i.test(src)) type = "image/webp";
+  }
+  return `data:${type};base64,${bytes.toString("base64")}`;
+}
+async function runBatch(args, meta) {
+  const options = parseBatchArgs(args);
+  if (options.help) return meta.help();
+  if (options.version) return meta.version();
+  if (!options.file) {
+    throw new Error(
+      "Give a CSV file: qrdx batch codes.csv -o qr-codes (run qrdx batch --help)."
+    );
+  }
+  const { flags, settings } = styleFromArgs(options.style);
+  if (flags.value !== void 0) {
+    throw new Error(
+      `Unexpected argument "${flags.value}". qrdx batch takes one CSV file.`
+    );
+  }
+  const format = flags.format ?? "svg";
+  if (settings.logo) settings.logo = await logoDataUrl(settings.logo);
+  const out = resolve(options.out);
+  mkdirSync(out, { recursive: true });
+  const jobs = options.jobs ?? (format === "svg" ? 4 : 8);
+  const allocate = createFilenameAllocator();
+  const failures = [];
+  const running = /* @__PURE__ */ new Set();
+  let columns = options.header ? null : [];
+  let valueColumn = 0;
+  let nameColumn = -1;
+  let line = 0;
+  let saved = 0;
+  let index = 0;
+  const started = performance.now();
+  const tty = process.stderr.isTTY === true;
+  let lastReport = 0;
+  const report = (force = false) => {
+    const now = performance.now();
+    if (!force && now - lastReport < (tty ? 100 : 5e3)) return;
+    lastReport = now;
+    const text2 = `${index.toLocaleString("en-US")} rows \xB7 ${saved.toLocaleString("en-US")} saved${failures.length > 0 ? ` \xB7 ${failures.length.toLocaleString("en-US")} skipped` : ""}`;
+    process.stderr.write(tty ? `\r${DIM2}${text2}${RESET2}\x1B[K` : `${text2}
+`);
+  };
+  const render = (value, file, row) => {
+    const task = saveOutput({
+      ...buildQrProps(value, settings),
+      outputPath: join(out, file),
+      format
+    }).then(() => {
+      saved++;
+    }).catch((error) => {
+      failures.push({ row, value, error: readableError(error) });
+    }).finally(() => {
+      running.delete(task);
+      report();
+    });
+    running.add(task);
+  };
+  for await (const row of readCsvRows(options.file)) {
+    line++;
+    if (columns === null) {
+      columns = row.map((name, i) => name.trim() || `Column ${i + 1}`);
+      valueColumn = options.valueColumn ? resolveColumn(options.valueColumn, columns, "--value-column") : guessValueColumn(columns);
+      nameColumn = options.nameColumn ? resolveColumn(options.nameColumn, columns, "--name-column") : guessFilenameColumn(columns, valueColumn);
+      continue;
+    }
+    if (line === 1 && !options.header) {
+      const width = row.length;
+      const numbered = Array.from({ length: width }, (_, i) => String(i + 1));
+      if (options.valueColumn) {
+        valueColumn = resolveColumn(
+          options.valueColumn,
+          numbered,
+          "--value-column"
+        );
+      }
+      if (options.nameColumn) {
+        nameColumn = resolveColumn(
+          options.nameColumn,
+          numbered,
+          "--name-column"
+        );
+      }
+    }
+    index++;
+    const value = row[valueColumn]?.trim() ?? "";
+    if (!value) {
+      failures.push({ row: line, value, error: "Empty value" });
+      report();
+      continue;
+    }
+    const base = sanitizeFilename(nameColumn >= 0 ? row[nameColumn] ?? "" : "") || `qr-${String(index).padStart(5, "0")}`;
+    render(value, allocate(base, format), line);
+    if (running.size >= jobs) await Promise.race(running);
+  }
+  await Promise.all(running);
+  report(true);
+  if (tty) process.stderr.write("\n");
+  if (failures.length > 0) {
+    failures.sort((a, b) => a.row - b.row);
+    writeFileSync(
+      join(out, "errors.csv"),
+      `${["row,value,error", ...failures.map((f) => [f.row, f.value, f.error].map(csvCell).join(","))].join("\n")}
+`,
+      "utf-8"
+    );
+  }
+  const seconds = ((performance.now() - started) / 1e3).toFixed(1);
+  if (saved === 0) {
+    throw new Error(
+      index === 0 ? "The CSV has no rows with codes." : `No codes could be made. See ${join(out, "errors.csv")}.`
+    );
+  }
+  console.log(
+    `${GREEN2}\u2714${RESET2}  Saved ${saved.toLocaleString("en-US")} ${format.toUpperCase()} codes to ${TEXT2}${out}${RESET2} ${DIM2}in ${seconds} s${RESET2}`
+  );
+  if (failures.length > 0) {
+    console.log(
+      `   ${failures.length.toLocaleString("en-US")} rows skipped: ${TEXT2}${join(out, "errors.csv")}${RESET2}`
+    );
+  }
+}
+
+// src/index.ts
+var RESET3 = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM3 = "\x1B[38;5;102m";
+var TEXT3 = "\x1B[38;5;145m";
 var GRAYS = [
   "\x1B[38;5;250m",
   "\x1B[38;5;248m",
@@ -517,8 +1198,8 @@ var LOGO_LINES = [
 ];
 function getVersion() {
   try {
-    const pkgPath = path.join(__dirname, "..", "package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = join(import.meta.dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.1";
@@ -528,84 +1209,116 @@ var VERSION = getVersion();
 function showLogo() {
   console.log();
   LOGO_LINES.forEach((line, i) => {
-    console.log(`${GRAYS[i] ?? GRAYS[5]}${line}${RESET2}`);
+    console.log(`${GRAYS[i] ?? GRAYS[5]}${line}${RESET3}`);
   });
 }
 function showBanner() {
   showLogo();
   console.log();
-  console.log(`${DIM2}QR code generator for developers${RESET2}`);
+  console.log(`${DIM3}QR code generator for developers${RESET3}`);
   console.log();
   console.log(
-    `  ${DIM2}$${RESET2} ${TEXT2}qrdx generate${RESET2}                   ${DIM2}Generate a QR code interactively${RESET2}`
+    `  ${DIM3}$${RESET3} ${TEXT3}qrdx generate${RESET3}                   ${DIM3}Generate a QR code interactively${RESET3}`
   );
   console.log(
-    `  ${DIM2}$${RESET2} ${TEXT2}qrdx generate${RESET2} ${DIM2}<url>${RESET2}            ${DIM2}Generate from URL${RESET2}`
+    `  ${DIM3}$${RESET3} ${TEXT3}qrdx generate${RESET3} ${DIM3}<url>${RESET3}            ${DIM3}Generate from URL${RESET3}`
+  );
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT3}qrdx batch${RESET3} ${DIM3}<file.csv>${RESET3}         ${DIM3}A code for every row of a CSV${RESET3}`
   );
   console.log();
   console.log(
-    `  ${DIM2}$${RESET2} ${TEXT2}qrdx --help${RESET2}                     ${DIM2}Show all commands and options${RESET2}`
+    `  ${DIM3}$${RESET3} ${TEXT3}qrdx --help${RESET3}                     ${DIM3}Show all commands and options${RESET3}`
   );
   console.log(
-    `  ${DIM2}$${RESET2} ${TEXT2}qrdx --version${RESET2}                  ${DIM2}Show version${RESET2}`
+    `  ${DIM3}$${RESET3} ${TEXT3}qrdx --version${RESET3}                  ${DIM3}Show version${RESET3}`
   );
   console.log();
-  console.log(`  ${DIM2}try:${RESET2} npx @qrdx/cli generate "https://qrdx.dev"`);
+  console.log(`  ${DIM3}try:${RESET3} npx @qrdx/cli generate "https://qrdx.dev"`);
   console.log();
 }
 function showHelp() {
   showLogo();
   console.log(`
-${BOLD}Usage:${RESET2} qrdx <command> [options]
+${BOLD}Usage:${RESET3} qrdx <command> [options]
 
-${BOLD}Commands:${RESET2}
+${BOLD}Commands:${RESET3}
   generate, gen, g    Generate a QR code (fully interactive or via flags)
+  batch, b            A static QR code for every row of a CSV file
 
-${BOLD}Generate Options:${RESET2}
+${BOLD}Generate Options:${RESET3}
   <data>              URL or text to encode (positional)
-  -o, --output        Output file path (.svg or .png)
-  -l, --level         Error correction: L, M, Q, H  ${DIM2}(default: Q)${RESET2}
-  --body              Body dot pattern:
-                        ${DIM2}square, circle, circle-large, diamond,${RESET2}
-                        ${DIM2}circle-mixed, pacman, rounded, small-square, vertical-line${RESET2}
-  --eye               Corner eye pattern:
-                        ${DIM2}square, rounded, gear, circle, diya,${RESET2}
-                        ${DIM2}extra-rounded, message, pointy, curly${RESET2}
-  --dot               Corner dot pattern:
-                        ${DIM2}square, rounded, circle, diamond, message,${RESET2}
-                        ${DIM2}message-reverse, diya, diya-reverse,${RESET2}
-                        ${DIM2}rounded-triangle, star, banner${RESET2}
-  --fg                Foreground color \u2014 hex or JSON gradient  ${DIM2}(default: #000000)${RESET2}
-  --bg                Background color \u2014 hex or JSON gradient  ${DIM2}(default: #ffffff)${RESET2}
-  --eye-color         Corner eye color \u2014 hex or JSON gradient  ${DIM2}(default: matches --fg)${RESET2}
-  --dot-color         Corner dot color \u2014 hex or JSON gradient  ${DIM2}(default: matches --fg)${RESET2}
-  --logo              Logo URL for center image
-  --margin            Quiet zone margin in modules  ${DIM2}(default: 0)${RESET2}
-  --size              Output pixel size for SVG/PNG  ${DIM2}(default: 512)${RESET2}
+  -o, --output        Output file path (.svg, .png, .webp or .eps)
+  --format            Output format when the file name has no extension:
+                        ${DIM3}svg, png, webp, eps${RESET3}  ${DIM3}(WebP is lossless; EPS is vector,${RESET3}
+                        ${DIM3}--size = width in points)${RESET3}
+  -l, --level         Error correction: L, M, Q, H  ${DIM3}(default: Q)${RESET3}
+  --body              Body dot pattern, e.g.:
+                        ${DIM3}square, rounded, circle, circle-large, liquid,${RESET3}
+                        ${DIM3}classy, classy-rounded, leaf, hexagon, star, heart${RESET3}
+  --eye               Corner eye pattern, e.g.:
+                        ${DIM3}square, rounded, extra-rounded, gear, leaf, drop,${RESET3}
+                        ${DIM3}squircle, octagon, shield, petal${RESET3}
+  --dot               Corner dot pattern, e.g.:
+                        ${DIM3}square, rounded, circle, leaf, drop, squircle,${RESET3}
+                        ${DIM3}octagon, flower, heart, plus, dots${RESET3}
+                        ${DIM3}All options: https://qrdx.dev/docs/styles${RESET3}
+  --fg                Foreground color \u2014 hex or JSON gradient  ${DIM3}(default: #000000)${RESET3}
+  --bg                Background color \u2014 hex or JSON gradient  ${DIM3}(default: #ffffff)${RESET3}
+  --eye-color         Corner eye color \u2014 hex or JSON gradient  ${DIM3}(default: matches --fg)${RESET3}
+  --dot-color         Corner dot color \u2014 hex or JSON gradient  ${DIM3}(default: matches --fg)${RESET3}
+  --logo              Logo URL for center image (use with --level H)
+  --no-logo           Skip the logo prompt in interactive mode
+  --margin            Quiet zone margin in modules  ${DIM3}(default: 0)${RESET3}
+  --size              Output pixel size for SVG/PNG/WebP  ${DIM3}(default: 512)${RESET3}
   --template          Decorative template wrapper:
-                        ${DIM2}Arrow, StandardBox, SquareBorder, StrikedBox, Halloween${RESET2}
+                        ${DIM3}Arrow, StandardBox, SquareBorder, StrikedBox, Halloween${RESET3}
+  --frame             Call-to-action frame (adds space around the code), e.g.:
+                        ${DIM3}none, banner-bottom, banner-top, rounded-border,${RESET3}
+                        ${DIM3}speech-bubble, polaroid, phone, ticket, sticker${RESET3}
+                        ${DIM3}All frames: https://qrdx.dev/docs/styles${RESET3}
+  --frame-text        Frame label, up to 24 characters  ${DIM3}(default: Scan me; "" hides it)${RESET3}
+  --frame-color       Frame color \u2014 hex  ${DIM3}(default: #000000)${RESET3}
+  --frame-text-color  Frame label color \u2014 hex  ${DIM3}(default: white on banners)${RESET3}
+                        ${DIM3}Frame text/colors without --frame use banner-bottom${RESET3}
+
+${BOLD}Batch Options:${RESET3}  ${DIM3}qrdx batch <file.csv> [options]${RESET3}
+  -o, --out           Folder for the codes  ${DIM3}(default: qr-codes)${RESET3}
+  --format            svg, png or eps  ${DIM3}(default: svg; PNG needs sharp)${RESET3}
+  --value-column      Column with each code's content, by name or number
+                        ${DIM3}(default: value, url, link, data, content, text or qr; else the first)${RESET3}
+  --name-column       Column with file names, by name or number
+                        ${DIM3}(default: file name, name, label, id, title or sku; else qr-00001, ...)${RESET3}
+  --no-header         The first row is a code, not column names
+  --jobs              Codes rendered at a time  ${DIM3}(default: 4 for SVG, 8 otherwise)${RESET3}
+  Every style option above applies to all codes. Rows that fail are listed
+  in errors.csv in the output folder. No row limit; nothing is uploaded.
 
-${BOLD}Gradient Colors:${RESET2}
+${BOLD}Gradient Colors:${RESET3}
   Pass a JSON object to --fg / --bg / --eye-color / --dot-color for gradients:
-  ${DIM2}Linear:  '{"type":"linear","stops":[{"color":"#f00","offset":0},{"color":"#00f","offset":100}],"angle":45}'${RESET2}
-  ${DIM2}Radial:  '{"type":"radial","stops":[{"color":"#f00","offset":0},{"color":"#00f","offset":100}]}'${RESET2}
+  ${DIM3}Linear:  '{"type":"linear","stops":[{"color":"#f00","offset":0},{"color":"#00f","offset":100}],"angle":45}'${RESET3}
+  ${DIM3}Radial:  '{"type":"radial","stops":[{"color":"#f00","offset":0},{"color":"#00f","offset":100}]}'${RESET3}
+  ${DIM3}Angular: '{"type":"angular","stops":[{"color":"#f00","offset":0},{"color":"#00f","offset":100}],"angle":0}'${RESET3}
 
-${BOLD}Global Options:${RESET2}
+${BOLD}Global Options:${RESET3}
   --help, -h          Show this help message
   --version, -v       Show version number
 
-${BOLD}Examples:${RESET2}
-  ${DIM2}$${RESET2} qrdx generate
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev"
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" -o qr.svg
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" -o qr.png --body circle --eye gear --dot star
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --fg "#ff0000" --bg "#ffffff" --size 1024
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --logo "https://qrdx.dev/logo.png" --level H -o branded.svg
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --template Arrow -o arrow.svg
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --template Halloween --body circle --eye gear -o halloween.svg
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --fg '{"type":"linear","stops":[{"color":"#6366f1","offset":0},{"color":"#ec4899","offset":100}],"angle":135}' -o gradient.svg
+${BOLD}Examples:${RESET3}
+  ${DIM3}$${RESET3} qrdx generate
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev"
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" -o qr.svg
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" -o qr.png --body circle --eye gear --dot flower
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" -o qr.eps --size 144
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" --fg "#ff0000" --bg "#ffffff" --size 1024
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" --logo "https://qrdx.dev/logo.png" --level H -o branded.svg
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" --template Arrow -o arrow.svg
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" --template Halloween --body circle --eye gear -o halloween.svg
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" --frame banner-bottom --frame-text "Scan for the menu" -o menu.png
+  ${DIM3}$${RESET3} qrdx batch products.csv -o codes --format png --size 1024 --body circle
+  ${DIM3}$${RESET3} qrdx generate "https://qrdx.dev" --fg '{"type":"linear","stops":[{"color":"#6366f1","offset":0},{"color":"#ec4899","offset":100}],"angle":135}' -o gradient.svg
 
-  Visit ${TEXT2}https://qrdx.dev${RESET2} for more.
+  Visit ${TEXT3}https://qrdx.dev${RESET3} for more.
 `);
 }
 async function main() {
@@ -616,13 +1329,23 @@ async function main() {
   }
   const command = args[0];
   const restArgs = args.slice(1);
+  const generateMeta = {
+    help: showHelp,
+    version: () => console.log(VERSION),
+    start: () => {
+      showLogo();
+      console.log();
+    }
+  };
   switch (command) {
     case "generate":
     case "gen":
     case "g":
-      showLogo();
-      console.log();
-      await runGenerate(restArgs);
+      await runGenerate(restArgs, generateMeta);
+      break;
+    case "batch":
+    case "b":
+      await runBatch(restArgs, generateMeta);
       break;
     case "--help":
     case "-h":
@@ -635,17 +1358,16 @@ async function main() {
       break;
     default:
       if (command.startsWith("-")) {
-        console.log(`Unknown command: ${command}`);
-        console.log(`Run ${BOLD}qrdx --help${RESET2} for usage.`);
+        console.error(`Unknown command: ${command}`);
+        console.error(`Run ${BOLD}qrdx --help${RESET3} for usage.`);
+        process.exitCode = 1;
       } else {
-        showLogo();
-        console.log();
-        await runGenerate(args);
+        await runGenerate(args, generateMeta);
       }
   }
 }
 main().catch((err) => {
   const msg = err instanceof Error ? err.message : String(err);
-  console.error(`\x1B[38;5;203m\u2717 ${msg}${RESET2}`);
+  console.error(`\x1B[38;5;203m\u2717 ${msg}${RESET3}`);
   process.exit(1);
 });