@playcraft/cli 0.0.15 → 0.0.18

package/dist/commands/build.js

@@ -2,7 +2,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import pc from 'picocolors';
 import ora from 'ora';
-import { BaseBuilder, ViteBuilder, PlayableBuilder, PlayableAnalyzer } from '@playcraft/build';
+import { BaseBuilder, ViteBuilder, PlayableBuilder, PlayableAnalyzer, EngineDetector, detectAmmoUsage } from '@playcraft/build';
 import { loadBuildConfig } from '../build-config.js';
 import inquirer from 'inquirer';
 /**
@@ -33,11 +33,59 @@ async function detectBaseBuild(dir) {
     }
 }
 /**
- * 检测项目场景列表
+ * 检测项目场景列表（支持 PlayCanvas 和 PlayCraft 两种格式）
  */
 async function detectProjectScenes(projectPath) {
     try {
-        // 尝试读取 scenes.json
+        // 1. 尝试读取 PlayCraft 格式的 manifest.json
+        const manifestJsonPath = path.join(projectPath, 'manifest.json');
+        try {
+            const manifestContent = await fs.readFile(manifestJsonPath, 'utf-8');
+            const manifestData = JSON.parse(manifestContent);
+            if (manifestData.scenes && Array.isArray(manifestData.scenes)) {
+                // PlayCraft manifest.json 中的场景列表
+                const scenes = manifestData.scenes.map((scene) => ({
+                    id: String(scene.id || scene.name),
+                    name: scene.name || `Scene ${scene.id}`,
+                    isMain: scene.isMain === true
+                }));
+                // 同时检查 scenes/ 目录中是否有不在 manifest 中的场景文件
+                const scenesDir = path.join(projectPath, 'scenes');
+                try {
+                    const sceneFiles = await fs.readdir(scenesDir);
+                    const manifestIds = new Set(scenes.map((s) => String(s.id)));
+                    for (const f of sceneFiles) {
+                        if (!f.endsWith('.json'))
+                            continue;
+                        const fileId = f.replace(/\.scene\.json$/, '').replace(/\.json$/, '');
+                        if (!manifestIds.has(fileId)) {
+                            // 读取场景文件获取名称
+                            try {
+                                const sceneContent = await fs.readFile(path.join(scenesDir, f), 'utf-8');
+                                const sceneData = JSON.parse(sceneContent);
+                                scenes.push({
+                                    id: fileId,
+                                    name: sceneData.name || `Scene ${fileId}`,
+                                    isMain: false
+                                });
+                            }
+                            catch {
+                                scenes.push({ id: fileId, name: `Scene ${fileId}`, isMain: false });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // scenes 目录不存在
+                }
+                if (scenes.length > 0)
+                    return scenes;
+            }
+        }
+        catch {
+            // manifest.json 不存在或解析失败
+        }
+        // 2. 尝试读取 PlayCanvas 格式的 scenes.json
         const scenesJsonPath = path.join(projectPath, 'scenes.json');
         try {
             const scenesContent = await fs.readFile(scenesJsonPath, 'utf-8');
@@ -60,7 +108,7 @@ async function detectProjectScenes(projectPath) {
         catch (error) {
             // scenes.json 不存在或解析失败，尝试其他方法
         }
-        // 尝试从 project.json 读取
+        // 3. 尝试从 project.json 读取
         const projectJsonPath = path.join(projectPath, 'project.json');
         try {
             const projectContent = await fs.readFile(projectJsonPath, 'utf-8');
@@ -81,78 +129,6 @@ async function detectProjectScenes(projectPath) {
         return [];
     }
 }
-function resolveSuggestedPhysicsEngine(use3dPhysics) {
-    return use3dPhysics ? 'cannon' : 'p2';
-}
-async function detectAmmoUsage(baseBuildDir) {
-    const configPath = path.join(baseBuildDir, 'config.json');
-    let hasAmmo = false;
-    let use3dPhysics = false;
-    try {
-        const configContent = await fs.readFile(configPath, 'utf-8');
-        const configJson = JSON.parse(configContent);
-        // 检查 application_properties.use3dPhysics
-        use3dPhysics = Boolean(configJson.application_properties?.use3dPhysics);
-        // 如果 use3dPhysics 未设置，通过检查场景内容来推断
-        // 检查场景是否包含 3D 物理组件（rigidbody, collision 等）
-        if (!use3dPhysics) {
-            const scenesDir = baseBuildDir;
-            try {
-                const files = await fs.readdir(scenesDir);
-                for (const file of files) {
-                    if (file.endsWith('.json') && !['config.json', 'manifest.json'].includes(file)) {
-                        try {
-                            const sceneContent = await fs.readFile(path.join(scenesDir, file), 'utf-8');
-                            // 检查场景是否包含 3D 物理组件
-                            if (sceneContent.includes('"rigidbody"') ||
-                                sceneContent.includes('"collision"') ||
-                                sceneContent.includes('"joint"')) {
-                                use3dPhysics = true;
-                                break;
-                            }
-                        }
-                        catch {
-                            // 忽略单个场景读取失败
-                        }
-                    }
-                }
-            }
-            catch {
-                // 忽略目录读取失败
-            }
-        }
-        if (configJson.assets) {
-            for (const asset of Object.values(configJson.assets)) {
-                const assetData = asset;
-                const moduleName = assetData?.data?.moduleName?.toLowerCase?.() || '';
-                const fileUrl = assetData?.file?.url?.toLowerCase?.() || '';
-                if (moduleName.includes('ammo') || fileUrl.includes('ammo')) {
-                    hasAmmo = true;
-                    break;
-                }
-            }
-        }
-    }
-    catch (error) {
-        // 忽略解析失败
-    }
-    if (!hasAmmo) {
-        try {
-            const settingsContent = await fs.readFile(path.join(baseBuildDir, '__settings__.js'), 'utf-8');
-            if (settingsContent.toLowerCase().includes('ammo')) {
-                hasAmmo = true;
-            }
-        }
-        catch (error) {
-            // 忽略读取失败
-        }
-    }
-    return {
-        hasAmmo,
-        suggestedEngine: resolveSuggestedPhysicsEngine(use3dPhysics),
-        use3dPhysics,
-    };
-}
 async function analyzeBaseBuild(baseBuildDir, ammoReplacement) {
     const assetSizes = [];
     const assetPaths = new Set(); // 用于去重
@@ -225,6 +201,27 @@ export async function buildCommand(projectPath, options) {
     // 清理选项（默认为 false，使用覆盖模式）
     const shouldClean = options.clean === true;
     try {
+        // ====== 引擎检测 ======
+        spinner.text = pc.cyan('检测项目引擎类型...');
+        let detectedEngine;
+        if (options.engine) {
+            // 用户指定了引擎类型
+            detectedEngine = options.engine;
+            console.log(pc.dim(`\nℹ️  使用指定引擎: ${detectedEngine}`));
+        }
+        else {
+            // 自动检测引擎类型
+            detectedEngine = await EngineDetector.detect(resolvedProjectPath);
+            console.log(pc.dim(`\nℹ️  检测到引擎: ${detectedEngine}`));
+            // 对于外部引擎，显示提示
+            if (detectedEngine !== 'playcanvas') {
+                console.log(pc.cyan(`\n🎮 检测到 ${detectedEngine} 项目`));
+                console.log(pc.dim('   将使用 npm install + npm run build 进行构建'));
+                console.log(pc.yellow('   ⚠️ 构建时间可能较长（约 2-5 分钟）\n'));
+            }
+        }
+        const isPlayCanvas = detectedEngine === 'playcanvas';
+        const requiresNpmBuild = detectedEngine !== 'playcanvas';
         if (!options.baseOnly && !options.mode) {
             spinner.stop();
             const modeAnswer = await inquirer.prompt([
@@ -257,58 +254,66 @@ export async function buildCommand(projectPath, options) {
             if (!options.output && fileConfig.outputDir) {
                 options.output = fileConfig.outputDir;
             }
+            // 从配置文件读取 storeUrls（避免重复输入）
+            if (!options.storeUrls && fileConfig.storeUrls) {
+                options.storeUrls = fileConfig.storeUrls;
+                console.log(pc.dim(`\nℹ️  从配置文件读取商店地址`));
+            }
         }
-        // 解析场景选择参数（需要在 baseOnly 之前）
+        // 解析场景选择参数（支持 PlayCanvas 和 PlayCraft 项目）
         let selectedScenes;
-        if (options.scenes) {
-            // 命令行指定了场景参数
-            selectedScenes = options.scenes.split(',').map(s => s.trim()).filter(s => s);
-            if (selectedScenes.length > 0) {
-                console.log(`\n🎬 选中场景: ${selectedScenes.join(', ')}`);
+        if (isPlayCanvas) {
+            if (options.scenes) {
+                // 命令行指定了场景参数
+                selectedScenes = options.scenes.split(',').map(s => s.trim()).filter(s => s);
+                if (selectedScenes.length > 0) {
+                    console.log(`\n🎬 选中场景: ${selectedScenes.join(', ')}`);
+                }
             }
-        }
-        else {
-            // 没有指定场景参数，检测项目场景并提供交互选择
-            spinner.stop();
-            const projectScenes = await detectProjectScenes(resolvedProjectPath);
-            if (projectScenes.length > 1) {
-                // 有多个场景，提示用户选择
-                console.log(pc.cyan(`\n🎬 检测到 ${projectScenes.length} 个场景`));
-                console.log(pc.dim('💡 提示: 只打包选中的场景可以显著减小文件大小（通常可减小 30-60%）\n'));
-                const sceneAnswer = await inquirer.prompt([
-                    {
-                        type: 'checkbox',
-                        name: 'selectedScenes',
-                        message: '选择要打包的场景（使用空格选择，回车确认）:',
-                        choices: projectScenes.map(scene => ({
-                            name: scene.name,
-                            value: scene.name,
-                            checked: true // 默认全选
-                        })),
-                        validate: (answer) => {
-                            if (answer.length === 0) {
-                                return '请至少选择一个场景';
+            else if (options.mode !== 'playable') {
+                // 没有指定场景参数，且不是仅做 playable build（playable 不需要选场景），检测项目场景并提供交互选择
+                spinner.stop();
+                const projectScenes = await detectProjectScenes(resolvedProjectPath);
+                if (projectScenes.length > 1) {
+                    // 有多个场景，提示用户选择
+                    console.log(pc.cyan(`\n🎬 检测到 ${projectScenes.length} 个场景`));
+                    console.log(pc.dim('💡 提示: 只打包选中的场景可以显著减小文件大小（通常可减小 30-60%）\n'));
+                    // 为 PlayCraft 项目标记主场景
+                    const sceneAnswer = await inquirer.prompt([
+                        {
+                            type: 'checkbox',
+                            name: 'selectedScenes',
+                            message: '选择要打包的场景（使用空格选择，回车确认）:',
+                            choices: projectScenes.map(scene => ({
+                                name: scene.isMain ? `${scene.name} (主场景)` : scene.name,
+                                value: scene.name,
+                                checked: scene.isMain === true || !projectScenes.some(s => s.isMain) // 有 isMain 标记则只默认选主场景，否则全选
+                            })),
+                            validate: (answer) => {
+                                if (answer.length === 0) {
+                                    return '请至少选择一个场景';
+                                }
+                                return true;
                             }
-                            return true;
                         }
-                    }
-                ]);
-                selectedScenes = sceneAnswer.selectedScenes;
-                if (selectedScenes && selectedScenes.length > 0) {
-                    if (selectedScenes.length === projectScenes.length) {
-                        console.log(pc.green(`✅ 已选择所有场景 (${selectedScenes.length} 个)`));
-                        // 全选则不传递参数（向后兼容）
-                        selectedScenes = undefined;
-                    }
-                    else {
-                        console.log(pc.green(`✅ 已选择 ${selectedScenes.length} / ${projectScenes.length} 个场景: ${selectedScenes.join(', ')}`));
+                    ]);
+                    selectedScenes = sceneAnswer.selectedScenes;
+                    if (selectedScenes && selectedScenes.length > 0) {
+                        if (selectedScenes.length === projectScenes.length) {
+                            console.log(pc.green(`✅ 已选择所有场景 (${selectedScenes.length} 个)`));
+                            // 全选则不传递参数（向后兼容）
+                            selectedScenes = undefined;
+                        }
+                        else {
+                            console.log(pc.green(`✅ 已选择 ${selectedScenes.length} / ${projectScenes.length} 个场景: ${selectedScenes.join(', ')}`));
+                        }
                     }
                 }
+                else if (projectScenes.length === 1) {
+                    console.log(pc.dim(`ℹ️  项目只有 1 个场景: ${projectScenes[0].name}`));
+                }
+                spinner.start(pc.cyan('🔨 开始打包 Playable Ad...'));
             }
-            else if (projectScenes.length === 1) {
-                console.log(pc.dim(`ℹ️  项目只有 1 个场景: ${projectScenes[0].name}`));
-            }
-            spinner.start(pc.cyan('🔨 开始打包 Playable Ad...'));
         }
         // 如果只执行基础构建
         if (options.baseOnly || options.mode === 'base') {
@@ -329,6 +334,7 @@ export async function buildCommand(projectPath, options) {
                 selectedScenes,
                 clean: shouldClean && !isSameAsInput, // 清理逻辑由 BaseBuilder 内部处理
                 analyze: options.analyze, // 传递 analyze 参数
+                engine: detectedEngine, // 传递引擎类型
             });
             const baseBuild = await baseBuilder.build();
             spinner.succeed(pc.green('✅ 基础构建完成！'));
@@ -353,6 +359,7 @@ export async function buildCommand(projectPath, options) {
             'inmobi',
             'adikteev',
             'remerge',
+            'mintegral',
         ];
         // 渠道输出格式配置（根据各渠道Playable规格对照表）
         // 只支持 HTML: applovin, ironsource, unity, moloco, adikteev, remerge
@@ -376,6 +383,7 @@ export async function buildCommand(projectPath, options) {
             bigo: { formats: ['zip'], default: 'zip' },
             snapchat: { formats: ['zip'], default: 'zip' },
             inmobi: { formats: ['zip'], default: 'zip' },
+            mintegral: { formats: ['zip'], default: 'zip' },
         };
         // 获取渠道支持的格式
         const getPlatformFormats = (platform) => {
@@ -426,6 +434,32 @@ export async function buildCommand(projectPath, options) {
                 ]);
                 selectedFormat = formatAnswer.format;
             }
+            // 输入商店跳转地址（CTA）- 如果配置文件中没有则必填
+            if (!options.storeUrls) {
+                console.log(pc.cyan('\n🔗 商店跳转地址（CTA 按钮目标）'));
+                console.log(pc.dim('   iOS 和 Android 地址均为必填'));
+                const storeUrlAnswer = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'iosStoreUrl',
+                        message: 'iOS App Store URL:',
+                        validate: (input) => input.trim() ? true : '请输入 iOS App Store URL',
+                    },
+                    {
+                        type: 'input',
+                        name: 'androidStoreUrl',
+                        message: 'Android Google Play URL:',
+                        validate: (input) => input.trim() ? true : '请输入 Android Google Play URL',
+                    },
+                ]);
+                options.storeUrls = {
+                    ios: storeUrlAnswer.iosStoreUrl.trim(),
+                    android: storeUrlAnswer.androidStoreUrl.trim(),
+                };
+            }
+            else {
+                console.log(pc.dim(`\n✅ 使用配置文件中的商店地址`));
+            }
             // 选择输出目录
             const outputAnswer = await inquirer.prompt([
                 {
@@ -452,22 +486,47 @@ export async function buildCommand(projectPath, options) {
                 // 未指定格式，使用默认值
                 options.format = formatConfig.default;
             }
+            // 如果命令行未传入 storeUrls，交互式输入（必填）
+            if (!options.storeUrls) {
+                spinner.stop();
+                console.log(pc.cyan('\n🔗 商店跳转地址（CTA 按钮目标）'));
+                console.log(pc.dim('   iOS 和 Android 地址均为必填'));
+                const storeUrlAnswer = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'iosStoreUrl',
+                        message: 'iOS App Store URL:',
+                        validate: (input) => input.trim() ? true : '请输入 iOS App Store URL',
+                    },
+                    {
+                        type: 'input',
+                        name: 'androidStoreUrl',
+                        message: 'Android Google Play URL:',
+                        validate: (input) => input.trim() ? true : '请输入 Android Google Play URL',
+                    },
+                ]);
+                options.storeUrls = {
+                    ios: storeUrlAnswer.iosStoreUrl.trim(),
+                    android: storeUrlAnswer.androidStoreUrl.trim(),
+                };
+                spinner.start(pc.cyan('🔨 开始打包 Playable Ad...'));
+            }
         }
         // 解析配置
         const buildOptions = {
             platform: options.platform,
             format: options.format || 'html',
             outputDir: path.resolve(options.output || './dist'),
-            // 如果命令行指定了 --compress，则使用命令行参数；否则让平台配置生效
-            compressEngine: options.compress,
-            // 如果命令行指定了 --compress-config，则使用命令行参数；否则让平台配置生效
-            compressConfigJson: options.compressConfig,
+            // 压缩选项（默认全部开启）
+            compressEngine: options.compress ?? true,
+            compressConfigJson: options.compressConfig ?? true,
+            compressJS: options.compressJs ?? true,
             analyze: options.analyze || false,
             // Vite 构建选项
             useVite: options.useVite !== false, // 默认使用 Vite
-            // 压缩选项
-            cssMinify: options.cssMinify,
-            jsMinify: options.jsMinify,
+            // 压缩选项（默认全部开启）
+            cssMinify: options.cssMinify ?? true,
+            jsMinify: options.jsMinify ?? true,
             compressImages: options.compressImages,
             imageQuality: options.imageQuality,
             convertToWebP: options.convertToWebP,
@@ -477,6 +536,8 @@ export async function buildCommand(projectPath, options) {
             selectedScenes,
             // ESM 选项
             ...(options.esmMode ? { esmMode: options.esmMode } : {}),
+            // 商店跳转地址
+            ...(options.storeUrls ? { storeUrls: options.storeUrls } : {}),
         };
         if (fileConfig) {
             Object.assign(buildOptions, fileConfig);
@@ -531,77 +592,86 @@ export async function buildCommand(projectPath, options) {
                 selectedScenes,
                 analyze: buildOptions.analyze,
                 analyzeReportPath: buildOptions.analyze ? 'base-bundle-report.html' : undefined,
+                engine: detectedEngine, // 传递引擎类型
             });
             const baseBuild = await baseBuilder.build();
             baseBuildDir = baseBuild.outputDir;
             spinner.text = pc.cyan('✅ 阶段1完成，开始阶段2...');
         }
-        const ammoCheck = await detectAmmoUsage(baseBuildDir);
-        const requestedAmmoEngine = options.ammoEngine;
-        if (requestedAmmoEngine === 'p2' || requestedAmmoEngine === 'cannon') {
-            buildOptions.ammoReplacement = requestedAmmoEngine;
-        }
-        else if (options.replaceAmmo && ammoCheck.hasAmmo && ammoCheck.suggestedEngine) {
-            buildOptions.ammoReplacement = ammoCheck.suggestedEngine;
-        }
-        else if (ammoCheck.hasAmmo && !buildOptions.ammoReplacement) {
-            spinner.stop();
-            // 根据是否使用 3D 物理提供不同的选项
-            const physicsType = ammoCheck.use3dPhysics ? '3D' : '2D';
-            if (ammoCheck.use3dPhysics) {
-                // 3D 项目 - 可以使用 Cannon.js 替换
-                console.log(pc.yellow(`⚠️  检测到 3D 物理项目，Ammo.js 约 1.8MB`));
-                console.log(pc.gray(`   提示: Cannon.js (~400KB) 可以减小 75% 的体积`));
-                const replaceAnswer = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'ammoAction',
-                        message: `如何处理 Ammo.js？`,
-                        choices: [
-                            { name: '保留 Ammo.js（完整物理功能，文件较大）', value: 'keep' },
-                            { name: '替换为 Cannon.js（推荐 3D 项目，~400KB，自动适配）', value: 'cannon' },
-                        ],
-                        default: 'cannon',
-                    },
-                ]);
-                if (replaceAnswer.ammoAction === 'cannon') {
-                    buildOptions.ammoReplacement = 'cannon';
-                    console.log(pc.green('   ✓ 将使用 Cannon.js 替换 Ammo.js（自动兼容 rigidbody API）'));
-                }
+        // Ammo 检测和替换（仅 PlayCanvas 项目）
+        if (isPlayCanvas) {
+            const ammoCheck = await detectAmmoUsage(baseBuildDir);
+            const requestedAmmoEngine = options.ammoEngine;
+            if (requestedAmmoEngine === 'p2' || requestedAmmoEngine === 'cannon') {
+                buildOptions.ammoReplacement = requestedAmmoEngine;
             }
-            else {
-                // 2D 项目 - 可以使用 p2.js 替换
-                const replaceAnswer = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'ammoAction',
-                        message: `检测到 Ammo.js（项目使用 ${physicsType} 物理），如何处理？`,
-                        choices: [
-                            { name: '不替换（保留 Ammo.js，文件较大）', value: 'keep' },
-                            { name: '替换为 p2.js（推荐 2D 项目，~60KB）', value: 'p2' },
-                        ],
-                        default: 'p2',
-                    },
-                ]);
-                if (replaceAnswer.ammoAction === 'p2') {
-                    buildOptions.ammoReplacement = 'p2';
+            else if (options.replaceAmmo && ammoCheck.hasAmmo && ammoCheck.suggestedEngine) {
+                buildOptions.ammoReplacement = ammoCheck.suggestedEngine;
+            }
+            else if (ammoCheck.hasAmmo && !buildOptions.ammoReplacement) {
+                spinner.stop();
+                // 根据是否使用 3D 物理提供不同的选项
+                const physicsType = ammoCheck.use3dPhysics ? '3D' : '2D';
+                if (ammoCheck.use3dPhysics) {
+                    // 3D 项目 - 可以使用 Cannon.js 替换
+                    console.log(pc.yellow(`⚠️  检测到 3D 物理项目，Ammo.js 约 1.8MB`));
+                    console.log(pc.gray(`   提示: Cannon.js (~400KB) 可以减小 75% 的体积`));
+                    const replaceAnswer = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'ammoAction',
+                            message: `如何处理 Ammo.js？`,
+                            choices: [
+                                { name: '保留 Ammo.js（完整物理功能，文件较大）', value: 'keep' },
+                                { name: '替换为 Cannon.js（推荐 3D 项目，~400KB，自动适配）', value: 'cannon' },
+                            ],
+                            default: 'cannon',
+                        },
+                    ]);
+                    if (replaceAnswer.ammoAction === 'cannon') {
+                        buildOptions.ammoReplacement = 'cannon';
+                        console.log(pc.green('   ✓ 将使用 Cannon.js 替换 Ammo.js（自动兼容 rigidbody API）'));
+                    }
+                }
+                else {
+                    // 2D 项目 - 可以使用 p2.js 替换
+                    const replaceAnswer = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'ammoAction',
+                            message: `检测到 Ammo.js（项目使用 ${physicsType} 物理），如何处理？`,
+                            choices: [
+                                { name: '不替换（保留 Ammo.js，文件较大）', value: 'keep' },
+                                { name: '替换为 p2.js（推荐 2D 项目，~60KB）', value: 'p2' },
+                            ],
+                            default: 'p2',
+                        },
+                    ]);
+                    if (replaceAnswer.ammoAction === 'p2') {
+                        buildOptions.ammoReplacement = 'p2';
+                    }
                 }
+                spinner.start(pc.cyan('🔨 开始打包 Playable Ad...'));
             }
-            spinner.start(pc.cyan('🔨 开始打包 Playable Ad...'));
         }
         // 2. 执行阶段2：转换为Playable Ads
         spinner.text = pc.cyan('执行阶段2: 转换为单HTML Playable Ads...');
         let outputPath;
         let sizeReport;
+        // 构建选项中传递引擎类型
+        const viteBuildOptions = {
+            ...buildOptions,
+            engine: detectedEngine,
+        };
         if (buildOptions.useVite !== false) {
             // 使用 Vite 构建
-            const viteBuilder = new ViteBuilder(baseBuildDir, buildOptions);
+            const viteBuilder = new ViteBuilder(baseBuildDir, viteBuildOptions);
             outputPath = await viteBuilder.build();
             sizeReport = viteBuilder.getSizeReport();
         }
         else {
             // 使用旧的 PlayableBuilder（向后兼容）
-            const playableBuilder = new PlayableBuilder(baseBuildDir, buildOptions);
+            const playableBuilder = new PlayableBuilder(baseBuildDir, viteBuildOptions);
             outputPath = await playableBuilder.build();
             sizeReport = playableBuilder.getSizeReport();
         }