@emasoft/svg-matrix 1.0.30 → 1.0.31

package/bin/svg-matrix.js

@@ -237,15 +237,22 @@ process.on("SIGTERM", () => handleGracefulExit("SIGTERM")); // kill command
  * @returns {void}
  */
 function writeToLogFile(message) {
-  if (config.logFile) {
-    try {
-      const timestamp = new Date().toISOString();
-      // eslint-disable-next-line no-control-regex -- ANSI escape codes are intentional for log stripping
-      const cleanMessage = message.replace(/\x1b\[[0-9;]*m/g, "");
-      appendFileSync(config.logFile, `[${timestamp}] ${cleanMessage}\n`);
-    } catch {
-      /* ignore */
+  // Why: Validate message parameter to prevent crashes
+  if (!message || !config.logFile) return;
+
+  try {
+    // Why: Ensure log directory exists before writing
+    const logDir = dirname(config.logFile);
+    if (!existsSync(logDir)) {
+      mkdirSync(logDir, { recursive: true });
     }
+
+    const timestamp = new Date().toISOString();
+    // eslint-disable-next-line no-control-regex -- ANSI escape codes are intentional for log stripping
+    const cleanMessage = message.replace(/\x1b\[[0-9;]*m/g, "");
+    appendFileSync(config.logFile, `[${timestamp}] ${cleanMessage}\n`);
+  } catch {
+    /* ignore */
   }
 }
 
@@ -319,6 +326,10 @@ function showProgress(current, total, filename) {
   // Why: Don't show progress in quiet mode or when there's only one file
   if (config.quiet || total <= 1) return;
 
+  // Why: Validate parameters to prevent crashes
+  if (!filename || typeof current !== "number" || typeof total !== "number")
+    return;
+
   // Why: In verbose mode, newline before progress to avoid overwriting debug output
   if (config.verbose && current > 1) {
     process.stdout.write("\n");
@@ -355,6 +366,16 @@ function showProgress(current, total, filename) {
  * @throws {Error} If file is invalid or too large
  */
 function validateSvgFile(filePath) {
+  // Why: Validate parameter to prevent crashes
+  if (!filePath || typeof filePath !== "string") {
+    throw new Error("Invalid file path: must be a non-empty string");
+  }
+
+  // Why: Check file exists before attempting to stat
+  if (!existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
   const stats = statSync(filePath);
 
   // Why: Prevent memory exhaustion from huge files
@@ -365,15 +386,27 @@ function validateSvgFile(filePath) {
   }
 
   // Why: Read only first 1KB to check header - don't load entire file
-  const fd = openSync(filePath, "r");
-  const buffer = Buffer.alloc(1024);
-  readSync(fd, buffer, 0, 1024, 0);
-  closeSync(fd);
-  const header = buffer.toString("utf8");
-
-  // Why: SVG files must have an <svg> element - if not, it's not a valid SVG
-  if (!CONSTANTS.SVG_HEADER_PATTERN.test(header)) {
-    throw new Error("Not a valid SVG file (missing <svg> element)");
+  // Use try-finally to ensure fd is always closed, preventing file descriptor leak
+  let fd;
+  try {
+    fd = openSync(filePath, "r");
+    const buffer = Buffer.alloc(1024);
+    readSync(fd, buffer, 0, 1024, 0);
+    const header = buffer.toString("utf8");
+
+    // Why: SVG files must have an <svg> element - if not, it's not a valid SVG
+    if (!CONSTANTS.SVG_HEADER_PATTERN.test(header)) {
+      throw new Error("Not a valid SVG file (missing <svg> element)");
+    }
+  } finally {
+    // Why: Always close file descriptor to prevent resource leak
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch {
+        /* ignore close errors */
+      }
+    }
   }
 
   return true;
@@ -383,34 +416,9 @@ function validateSvgFile(filePath) {
 // WRITE VERIFICATION
 // Why: Detect silent write failures. Some filesystems (especially network
 // shares) may appear to write successfully but fail to persist data.
-// Verification catches this immediately rather than discovering corruption later.
+// Verification is done inline where needed (see processFlatten/Convert/Normalize)
+// rather than in a dedicated function to avoid double memory usage.
 // ============================================================================
-/**
- * Verify file was written correctly by comparing content.
- * @param {string} filePath - Path to file
- * @param {string} expectedContent - Expected file content
- * @returns {boolean} True if verification passed
- * @throws {Error} If verification failed
- * @private
- */
-function _verifyWriteSuccess(filePath, expectedContent) {
-  // Why: Read back what was written and compare
-  const actualContent = readFileSync(filePath, "utf8");
-
-  // Why: Compare lengths first (fast), then content if needed
-  if (actualContent.length !== expectedContent.length) {
-    throw new Error(
-      `Write verification failed: size mismatch (expected ${expectedContent.length}, got ${actualContent.length})`,
-    );
-  }
-
-  // Why: Full content comparison to catch bit flips or encoding issues
-  if (actualContent !== expectedContent) {
-    throw new Error("Write verification failed: content mismatch");
-  }
-
-  return true;
-}
 
 // ============================================================================
 // CRASH LOG
@@ -473,6 +481,8 @@ ${JSON.stringify({ ...config, logFile: config.logFile ? "[redacted]" : null }, n
  * @returns {string} Normalized path
  */
 function normalizePath(p) {
+  // Why: Validate parameter to prevent crashes
+  if (!p || typeof p !== "string") return "";
   return p.replace(/\\/g, "/");
 }
 
@@ -482,6 +492,10 @@ function normalizePath(p) {
  * @returns {string} Absolute normalized path
  */
 function resolvePath(p) {
+  // Why: Validate parameter to prevent crashes
+  if (!p || typeof p !== "string") {
+    throw new Error("Invalid path: must be a non-empty string");
+  }
   return isAbsolute(p)
     ? normalizePath(p)
     : normalizePath(resolve(process.cwd(), p));
@@ -493,6 +507,8 @@ function resolvePath(p) {
  * @returns {boolean} True if directory exists
  */
 function isDir(p) {
+  // Why: Validate parameter to prevent crashes from invalid types
+  if (!p || typeof p !== "string") return false;
   try {
     return statSync(p).isDirectory();
   } catch {
@@ -506,6 +522,8 @@ function isDir(p) {
  * @returns {boolean} True if file exists
  */
 function isFile(p) {
+  // Why: Validate parameter to prevent crashes from invalid types
+  if (!p || typeof p !== "string") return false;
   try {
     return statSync(p).isFile();
   } catch {
@@ -519,6 +537,10 @@ function isFile(p) {
  * @returns {void}
  */
 function ensureDir(dir) {
+  // Why: Validate parameter to prevent crashes
+  if (!dir || typeof dir !== "string") {
+    throw new Error("Invalid directory path: must be a non-empty string");
+  }
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
     logDebug(`Created directory: ${dir}`);
@@ -532,6 +554,14 @@ function ensureDir(dir) {
  * @returns {string[]} Array of SVG file paths
  */
 function getSvgFiles(dir, recursive = false) {
+  // Why: Validate parameter to prevent crashes
+  if (!dir || typeof dir !== "string") {
+    throw new Error("Invalid directory path: must be a non-empty string");
+  }
+  if (!existsSync(dir)) {
+    throw new Error(`Directory not found: ${dir}`);
+  }
+
   const files = [];
   function scan(d) {
     for (const entry of readdirSync(d, { withFileTypes: true })) {
@@ -555,16 +585,28 @@ function getSvgFiles(dir, recursive = false) {
  * @returns {string[]} Array of resolved file paths
  */
 function parseFileList(listPath) {
+  // Why: Validate parameter to prevent crashes
+  if (!listPath || typeof listPath !== "string") {
+    throw new Error("Invalid list file path: must be a non-empty string");
+  }
+  if (!existsSync(listPath)) {
+    throw new Error(`List file not found: ${listPath}`);
+  }
+
   const content = readFileSync(listPath, "utf8");
   const files = [];
   for (const line of content.split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
-    const resolved = resolvePath(trimmed);
-    if (isFile(resolved)) files.push(resolved);
-    else if (isDir(resolved))
-      files.push(...getSvgFiles(resolved, config.recursive));
-    else logWarn(`File not found: ${trimmed}`);
+    try {
+      const resolved = resolvePath(trimmed);
+      if (isFile(resolved)) files.push(resolved);
+      else if (isDir(resolved))
+        files.push(...getSvgFiles(resolved, config.recursive));
+      else logWarn(`File not found: ${trimmed}`);
+    } catch (e) {
+      logWarn(`Invalid path in list: ${trimmed} - ${e.message}`);
+    }
   }
   return files;
 }
@@ -584,10 +626,17 @@ function parseFileList(listPath) {
  * @returns {number} Parsed value or default
  */
 function extractNumericAttr(attrs, attrName, defaultValue = 0) {
+  // Why: Validate parameters to prevent crashes
+  if (!attrs || typeof attrs !== "string") return defaultValue;
+  if (!attrName || typeof attrName !== "string") return defaultValue;
+
   // Why: Use word boundary \b to avoid matching 'rx' when looking for 'x'
   const regex = new RegExp(`\\b${attrName}\\s*=\\s*["']([^"']+)["']`, "i");
   const match = attrs.match(regex);
-  return match ? parseFloat(match[1]) : defaultValue;
+  if (!match) return defaultValue;
+  const val = parseFloat(match[1]);
+  // Why: Return default if parsing fails or results in NaN/Infinity
+  return isNaN(val) || !isFinite(val) ? defaultValue : val;
 }
 
 /**
@@ -598,6 +647,18 @@ function extractNumericAttr(attrs, attrName, defaultValue = 0) {
  * @returns {string|null} Path data or null if extraction failed
  */
 function extractShapeAsPath(shapeType, attrs, precision) {
+  // Why: Validate parameters to prevent crashes
+  if (!shapeType || typeof shapeType !== "string") return null;
+  if (!attrs || typeof attrs !== "string") return null;
+  // Why: Validate precision is a valid finite number within acceptable range
+  if (
+    typeof precision !== "number" ||
+    !isFinite(precision) ||
+    precision < 1 ||
+    precision > CONSTANTS.MAX_PRECISION
+  )
+    return null;
+
   switch (shapeType) {
     case "rect": {
       const x = extractNumericAttr(attrs, "x");
@@ -606,7 +667,8 @@ function extractShapeAsPath(shapeType, attrs, precision) {
       const h = extractNumericAttr(attrs, "height");
       const rx = extractNumericAttr(attrs, "rx");
       const ry = extractNumericAttr(attrs, "ry", rx); // ry defaults to rx per SVG spec
-      if (w <= 0 || h <= 0) return null;
+      // Why: Validate dimensions and corner radii are positive and finite
+      if (w <= 0 || h <= 0 || rx < 0 || ry < 0) return null;
       return GeometryToPath.rectToPathData(
         x,
         y,
@@ -622,6 +684,7 @@ function extractShapeAsPath(shapeType, attrs, precision) {
       const cx = extractNumericAttr(attrs, "cx");
       const cy = extractNumericAttr(attrs, "cy");
       const r = extractNumericAttr(attrs, "r");
+      // Why: Validate radius is positive (already checked by extractNumericAttr for NaN/Infinity)
       if (r <= 0) return null;
       return GeometryToPath.circleToPathData(cx, cy, r, precision);
     }
@@ -630,6 +693,7 @@ function extractShapeAsPath(shapeType, attrs, precision) {
       const cy = extractNumericAttr(attrs, "cy");
       const rx = extractNumericAttr(attrs, "rx");
       const ry = extractNumericAttr(attrs, "ry");
+      // Why: Validate radii are positive (already checked by extractNumericAttr for NaN/Infinity)
       if (rx <= 0 || ry <= 0) return null;
       return GeometryToPath.ellipseToPathData(cx, cy, rx, ry, precision);
     }
@@ -663,6 +727,9 @@ function extractShapeAsPath(shapeType, attrs, precision) {
  * @returns {string[]} Attribute names to remove
  */
 function getShapeSpecificAttrs(shapeType) {
+  // Why: Validate parameter and return empty array for invalid input
+  if (!shapeType || typeof shapeType !== "string") return [];
+
   const attrMap = {
     rect: ["x", "y", "width", "height", "rx", "ry"],
     circle: ["cx", "cy", "r"],
@@ -681,8 +748,13 @@ function getShapeSpecificAttrs(shapeType) {
  * @returns {string} Cleaned attributes
  */
 function removeShapeAttrs(attrs, attrsToRemove) {
+  // Why: Validate parameters to prevent crashes
+  if (!attrs || typeof attrs !== "string") return "";
+  if (!Array.isArray(attrsToRemove)) return attrs;
+
   let result = attrs;
   for (const attrName of attrsToRemove) {
+    if (!attrName || typeof attrName !== "string") continue;
     result = result.replace(
       new RegExp(`\\b${attrName}\\s*=\\s*["'][^"']*["']`, "gi"),
       "",
@@ -726,6 +798,8 @@ const B = supportsUnicode()
  * @returns {string} String without ANSI codes
  */
 function stripAnsi(s) {
+  // Why: Validate parameter to prevent crashes
+  if (!s || typeof s !== "string") return "";
   // eslint-disable-next-line no-control-regex -- ANSI escape codes are intentional for terminal color stripping
   return s.replace(/\x1b\[[0-9;]*m/g, "");
 }
@@ -737,9 +811,14 @@ function stripAnsi(s) {
  * @returns {string} Formatted line
  */
 function boxLine(content, width = 70) {
-  const visible = stripAnsi(content).length;
+  // Why: Validate content parameter to prevent crashes
+  let safeContent = content;
+  if (safeContent === undefined || safeContent === null) safeContent = "";
+  if (typeof safeContent !== "string") safeContent = String(safeContent);
+
+  const visible = stripAnsi(safeContent).length;
   const padding = Math.max(0, width - visible - 2);
-  return `${colors.cyan}${B.v}${colors.reset} ${content}${" ".repeat(padding)}${colors.cyan}${B.v}${colors.reset}`;
+  return `${colors.cyan}${B.v}${colors.reset} ${safeContent}${" ".repeat(padding)}${colors.cyan}${B.v}${colors.reset}`;
 }
 
 /**
@@ -749,10 +828,14 @@ function boxLine(content, width = 70) {
  * @returns {string} Formatted header
  */
 function boxHeader(title, width = 70) {
-  const _hr = B.h.repeat(width); // Reserved for future use (horizontal rule)
-  const visible = stripAnsi(title).length;
+  // Why: Validate title parameter to prevent crashes
+  let safeTitle = title;
+  if (safeTitle === undefined || safeTitle === null) safeTitle = "";
+  if (typeof safeTitle !== "string") safeTitle = String(safeTitle);
+
+  const visible = stripAnsi(safeTitle).length;
   const padding = Math.max(0, width - visible - 2);
-  return `${colors.cyan}${B.v}${colors.reset} ${colors.bright}${title}${colors.reset}${" ".repeat(padding)}${colors.cyan}${B.v}${colors.reset}`;
+  return `${colors.cyan}${B.v}${colors.reset} ${colors.bright}${safeTitle}${colors.reset}${" ".repeat(padding)}${colors.cyan}${B.v}${colors.reset}`;
 }
 
 /**
@@ -886,6 +969,12 @@ ${colors.cyan}${B.bl}${hr}${B.br}${colors.reset}
  * @returns {void}
  */
 function showCommandHelp(command) {
+  // Why: Validate command parameter to prevent crashes
+  if (!command || typeof command !== "string") {
+    showHelp();
+    return;
+  }
+
   const W = 72;
   const hr = B.h.repeat(W);
 
@@ -1034,6 +1123,8 @@ function showVersion() {
  * @returns {string|null} Transform value or null
  */
 function extractTransform(attrs) {
+  // Why: Validate parameter to prevent crashes
+  if (!attrs || typeof attrs !== "string") return null;
   const match = attrs.match(/transform\s*=\s*["']([^"']+)["']/i);
   return match ? match[1] : null;
 }
@@ -1044,6 +1135,8 @@ function extractTransform(attrs) {
  * @returns {string} Attributes without transform
  */
 function removeTransform(attrs) {
+  // Why: Validate parameter to prevent crashes
+  if (!attrs || typeof attrs !== "string") return "";
   return attrs.replace(/\s*transform\s*=\s*["'][^"']*["']/gi, "");
 }
 
@@ -1053,6 +1146,8 @@ function removeTransform(attrs) {
  * @returns {string|null} Path data or null
  */
 function extractPathD(attrs) {
+  // Why: Validate parameter to prevent crashes
+  if (!attrs || typeof attrs !== "string") return null;
   const match = attrs.match(/\bd\s*=\s*["']([^"']+)["']/i);
   return match ? match[1] : null;
 }
@@ -1064,7 +1159,12 @@ function extractPathD(attrs) {
  * @returns {string} Updated attributes
  */
 function replacePathD(attrs, newD) {
-  return attrs.replace(/(\bd\s*=\s*["'])[^"']+["']/i, `$1${newD}"`);
+  // Why: Validate parameters to prevent crashes
+  if (!attrs || typeof attrs !== "string") return "";
+  let safeD = newD;
+  if (safeD === undefined || safeD === null) safeD = "";
+  if (typeof safeD !== "string") safeD = String(safeD);
+  return attrs.replace(/(\bd\s*=\s*["'])[^"']+["']/i, `$1${safeD}"`);
 }
 
 /**
@@ -1086,6 +1186,16 @@ function replacePathD(attrs, newD) {
  * @returns {boolean} True if successful
  */
 function processFlatten(inputPath, outputPath) {
+  // Why: Validate parameters to prevent crashes
+  if (!inputPath || typeof inputPath !== "string") {
+    logError("Invalid input path: must be a non-empty string");
+    return false;
+  }
+  if (!outputPath || typeof outputPath !== "string") {
+    logError("Invalid output path: must be a non-empty string");
+    return false;
+  }
+
   try {
     logDebug(`Processing: ${inputPath}`);
     const svgContent = readFileSync(inputPath, "utf8");
@@ -1116,10 +1226,20 @@ function processFlatten(inputPath, outputPath) {
     };
 
     // Run the full flatten pipeline
-    const { svg: flattenedSvg, stats } = FlattenPipeline.flattenSVG(
-      svgContent,
-      pipelineOptions,
-    );
+    const result = FlattenPipeline.flattenSVG(svgContent, pipelineOptions);
+
+    // Why: Validate result structure to prevent crashes on unexpected return values
+    if (!result || typeof result !== "object") {
+      throw new Error("FlattenPipeline.flattenSVG returned invalid result");
+    }
+    if (!result.svg || typeof result.svg !== "string") {
+      throw new Error("FlattenPipeline.flattenSVG returned invalid SVG");
+    }
+    if (!result.stats || typeof result.stats !== "object") {
+      throw new Error("FlattenPipeline.flattenSVG returned invalid stats");
+    }
+
+    const { svg: flattenedSvg, stats } = result;
 
     // Report statistics
     const parts = [];
@@ -1232,6 +1352,20 @@ function processFlatten(inputPath, outputPath) {
  * @private
  */
 function processFlattenLegacy(inputPath, outputPath, svgContent) {
+  // Why: Validate parameters to prevent crashes
+  if (!inputPath || typeof inputPath !== "string") {
+    logError("Invalid input path: must be a non-empty string");
+    return false;
+  }
+  if (!outputPath || typeof outputPath !== "string") {
+    logError("Invalid output path: must be a non-empty string");
+    return false;
+  }
+  if (!svgContent || typeof svgContent !== "string") {
+    logError("Invalid SVG content: must be a non-empty string");
+    return false;
+  }
+
   let result = svgContent;
   let transformCount = 0;
   let pathCount = 0;
@@ -1377,6 +1511,13 @@ function processFlattenLegacy(inputPath, outputPath, svgContent) {
     groupIterations++;
   }
 
+  // Why: Warn when iteration limit reached - may indicate deeply nested transforms
+  if (groupIterations >= CONSTANTS.MAX_GROUP_ITERATIONS) {
+    logWarn(
+      `Group transform propagation reached maximum iterations (${CONSTANTS.MAX_GROUP_ITERATIONS}). Deeply nested groups may not be fully flattened.`,
+    );
+  }
+
   logInfo(
     `Flattened ${transformCount} transforms (${pathCount} paths, ${shapeCount} shapes) [legacy mode]`,
   );
@@ -1396,6 +1537,16 @@ function processFlattenLegacy(inputPath, outputPath, svgContent) {
  * @returns {boolean} True if successful
  */
 function processConvert(inputPath, outputPath) {
+  // Why: Validate parameters to prevent crashes
+  if (!inputPath || typeof inputPath !== "string") {
+    logError("Invalid input path: must be a non-empty string");
+    return false;
+  }
+  if (!outputPath || typeof outputPath !== "string") {
+    logError("Invalid output path: must be a non-empty string");
+    return false;
+  }
+
   try {
     logDebug(`Converting: ${inputPath}`);
     let result = readFileSync(inputPath, "utf8");
@@ -1457,6 +1608,16 @@ function processConvert(inputPath, outputPath) {
  * @returns {boolean} True if successful
  */
 function processNormalize(inputPath, outputPath) {
+  // Why: Validate parameters to prevent crashes
+  if (!inputPath || typeof inputPath !== "string") {
+    logError("Invalid input path: must be a non-empty string");
+    return false;
+  }
+  if (!outputPath || typeof outputPath !== "string") {
+    logError("Invalid output path: must be a non-empty string");
+    return false;
+  }
+
   try {
     logDebug(`Normalizing: ${inputPath}`);
     let result = readFileSync(inputPath, "utf8");
@@ -1488,6 +1649,12 @@ function processNormalize(inputPath, outputPath) {
  * @returns {boolean} True if successful
  */
 function processInfo(inputPath) {
+  // Why: Validate parameter to prevent crashes
+  if (!inputPath || typeof inputPath !== "string") {
+    logError("Invalid input path: must be a non-empty string");
+    return false;
+  }
+
   try {
     const svg = readFileSync(inputPath, "utf8");
     const vb = svg.match(/viewBox\s*=\s*["']([^"']+)["']/i)?.[1] || "not set";
@@ -1623,6 +1790,20 @@ async function testToolboxFunction(
   originalSize,
   outputDir,
 ) {
+  // Why: Validate parameters to prevent crashes
+  if (!fnName || typeof fnName !== "string") {
+    return {
+      name: "invalid",
+      status: "error",
+      error: "Invalid function name",
+      outputSize: 0,
+      sizeDiff: 0,
+      sizeDiffPercent: 0,
+      outputFile: null,
+      timeMs: 0,
+    };
+  }
+
   const result = {
     name: fnName,
     status: "unknown",
@@ -1634,6 +1815,23 @@ async function testToolboxFunction(
     timeMs: 0,
   };
 
+  // Why: Validate remaining parameters after result initialization
+  if (!originalContent || typeof originalContent !== "string") {
+    result.status = "error";
+    result.error = "Invalid original content";
+    return result;
+  }
+  if (typeof originalSize !== "number" || originalSize < 0) {
+    result.status = "error";
+    result.error = "Invalid original size";
+    return result;
+  }
+  if (!outputDir || typeof outputDir !== "string") {
+    result.status = "error";
+    result.error = "Invalid output directory";
+    return result;
+  }
+
   try {
     const fn = SVGToolbox[fnName];
     if (!fn) {
@@ -1846,10 +2044,18 @@ function parseArgs(args) {
     switch (arg) {
       case "-o":
       case "--output":
+        if (i + 1 >= args.length) {
+          logError("-o/--output requires a value");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         cfg.output = args[++i];
         break;
       case "-l":
       case "--list":
+        if (i + 1 >= args.length) {
+          logError("-l/--list requires a value");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         cfg.listFile = args[++i];
         break;
       case "-r":
@@ -1858,6 +2064,10 @@ function parseArgs(args) {
         break;
       case "-p":
       case "--precision": {
+        if (i + 1 >= args.length) {
+          logError("-p/--precision requires a value");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         const precision = parseInt(args[++i], 10);
         if (
           isNaN(precision) ||
@@ -1889,6 +2099,10 @@ function parseArgs(args) {
         cfg.verbose = true;
         break;
       case "--log-file":
+        if (i + 1 >= args.length) {
+          logError("--log-file requires a value");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         cfg.logFile = args[++i];
         break;
       case "-h":
@@ -1936,6 +2150,12 @@ function parseArgs(args) {
         break;
       // Namespace preservation option (comma-separated list)
       case "--preserve-ns": {
+        if (!argValue && i + 1 >= args.length) {
+          logError(
+            "--preserve-ns requires a comma-separated list of namespaces",
+          );
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         const namespaces = argValue || args[++i];
         if (!namespaces) {
           logError(
@@ -1947,6 +2167,13 @@ function parseArgs(args) {
           .split(",")
           .map((ns) => ns.trim().toLowerCase())
           .filter((ns) => ns.length > 0);
+        // Why: Reject empty array after filtering whitespace-only entries
+        if (cfg.preserveNamespaces.length === 0) {
+          logError(
+            "--preserve-ns list is empty after filtering whitespace",
+          );
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         break;
       }
       case "--svg2-polyfills":
@@ -1958,6 +2185,10 @@ function parseArgs(args) {
         break;
       // E2E verification precision options
       case "--clip-segments": {
+        if (i + 1 >= args.length) {
+          logError("--clip-segments requires a value");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         const segs = parseInt(args[++i], 10);
         if (isNaN(segs) || segs < 8 || segs > 512) {
           logError("clip-segments must be between 8 and 512");
@@ -1967,15 +2198,28 @@ function parseArgs(args) {
         break;
       }
       case "--bezier-arcs": {
+        if (i + 1 >= args.length) {
+          logError("--bezier-arcs requires a value");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         const arcs = parseInt(args[++i], 10);
         if (isNaN(arcs) || arcs < 4 || arcs > 128) {
           logError("bezier-arcs must be between 4 and 128");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
+        // Why: bezier-arcs must be multiple of 4 for proper arc approximation
+        if (arcs % 4 !== 0) {
+          logError("bezier-arcs must be a multiple of 4");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         cfg.bezierArcs = arcs;
         break;
       }
       case "--e2e-tolerance": {
+        if (i + 1 >= args.length) {
+          logError("--e2e-tolerance requires a value");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         const tol = args[++i];
         if (!/^1e-\d+$/.test(tol)) {
           logError("e2e-tolerance must be in format 1e-N (e.g., 1e-10, 1e-12)");
@@ -2044,6 +2288,11 @@ function gatherInputFiles() {
  * @returns {string} Output file path
  */
 function getOutputPath(inputPath) {
+  // Why: Validate parameter to prevent crashes
+  if (!inputPath || typeof inputPath !== "string") {
+    throw new Error("Invalid input path: must be a non-empty string");
+  }
+
   if (!config.output) {
     const dir = dirname(inputPath);
     const base = basename(inputPath, ".svg");