@aws/ml-container-creator 0.2.1 → 0.2.3

package/src/lib/registry-loader.js

@@ -9,12 +9,12 @@
  * and the generator's internal data shapes. No MCP runtime dependency.
  */
 
-import { readFileSync } from 'node:fs'
-import { resolve, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 // Catalog file paths relative to this module
 const CATALOG_PATHS = {
@@ -22,12 +22,12 @@ const CATALOG_PATHS = {
     tritonBackends: resolve(__dirname, '../../servers/base-image-picker/catalogs/triton-backends.json'),
     instances: resolve(__dirname, '../../servers/instance-recommender/catalogs/instances.json'),
     popularTransformers: resolve(__dirname, '../../servers/model-picker/catalogs/popular-transformers.json'),
-    popularDiffusors: resolve(__dirname, '../../servers/model-picker/catalogs/popular-diffusors.json'),
-}
+    popularDiffusors: resolve(__dirname, '../../servers/model-picker/catalogs/popular-diffusors.json')
+};
 
 class RegistryLoader {
     constructor() {
-        this._catalogCache = {}
+        this._catalogCache = {};
     }
 
     /**
@@ -36,17 +36,17 @@ class RegistryLoader {
      */
     _loadCatalog(catalogPath) {
         if (this._catalogCache[catalogPath] !== undefined) {
-            return this._catalogCache[catalogPath]
+            return this._catalogCache[catalogPath];
         }
         try {
-            const raw = readFileSync(catalogPath, 'utf8')
-            const data = JSON.parse(raw)
-            this._catalogCache[catalogPath] = data
-            return data
+            const raw = readFileSync(catalogPath, 'utf8');
+            const data = JSON.parse(raw);
+            this._catalogCache[catalogPath] = data;
+            return data;
         } catch (error) {
-            console.warn(`Failed to load catalog ${catalogPath}: ${error.message}`)
-            this._catalogCache[catalogPath] = null
-            return null
+            console.warn(`Failed to load catalog ${catalogPath}: ${error.message}`);
+            this._catalogCache[catalogPath] = null;
+            return null;
         }
     }
 
@@ -65,17 +65,17 @@ class RegistryLoader {
      */
     async loadFrameworkRegistry() {
         try {
-            const catalog = this._loadCatalog(CATALOG_PATHS.modelServers)
-            if (!catalog) return {}
+            const catalog = this._loadCatalog(CATALOG_PATHS.modelServers);
+            if (!catalog) return {};
 
-            const registry = {}
+            const registry = {};
             for (const [frameworkName, entries] of Object.entries(catalog)) {
-                if (!Array.isArray(entries)) continue
-                registry[frameworkName] = {}
+                if (!Array.isArray(entries)) continue;
+                registry[frameworkName] = {};
 
                 for (const entry of entries) {
-                    const version = entry.labels?.framework_version
-                    if (!version) continue
+                    const version = entry.labels?.framework_version;
+                    if (!version) continue;
 
                     registry[frameworkName][version] = {
                         baseImage: entry.image,
@@ -85,14 +85,14 @@ class RegistryLoader {
                         recommendedInstanceTypes: entry.defaults?.recommendedInstanceTypes || [],
                         validationLevel: entry.validationLevel || 'untested',
                         profiles: entry.profiles || {},
-                        notes: entry.notes || '',
-                    }
+                        notes: entry.notes || ''
+                    };
                 }
             }
-            return registry
+            return registry;
         } catch (error) {
-            console.warn(`Failed to load framework registry: ${error.message}`)
-            return {}
+            console.warn(`Failed to load framework registry: ${error.message}`);
+            return {};
         }
     }
 
@@ -116,27 +116,27 @@ class RegistryLoader {
      */
     async loadModelRegistry() {
         try {
-            const transformers = this._loadCatalog(CATALOG_PATHS.popularTransformers) || {}
-            const diffusors = this._loadCatalog(CATALOG_PATHS.popularDiffusors) || {}
+            const transformers = this._loadCatalog(CATALOG_PATHS.popularTransformers) || {};
+            const diffusors = this._loadCatalog(CATALOG_PATHS.popularDiffusors) || {};
 
-            const registry = {}
-            const allModels = { ...transformers, ...diffusors }
+            const registry = {};
+            const allModels = { ...transformers, ...diffusors };
 
             for (const [modelId, entry] of Object.entries(allModels)) {
                 registry[modelId] = {
                     family: entry.family || '',
                     chatTemplate: entry.chat_template ?? null,
-                    requiresTemplate: entry.chat_template != null && entry.chat_template !== '',
+                    requiresTemplate: entry.chat_template !== null && entry.chat_template !== undefined && entry.chat_template !== '',
                     validationLevel: entry.validation_level || 'experimental',
                     frameworkCompatibility: entry.framework_compatibility || {},
                     profiles: entry.profiles || {},
-                    notes: entry.notes || '',
-                }
+                    notes: entry.notes || ''
+                };
             }
-            return registry
+            return registry;
         } catch (error) {
-            console.warn(`Failed to load model registry: ${error.message}`)
-            return {}
+            console.warn(`Failed to load model registry: ${error.message}`);
+            return {};
         }
     }
 
@@ -150,10 +150,10 @@ class RegistryLoader {
      */
     async loadInstanceAcceleratorMapping() {
         try {
-            const catalog = this._loadCatalog(CATALOG_PATHS.instances)
-            if (!catalog || !catalog.catalog) return {}
+            const catalog = this._loadCatalog(CATALOG_PATHS.instances);
+            if (!catalog || !catalog.catalog) return {};
 
-            const mapping = {}
+            const mapping = {};
             for (const [instanceType, entry] of Object.entries(catalog.catalog)) {
                 mapping[instanceType] = {
                     family: entry.family || '',
@@ -162,17 +162,17 @@ class RegistryLoader {
                         hardware: entry.hardware || 'None',
                         architecture: entry.gpuArchitecture || 'None',
                         versions: entry.cudaVersions || null,
-                        default: entry.defaultCudaVersion || null,
+                        default: entry.defaultCudaVersion || null
                     },
                     memory: entry.memGb ? `${entry.memGb} GB` : '0 GB',
                     vcpus: entry.vcpus || 0,
-                    notes: entry.notes || '',
-                }
+                    notes: entry.notes || ''
+                };
             }
-            return mapping
+            return mapping;
         } catch (error) {
-            console.warn(`Failed to load instance accelerator mapping: ${error.message}`)
-            return {}
+            console.warn(`Failed to load instance accelerator mapping: ${error.message}`);
+            return {};
         }
     }
 
@@ -186,13 +186,13 @@ class RegistryLoader {
      */
     async loadTritonBackends() {
         try {
-            const catalog = this._loadCatalog(CATALOG_PATHS.tritonBackends)
-            return catalog || {}
+            const catalog = this._loadCatalog(CATALOG_PATHS.tritonBackends);
+            return catalog || {};
         } catch (error) {
-            console.warn(`Failed to load triton backends: ${error.message}`)
-            return {}
+            console.warn(`Failed to load triton backends: ${error.message}`);
+            return {};
         }
     }
 }
 
-export default RegistryLoader
+export default RegistryLoader;

package/src/lib/sensitive-redactor.js

@@ -14,17 +14,17 @@
 /**
  * Redaction marker used to replace sensitive values.
  */
-export const REDACTION_MARKER = '***REDACTED***'
+export const REDACTION_MARKER = '***REDACTED***';
 
 /**
  * Exact key names that are always considered sensitive.
  */
-export const SENSITIVE_EXACT_KEYS = ['HF_TOKEN', 'AWS_SECRET_ACCESS_KEY', 'AWS_SESSION_TOKEN']
+export const SENSITIVE_EXACT_KEYS = ['HF_TOKEN', 'AWS_SECRET_ACCESS_KEY', 'AWS_SESSION_TOKEN'];
 
 /**
  * Substrings that, when found in a key (case-insensitive), mark it as sensitive.
  */
-export const SENSITIVE_SUBSTRINGS = ['SECRET', 'TOKEN']
+export const SENSITIVE_SUBSTRINGS = ['SECRET', 'TOKEN'];
 
 /**
  * Determine whether a given key matches sensitive patterns.
@@ -37,9 +37,9 @@ export const SENSITIVE_SUBSTRINGS = ['SECRET', 'TOKEN']
  * @returns {boolean} True if the key is sensitive
  */
 export function isSensitiveKey(key) {
-    if (SENSITIVE_EXACT_KEYS.includes(key)) return true
-    const upper = key.toUpperCase()
-    return SENSITIVE_SUBSTRINGS.some(sub => upper.includes(sub))
+    if (SENSITIVE_EXACT_KEYS.includes(key)) return true;
+    const upper = key.toUpperCase();
+    return SENSITIVE_SUBSTRINGS.some(sub => upper.includes(sub));
 }
 
 /**
@@ -51,9 +51,9 @@ export function isSensitiveKey(key) {
  * @returns {Object<string, string>} New object with sensitive values redacted
  */
 export function redactSensitiveValues(params) {
-    const result = {}
+    const result = {};
     for (const [key, value] of Object.entries(params)) {
-        result[key] = isSensitiveKey(key) ? REDACTION_MARKER : value
+        result[key] = isSensitiveKey(key) ? REDACTION_MARKER : value;
     }
-    return result
+    return result;
 }

package/src/lib/template-engine.js

@@ -51,7 +51,7 @@ export default class TemplateEngine {
      * @param {Object} config - Configuration profile
      * @returns {void}
      */
-    generateDeploymentScript(config) {
+    generateDeploymentScript(_config) {
         // No-op: legacy deploy/ scripts have been removed.
         // Deployment is handled by do/deploy in the do-framework.
     }

package/src/lib/template-manager.js

@@ -15,7 +15,7 @@
 /**
  * GPU-requiring Triton backends that must use GPU instance types
  */
-const GPU_REQUIRING_BACKENDS = ['triton-vllm', 'triton-tensorrtllm', 'diffusors-vllm-omni']
+const GPU_REQUIRING_BACKENDS = ['triton-vllm', 'triton-tensorrtllm', 'diffusors-vllm-omni'];
 
 /**
  * CPU-only instance type families (patterns that indicate non-GPU instances)
@@ -24,8 +24,8 @@ const CPU_ONLY_INSTANCE_PATTERNS = [
     /^ml\.m[0-9]+\./,   // ml.m4.*, ml.m5.*, ml.m6i.*, etc.
     /^ml\.c[0-9]+\./,   // ml.c4.*, ml.c5.*, ml.c6i.*, etc.
     /^ml\.t[0-9]+\./,   // ml.t2.*, ml.t3.*, etc.
-    /^ml\.r[0-9]+\./,   // ml.r5.*, ml.r6i.*, etc.
-]
+    /^ml\.r[0-9]+\./   // ml.r5.*, ml.r6i.*, etc.
+];
 
 /**
  * Check if an instance type is CPU-only (no GPU)
@@ -34,14 +34,14 @@ const CPU_ONLY_INSTANCE_PATTERNS = [
  */
 function isCpuOnlyInstance(instanceType) {
     if (!instanceType || instanceType === 'custom') {
-        return false
+        return false;
     }
-    return CPU_ONLY_INSTANCE_PATTERNS.some(pattern => pattern.test(instanceType))
+    return CPU_ONLY_INSTANCE_PATTERNS.some(pattern => pattern.test(instanceType));
 }
 
 export default class TemplateManager {
     constructor(answers) {
-        this.answers = answers
+        this.answers = answers;
     }
 
     /**
@@ -72,17 +72,17 @@ export default class TemplateManager {
                 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1',
                 'ca-central-1', 'sa-east-1'
             ]
-        }
+        };
 
         // Validate deployment configuration if present
         if (this.answers.deploymentConfig) {
-            this._validateChoice('deploymentConfig', supportedOptions.deploymentConfigs)
+            this._validateChoice('deploymentConfig', supportedOptions.deploymentConfigs);
             
             // GPU instance type enforcement for GPU-requiring backends
-            this._validateGpuRequirement()
+            this._validateGpuRequirement();
         } else {
             // Fallback: validate architecture and backend separately (new canonical format)
-            const architectures = ['http', 'transformers', 'triton', 'diffusors']
+            const architectures = ['http', 'transformers', 'triton', 'diffusors'];
             const backends = [
                 // http backends
                 'flask', 'fastapi',
@@ -92,63 +92,63 @@ export default class TemplateManager {
                 'fil', 'onnxruntime', 'tensorflow', 'pytorch', 'tensorrtllm', 'python',
                 // diffusors backends
                 'vllm-omni'
-            ]
+            ];
             
-            this._validateChoice('architecture', architectures)
-            this._validateChoice('backend', backends)
+            this._validateChoice('architecture', architectures);
+            this._validateChoice('backend', backends);
             
             // Validate tensorrt-llm is only used with transformers architecture
             if (this.answers.backend === 'tensorrt-llm' && this.answers.architecture !== 'transformers') {
-                throw new Error('⚠️  TensorRT-LLM is only supported with the transformers architecture. Please select "transformers" as your architecture or choose a different backend.')
+                throw new Error('⚠️  TensorRT-LLM is only supported with the transformers architecture. Please select "transformers" as your architecture or choose a different backend.');
             }
             
             // GPU instance type enforcement for GPU-requiring backends (fallback path)
             const deploymentConfig = this.answers.architecture && this.answers.backend
                 ? `${this.answers.architecture}-${this.answers.backend}`
-                : null
+                : null;
             if (deploymentConfig && GPU_REQUIRING_BACKENDS.includes(deploymentConfig)) {
-                this._validateGpuRequirementForConfig(deploymentConfig)
+                this._validateGpuRequirementForConfig(deploymentConfig);
             }
         }
 
         // Validate buildTarget (replaces deployTarget)
         if (this.answers.buildTarget) {
-            this._validateChoice('buildTarget', supportedOptions.buildTargets)
+            this._validateChoice('buildTarget', supportedOptions.buildTargets);
         } else if (this.answers.deployTarget) {
             // Backward compatibility: validate deployTarget against buildTargets
-            this._validateChoice('deployTarget', supportedOptions.buildTargets)
+            this._validateChoice('deployTarget', supportedOptions.buildTargets);
         }
 
         // Validate deploymentTarget
         if (this.answers.deploymentTarget) {
-            this._validateChoice('deploymentTarget', supportedOptions.deploymentTargets)
+            this._validateChoice('deploymentTarget', supportedOptions.deploymentTargets);
         }
 
         // Validate HyperPod EKS specific fields
         if (this.answers.deploymentTarget === 'hyperpod-eks') {
-            this._validateHyperPodConfig()
+            this._validateHyperPodConfig();
         }
 
         // Validate async inference specific fields
-        this._validateAsyncConfig()
+        this._validateAsyncConfig();
 
         // Validate batch transform specific fields
-        this._validateBatchTransformConfig()
+        this._validateBatchTransformConfig();
         
         // Validate instance type format (ml.*.*) - only for managed-inference
         if (this.answers.instanceType && this.answers.instanceType !== 'custom') {
-            const instancePattern = /^ml\.[a-z0-9]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/
+            const instancePattern = /^ml\.[a-z0-9]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/;
             if (!instancePattern.test(this.answers.instanceType)) {
-                throw new Error(`⚠️  Invalid instance type format: ${this.answers.instanceType}. Expected format: ml.{family}.{size} (e.g., ml.m5.large, ml.g5.xlarge)`)
+                throw new Error(`⚠️  Invalid instance type format: ${this.answers.instanceType}. Expected format: ml.{family}.{size} (e.g., ml.m5.large, ml.g5.xlarge)`);
             }
         }
         
-        this._validateChoice('awsRegion', supportedOptions.awsRegions)
+        this._validateChoice('awsRegion', supportedOptions.awsRegions);
 
         // Validate test types if testing is enabled
         if (this.answers.includeTesting && this.answers.testTypes) {
             for (const testType of this.answers.testTypes) {
-                this._validateChoice('testType', supportedOptions.testTypes, testType)
+                this._validateChoice('testType', supportedOptions.testTypes, testType);
             }
         }
     }
@@ -161,21 +161,21 @@ export default class TemplateManager {
     _validateHyperPodConfig() {
         // Validate hyperPodCluster is non-empty
         if (!this.answers.hyperPodCluster || this.answers.hyperPodCluster.trim() === '') {
-            throw new Error('⚠️  hyperPodCluster is required when deploymentTarget is "hyperpod-eks". Please provide a valid HyperPod cluster name.')
+            throw new Error('⚠️  hyperPodCluster is required when deploymentTarget is "hyperpod-eks". Please provide a valid HyperPod cluster name.');
         }
 
         // Validate hyperPodNamespace conforms to RFC 1123 DNS label format
         if (this.answers.hyperPodNamespace) {
             if (!this._isValidRfc1123DnsLabel(this.answers.hyperPodNamespace)) {
-                throw new Error(`⚠️  Invalid hyperPodNamespace: "${this.answers.hyperPodNamespace}". Namespace must conform to RFC 1123 DNS label format: lowercase alphanumeric characters or hyphens, must start and end with an alphanumeric character, and be at most 63 characters.`)
+                throw new Error(`⚠️  Invalid hyperPodNamespace: "${this.answers.hyperPodNamespace}". Namespace must conform to RFC 1123 DNS label format: lowercase alphanumeric characters or hyphens, must start and end with an alphanumeric character, and be at most 63 characters.`);
             }
         }
 
         // Validate hyperPodReplicas is an integer >= 1
         if (this.answers.hyperPodReplicas !== undefined) {
-            const replicas = this.answers.hyperPodReplicas
+            const replicas = this.answers.hyperPodReplicas;
             if (!Number.isInteger(replicas) || replicas < 1) {
-                throw new Error(`⚠️  Invalid hyperPodReplicas: "${replicas}". Replicas must be an integer greater than or equal to 1.`)
+                throw new Error(`⚠️  Invalid hyperPodReplicas: "${replicas}". Replicas must be an integer greater than or equal to 1.`);
             }
         }
     }
@@ -188,11 +188,11 @@ export default class TemplateManager {
      */
     _isValidRfc1123DnsLabel(value) {
         if (!value || typeof value !== 'string') {
-            return false
+            return false;
         }
         // RFC 1123 DNS label: lowercase alphanumeric, hyphens allowed (not at start/end), max 63 chars
-        const rfc1123Pattern = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/
-        return value.length <= 63 && rfc1123Pattern.test(value)
+        const rfc1123Pattern = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+        return value.length <= 63 && rfc1123Pattern.test(value);
     }
 
     /**
@@ -201,33 +201,33 @@ export default class TemplateManager {
      * @throws {Error} If async configuration is invalid
      */
     _validateAsyncConfig() {
-        if (this.answers.deploymentTarget !== 'async-inference') return
+        if (this.answers.deploymentTarget !== 'async-inference') return;
 
         // Validate S3 output path format if explicitly provided
         if (this.answers.asyncS3OutputPath && this.answers.asyncS3OutputPath.trim() !== '') {
             if (!this.answers.asyncS3OutputPath.startsWith('s3://')) {
-                throw new Error('⚠️  asyncS3OutputPath must start with "s3://". Example: s3://my-bucket/output/')
+                throw new Error('⚠️  asyncS3OutputPath must start with "s3://". Example: s3://my-bucket/output/');
             }
         }
 
         // Validate SNS topic ARN format if explicitly provided
-        const snsArnPattern = /^arn:aws:sns:[a-z0-9-]+:\d{12}:.+$/
+        const snsArnPattern = /^arn:aws:sns:[a-z0-9-]+:\d{12}:.+$/;
         if (this.answers.asyncSnsSuccessTopic && this.answers.asyncSnsSuccessTopic.trim() !== '') {
             if (!snsArnPattern.test(this.answers.asyncSnsSuccessTopic)) {
-                throw new Error('⚠️  asyncSnsSuccessTopic must be a valid SNS ARN. Format: arn:aws:sns:<region>:<account-id>:<topic-name>')
+                throw new Error('⚠️  asyncSnsSuccessTopic must be a valid SNS ARN. Format: arn:aws:sns:<region>:<account-id>:<topic-name>');
             }
         }
         if (this.answers.asyncSnsErrorTopic && this.answers.asyncSnsErrorTopic.trim() !== '') {
             if (!snsArnPattern.test(this.answers.asyncSnsErrorTopic)) {
-                throw new Error('⚠️  asyncSnsErrorTopic must be a valid SNS ARN. Format: arn:aws:sns:<region>:<account-id>:<topic-name>')
+                throw new Error('⚠️  asyncSnsErrorTopic must be a valid SNS ARN. Format: arn:aws:sns:<region>:<account-id>:<topic-name>');
             }
         }
 
         // Validate max concurrent invocations
         if (this.answers.asyncMaxConcurrentInvocations !== undefined) {
-            const val = this.answers.asyncMaxConcurrentInvocations
+            const val = this.answers.asyncMaxConcurrentInvocations;
             if (!Number.isInteger(val) || val < 1) {
-                throw new Error('⚠️  asyncMaxConcurrentInvocations must be an integer >= 1')
+                throw new Error('⚠️  asyncMaxConcurrentInvocations must be an integer >= 1');
             }
         }
     }
@@ -238,61 +238,61 @@ export default class TemplateManager {
      * @throws {Error} If batch transform configuration is invalid
      */
     _validateBatchTransformConfig() {
-        if (this.answers.deploymentTarget !== 'batch-transform') return
+        if (this.answers.deploymentTarget !== 'batch-transform') return;
 
         // Validate S3 input path format if provided
         if (this.answers.batchInputPath && this.answers.batchInputPath.trim() !== '') {
             if (!this.answers.batchInputPath.startsWith('s3://')) {
-                throw new Error('⚠️  batchInputPath must start with "s3://". Example: s3://my-bucket/input/')
+                throw new Error('⚠️  batchInputPath must start with "s3://". Example: s3://my-bucket/input/');
             }
         }
 
         // Validate S3 output path format if provided
         if (this.answers.batchOutputPath && this.answers.batchOutputPath.trim() !== '') {
             if (!this.answers.batchOutputPath.startsWith('s3://')) {
-                throw new Error('⚠️  batchOutputPath must start with "s3://". Example: s3://my-bucket/output/')
+                throw new Error('⚠️  batchOutputPath must start with "s3://". Example: s3://my-bucket/output/');
             }
         }
 
         // Validate instance count
         if (this.answers.batchInstanceCount !== undefined) {
-            const val = this.answers.batchInstanceCount
+            const val = this.answers.batchInstanceCount;
             if (!Number.isInteger(val) || val < 1) {
-                throw new Error('⚠️  batchInstanceCount must be an integer >= 1')
+                throw new Error('⚠️  batchInstanceCount must be an integer >= 1');
             }
         }
 
         // Validate split type
-        const validSplitTypes = ['Line', 'RecordIO', 'None']
+        const validSplitTypes = ['Line', 'RecordIO', 'None'];
         if (this.answers.batchSplitType && !validSplitTypes.includes(this.answers.batchSplitType)) {
-            throw new Error(`⚠️  batchSplitType must be one of: ${validSplitTypes.join(', ')}`)
+            throw new Error(`⚠️  batchSplitType must be one of: ${validSplitTypes.join(', ')}`);
         }
 
         // Validate batch strategy
-        const validStrategies = ['MultiRecord', 'SingleRecord']
+        const validStrategies = ['MultiRecord', 'SingleRecord'];
         if (this.answers.batchStrategy && !validStrategies.includes(this.answers.batchStrategy)) {
-            throw new Error(`⚠️  batchStrategy must be one of: ${validStrategies.join(', ')}`)
+            throw new Error(`⚠️  batchStrategy must be one of: ${validStrategies.join(', ')}`);
         }
 
         // Validate join source
-        const validJoinSources = ['Input', 'None']
+        const validJoinSources = ['Input', 'None'];
         if (this.answers.batchJoinSource && !validJoinSources.includes(this.answers.batchJoinSource)) {
-            throw new Error(`⚠️  batchJoinSource must be one of: ${validJoinSources.join(', ')}`)
+            throw new Error(`⚠️  batchJoinSource must be one of: ${validJoinSources.join(', ')}`);
         }
 
         // Validate max concurrent transforms
         if (this.answers.batchMaxConcurrentTransforms !== undefined) {
-            const val = this.answers.batchMaxConcurrentTransforms
+            const val = this.answers.batchMaxConcurrentTransforms;
             if (!Number.isInteger(val) || val < 0) {
-                throw new Error('⚠️  batchMaxConcurrentTransforms must be an integer >= 0')
+                throw new Error('⚠️  batchMaxConcurrentTransforms must be an integer >= 0');
             }
         }
 
         // Validate max payload in MB
         if (this.answers.batchMaxPayloadInMB !== undefined) {
-            const val = this.answers.batchMaxPayloadInMB
+            const val = this.answers.batchMaxPayloadInMB;
             if (!Number.isInteger(val) || val < 0 || val > 100) {
-                throw new Error('⚠️  batchMaxPayloadInMB must be an integer between 0 and 100')
+                throw new Error('⚠️  batchMaxPayloadInMB must be an integer between 0 and 100');
             }
         }
     }
@@ -304,9 +304,9 @@ export default class TemplateManager {
      * @throws {Error} If a GPU-requiring backend is paired with a CPU-only instance
      */
     _validateGpuRequirement() {
-        const dc = this.answers.deploymentConfig
+        const dc = this.answers.deploymentConfig;
         if (GPU_REQUIRING_BACKENDS.includes(dc)) {
-            this._validateGpuRequirementForConfig(dc)
+            this._validateGpuRequirementForConfig(dc);
         }
     }
 
@@ -317,13 +317,13 @@ export default class TemplateManager {
      * @throws {Error} If instance type is CPU-only
      */
     _validateGpuRequirementForConfig(deploymentConfig) {
-        const instanceType = this.answers.instanceType
+        const instanceType = this.answers.instanceType;
         if (isCpuOnlyInstance(instanceType)) {
             throw new Error(
                 `⚠️  ${deploymentConfig} requires a GPU instance type. ` +
                 `Selected: ${instanceType}. ` +
-                `Recommended: ml.g5.xlarge, ml.g5.2xlarge`
-            )
+                'Recommended: ml.g5.xlarge, ml.g5.2xlarge'
+            );
         }
     }
 
@@ -332,9 +332,9 @@ export default class TemplateManager {
      * @private
      */
     _validateChoice(field, supportedValues, value = null) {
-        const actualValue = value || this.answers[field]
+        const actualValue = value || this.answers[field];
         if (actualValue && !supportedValues.includes(actualValue)) {
-            throw new Error(`⚠️  ${actualValue} not implemented yet for ${field}.`)
+            throw new Error(`⚠️  ${actualValue} not implemented yet for ${field}.`);
         }
     }
 }