@playcraft/build 0.0.4 → 0.0.8

package/dist/analyzers/scene-asset-collector.js

@@ -17,16 +17,95 @@ export async function analyzeSceneDependencies(sceneData, assets) {
         indirectAssets: new Set(),
         scripts: new Set(),
     };
+    // 调试：检查场景数据结构
+    const hasEntities = !!sceneData.entities;
+    const entityCount = hasEntities ? Object.keys(sceneData.entities).length : 0;
+    console.log(`  [SceneAnalyzer] 场景 "${deps.sceneName}" (ID: ${deps.sceneId})`);
+    console.log(`    - 有 entities: ${hasEntities}, 实体数量: ${entityCount}`);
     // 1. 遍历所有实体
     if (sceneData.entities) {
         for (const [entityId, entity] of Object.entries(sceneData.entities)) {
             collectEntityAssets(entity, deps, assets);
         }
     }
-    // 2. 递归收集间接依赖
+    else {
+        console.warn(`    ⚠️ 警告: 场景没有 entities 字段，资源收集可能不完整！`);
+    }
+    // 2. 收集场景设置中引用的资源（如 skybox、环境贴图等）
+    if (sceneData.settings) {
+        collectSettingsAssets(sceneData.settings, deps, assets);
+    }
+    // 3. 递归收集间接依赖
     collectIndirectDependencies(deps, assets);
     return deps;
 }
+/**
+ * 收集场景设置中引用的资源
+ * 包括 skybox、环境贴图、光照贴图等
+ */
+function collectSettingsAssets(settings, deps, assets) {
+    if (!settings || typeof settings !== 'object')
+        return;
+    // 渲染设置中的资源引用
+    if (settings.render) {
+        const render = settings.render;
+        // Skybox
+        if (render.skybox) {
+            const skyboxId = String(render.skybox);
+            if (assets[skyboxId]) {
+                deps.directAssets.add(skyboxId);
+            }
+        }
+        // 环境贴图 (ambientBake 相关)
+        if (render.ambientBakeSphereMesh) {
+            const meshId = String(render.ambientBakeSphereMesh);
+            if (assets[meshId]) {
+                deps.directAssets.add(meshId);
+            }
+        }
+    }
+    // 物理设置中的资源引用（如果有）
+    if (settings.physics) {
+        findAssetIds(settings.physics, deps, assets, 0);
+    }
+    // 递归扫描整个 settings 对象以捕获任何其他资源引用
+    // 但跳过已知的非资源字段
+    const knownNonAssetFields = ['gravity', 'lightingCells', 'global_ambient', 'fog_color',
+        'skyboxRotation', 'skyMeshPosition', 'skyMeshRotation', 'skyMeshScale', 'skyCenter'];
+    const scanSettings = (obj, depth = 0) => {
+        if (depth > 5)
+            return;
+        if (obj === null || obj === undefined)
+            return;
+        if (typeof obj === 'number') {
+            const id = String(obj);
+            // 检查是否是有效的资源 ID（数字且存在于 assets 中）
+            if (assets[id]) {
+                deps.directAssets.add(id);
+            }
+        }
+        else if (Array.isArray(obj)) {
+            // 跳过坐标/颜色数组（通常是 3 或 4 个小数或小整数）
+            // 资源 ID 通常是大于 10000 的正整数，不会被误跳过
+            if (obj.length <= 4 && obj.every(v => typeof v === 'number' && (!Number.isInteger(v) || // 浮点数（坐标/颜色）
+                (v >= 0 && v < 1000) // 小正整数（颜色分量等）
+            ))) {
+                return;
+            }
+            for (const item of obj) {
+                scanSettings(item, depth + 1);
+            }
+        }
+        else if (typeof obj === 'object') {
+            for (const [key, value] of Object.entries(obj)) {
+                if (knownNonAssetFields.includes(key))
+                    continue;
+                scanSettings(value, depth + 1);
+            }
+        }
+    };
+    scanSettings(settings);
+}
 /**
  * 收集实体的资源引用
  */
@@ -131,6 +210,21 @@ function collectIndirectDependencies(deps, assets) {
                 }
                 break;
             case 'cubemap':
+                // Cubemap 引用 6 个纹理面（textures 数组）
+                if (asset.data?.textures && Array.isArray(asset.data.textures)) {
+                    for (const textureId of asset.data.textures) {
+                        if (textureId !== null && textureId !== undefined) {
+                            const id = String(textureId);
+                            if (assets[id] && !visited.has(id) && !deps.directAssets.has(id)) {
+                                deps.indirectAssets.add(id);
+                                queue.push(id);
+                            }
+                        }
+                    }
+                }
+                // 还要扫描其他可能的数据
+                findAssetIdsInData(asset.data, deps, assets, queue, visited);
+                break;
             case 'texture':
                 // 纹理资源通常是叶子节点，但可能引用其他纹理（如合成纹理）
                 findAssetIdsInData(asset.data, deps, assets, queue, visited);
@@ -146,6 +240,30 @@ function collectIndirectDependencies(deps, assets) {
                 }
                 findAssetIdsInData(asset.data, deps, assets, queue, visited);
                 break;
+            case 'template':
+                // 模板资产内部的 entities 可能引用其他资产（字体、纹理、脚本等）
+                if (asset.data?.entities) {
+                    for (const entity of Object.values(asset.data.entities)) {
+                        findAssetIdsInData(entity, deps, assets, queue, visited);
+                    }
+                }
+                break;
+            case 'render':
+                // Render 资源引用 containerAsset (GLB/GLTF 模型)
+                if (asset.data?.containerAsset) {
+                    const id = String(asset.data.containerAsset);
+                    if (assets[id] && !visited.has(id) && !deps.directAssets.has(id)) {
+                        deps.indirectAssets.add(id);
+                        queue.push(id);
+                    }
+                }
+                findAssetIdsInData(asset.data, deps, assets, queue, visited);
+                break;
+            case 'container':
+                // Container 可能引用内部的 render 和 material 资源
+                // 主要是 GLB/GLTF 文件，它本身是独立的
+                findAssetIdsInData(asset.data, deps, assets, queue, visited);
+                break;
         }
     }
 }
@@ -211,8 +329,99 @@ export async function collectScenesAssets(scenes, assets, globalScriptIds) {
             allAssetIds.add(id);
         }
     }
+    // 收集所有 template 资源及其依赖
+    // template 通常是运行时通过 assets.find() 动态实例化的，需要包含所有 preload 的模板
+    console.log(`\n📦 收集 Template 资源依赖...`);
+    const templateDeps = collectAllTemplatesDependencies(assets);
+    let templateAssetsCount = 0;
+    for (const id of templateDeps) {
+        if (!allAssetIds.has(id)) {
+            allAssetIds.add(id);
+            templateAssetsCount++;
+        }
+    }
+    console.log(`  - 从 Template 添加了 ${templateAssetsCount} 个额外资源`);
     return allAssetIds;
 }
+/**
+ * 收集所有 preload=true 的 template 资源及其依赖
+ * 因为 template 通常是运行时动态实例化的，不一定在场景中直接引用
+ */
+function collectAllTemplatesDependencies(assets) {
+    const result = new Set();
+    const visited = new Set();
+    const queue = [];
+    // 首先收集所有 preload=true 的 template
+    for (const [assetId, asset] of Object.entries(assets)) {
+        if (asset.type === 'template' && asset.preload !== false) {
+            result.add(assetId);
+            queue.push(assetId);
+        }
+    }
+    // 然后递归收集这些 template 的所有依赖
+    while (queue.length > 0) {
+        const assetId = queue.shift();
+        if (visited.has(assetId))
+            continue;
+        visited.add(assetId);
+        const asset = assets[assetId];
+        if (!asset)
+            continue;
+        // 扫描资源数据中引用的其他资源 ID
+        const foundIds = new Set();
+        scanForAssetIds(asset, assets, foundIds);
+        for (const id of foundIds) {
+            if (!result.has(id)) {
+                result.add(id);
+                queue.push(id); // 继续递归收集依赖
+            }
+        }
+    }
+    return result;
+}
+/**
+ * 扫描对象中可能的资源 ID 引用
+ */
+function scanForAssetIds(obj, assets, foundIds, depth = 0) {
+    if (depth > 15)
+        return;
+    if (obj === null || obj === undefined)
+        return;
+    if (typeof obj === 'number') {
+        const id = String(obj);
+        if (assets[id]) {
+            foundIds.add(id);
+        }
+    }
+    else if (typeof obj === 'string') {
+        // 直接检查字符串是否是有效的资源 ID（不再限制为纯数字）
+        if (assets[obj]) {
+            foundIds.add(obj);
+        }
+    }
+    else if (Array.isArray(obj)) {
+        // 跳过坐标/颜色数组（通常是 3 或 4 个小数或小整数）
+        // 资源 ID 通常是大于 10000 的正整数，不会被误跳过
+        if (obj.length <= 4 && obj.every(v => typeof v === 'number' && (!Number.isInteger(v) || // 浮点数（坐标/颜色）
+            (v >= 0 && v < 1000) // 小正整数（颜色分量等）
+        ))) {
+            return;
+        }
+        for (const item of obj) {
+            scanForAssetIds(item, assets, foundIds, depth + 1);
+        }
+    }
+    else if (typeof obj === 'object') {
+        for (const [key, value] of Object.entries(obj)) {
+            // 跳过明显不是资源引用的字段
+            if (['name', 'enabled', 'position', 'rotation', 'scale', 'tags',
+                'children', 'parent', 'resource_id'].includes(key)) {
+                continue;
+            }
+            scanForAssetIds(value, assets, foundIds, depth + 1);
+        }
+    }
+}
 /**
  * 打印场景依赖统计信息
  */

package/dist/base-builder.d.ts

@@ -1,11 +1,14 @@
+import type { BaseBuildMetadata } from './types.js';
 export interface BaseBuildOptions {
     outputDir: string;
     selectedScenes?: string[];
     analyze?: boolean;
     analyzeReportPath?: string;
+    clean?: boolean;
 }
 export interface BaseBuildOutput {
     outputDir: string;
+    metadata: BaseBuildMetadata;
     files: {
         html: string;
         engine: string | null;
@@ -34,6 +37,10 @@ export declare class BaseBuilder {
      * 执行基础构建
      */
     build(): Promise<BaseBuildOutput>;
+    /**
+     * 保存构建元数据到输出目录
+     */
+    private saveBuildMetadata;
     /**
      * 检测项目类型
      */
@@ -42,6 +49,14 @@ export declare class BaseBuilder {
      * 从官方构建产物构建
      */
     private buildFromOfficial;
+    /**
+     * 从输出目录检测构建模式
+     */
+    private detectBuildModeFromOutput;
+    /**
+     * 检测是否为 ESM 格式项目
+     */
+    private detectESMFormat;
     /**
      * 验证官方构建产物
      */

package/dist/base-builder.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import { build as viteBuild } from 'vite';
 import { visualizer } from 'rollup-plugin-visualizer';
 import { viteSourceBuilderPlugin } from './vite/plugin-source-builder.js';
+import { loadPlayCanvasProject } from './loaders/playcanvas-loader.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
@@ -19,6 +20,7 @@ export class BaseBuilder {
     constructor(projectDir, options) {
         this.projectDir = projectDir;
         this.options = options;
+        console.log(`[BaseBuilder] 初始化: projectDir=${projectDir}, outputDir=${options.outputDir}`);
     }
     /**
      * 执行基础构建
@@ -26,16 +28,28 @@ export class BaseBuilder {
     async build() {
         // 1. 检测项目类型
         const projectType = await this.detectProjectType();
+        let result;
         if (projectType === 'official-build') {
             // 官方构建产物 - 直接复制并验证
-            return await this.buildFromOfficial();
+            result = await this.buildFromOfficial();
         }
         else {
             // 源代码格式（PlayCanvas 或 PlayCraft）- 使用 Vite 生成构建产物
             const formatName = projectType === 'playcraft' ? 'PlayCraft' : 'PlayCanvas';
             console.log(`[BaseBuilder] 检测到 ${formatName} 源代码格式，使用 Vite 构建...`);
-            return await this.buildFromSource();
+            result = await this.buildFromSource();
         }
+        // 保存构建元数据
+        await this.saveBuildMetadata(result.metadata);
+        return result;
+    }
+    /**
+     * 保存构建元数据到输出目录
+     */
+    async saveBuildMetadata(metadata) {
+        const metadataPath = path.join(this.options.outputDir, '.build-metadata.json');
+        await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8');
+        console.log('[BaseBuilder] 构建元数据已保存');
     }
     /**
      * 检测项目类型
@@ -79,20 +93,72 @@ export class BaseBuilder {
         await fs.mkdir(this.options.outputDir, { recursive: true });
         // 复制所有文件到输出目录
         const files = await this.copyBuildFiles();
+        // 检测构建模式（官方构建产物可能是 Classic 或 ESM）
+        const metadata = await this.detectBuildModeFromOutput();
         return {
             outputDir: this.options.outputDir,
+            metadata,
             files,
         };
     }
+    /**
+     * 从输出目录检测构建模式
+     */
+    async detectBuildModeFromOutput() {
+        const indexPath = path.join(this.options.outputDir, 'index.html');
+        try {
+            const html = await fs.readFile(indexPath, 'utf-8');
+            const hasImportMap = html.includes('<script type="importmap">');
+            if (hasImportMap) {
+                const importMapMatch = html.match(/<script type="importmap">\s*(\{[\s\S]*?\})\s*<\/script>/);
+                const importMapContent = importMapMatch ? JSON.parse(importMapMatch[1]) : { imports: {} };
+                return {
+                    mode: 'esm',
+                    importMap: {
+                        id: 'detected',
+                        imports: importMapContent.imports || {},
+                    },
+                    entryPoint: 'js/index.mjs',
+                };
+            }
+        }
+        catch (error) {
+            // 忽略错误，返回 Classic 模式
+        }
+        return {
+            mode: 'classic',
+        };
+    }
+    /**
+     * 检测是否为 ESM 格式项目
+     */
+    async detectESMFormat() {
+        // ESM 格式的特征：存在 js/index.mjs 或 esm-scripts 目录
+        const esmIndicators = [
+            path.join(this.projectDir, 'js/index.mjs'),
+            path.join(this.projectDir, 'esm-scripts'),
+        ];
+        for (const indicator of esmIndicators) {
+            try {
+                await fs.access(indicator);
+                return true;
+            }
+            catch {
+                // 继续检查下一个
+            }
+        }
+        return false;
+    }
     /**
      * 验证官方构建产物
      */
     async validateOfficialBuild() {
-        const requiredFiles = [
-            'index.html',
-            'config.json',
-            '__start__.js',
-        ];
+        // 检测是否为 ESM 格式
+        const isESM = await this.detectESMFormat();
+        // ESM 格式不需要 __start__.js，Classic 格式需要
+        const requiredFiles = isESM
+            ? ['index.html', 'config.json']
+            : ['index.html', 'config.json', '__start__.js'];
         const missingFiles = [];
         for (const file of requiredFiles) {
             try {
@@ -103,8 +169,9 @@ export class BaseBuilder {
             }
         }
         if (missingFiles.length > 0) {
+            const formatType = isESM ? 'ESM' : 'Classic';
             throw new Error(`官方构建产物缺少必需文件: ${missingFiles.join(', ')}\n` +
-                `请确保项目目录包含完整的构建产物。`);
+                `检测到 ${formatType} 格式，请确保项目目录包含完整的构建产物。`);
         }
     }
     /**
@@ -134,11 +201,20 @@ export class BaseBuilder {
         // 读取 config.json 以获取场景信息
         const configContent = await fs.readFile(configPath, 'utf-8');
         const configJson = JSON.parse(configContent);
-        // 复制 __start__.js
-        const startPath = path.join(this.projectDir, '__start__.js');
-        const outputStartPath = path.join(this.options.outputDir, '__start__.js');
-        await fs.copyFile(startPath, outputStartPath);
-        files.start = outputStartPath;
+        // 检测是否为 ESM 格式
+        const isESM = await this.detectESMFormat();
+        // 复制 __start__.js（Classic 格式必需，ESM 格式不需要）
+        if (!isESM) {
+            const startPath = path.join(this.projectDir, '__start__.js');
+            const outputStartPath = path.join(this.options.outputDir, '__start__.js');
+            try {
+                await fs.copyFile(startPath, outputStartPath);
+                files.start = outputStartPath;
+            }
+            catch (error) {
+                console.warn('警告: 无法复制 __start__.js');
+            }
+        }
         // 复制 __settings__.js（如果存在）
         const settingsPath = path.join(this.projectDir, '__settings__.js');
         try {
@@ -259,6 +335,30 @@ export class BaseBuilder {
         catch (error) {
             // manifest.json 可能不存在
         }
+        // ESM 格式：复制 js/ 目录（如果存在）
+        const jsDir = path.join(this.projectDir, 'js');
+        try {
+            const jsDirStat = await fs.stat(jsDir);
+            if (jsDirStat.isDirectory()) {
+                const outputJsDir = path.join(this.options.outputDir, 'js');
+                await this.copyDirectory(jsDir, outputJsDir);
+            }
+        }
+        catch (error) {
+            // js/ 目录可能不存在
+        }
+        // ESM 格式：复制 esm-scripts/ 目录（如果存在）
+        const esmScriptsDir = path.join(this.projectDir, 'esm-scripts');
+        try {
+            const esmScriptsDirStat = await fs.stat(esmScriptsDir);
+            if (esmScriptsDirStat.isDirectory()) {
+                const outputEsmScriptsDir = path.join(this.options.outputDir, 'esm-scripts');
+                await this.copyDirectory(esmScriptsDir, outputEsmScriptsDir);
+            }
+        }
+        catch (error) {
+            // esm-scripts/ 目录可能不存在
+        }
         return files;
     }
     /**
@@ -283,13 +383,77 @@ export class BaseBuilder {
      */
     async buildFromSource() {
         console.log('[BaseBuilder] 使用 Vite 从源代码构建...');
+        console.log('[BaseBuilder] ====== 开始检测构建模式 ======');
+        // 0. 检测构建模式（Import Map）
+        let buildMode = 'classic';
+        let importMap = undefined;
+        try {
+            console.log('[BaseBuilder] 正在加载项目配置...');
+            const projectConfig = await loadPlayCanvasProject(this.projectDir);
+            console.log('[BaseBuilder] 项目配置加载成功');
+            console.log('[BaseBuilder] Import Map:', projectConfig.importMap ? 'YES' : 'NO');
+            buildMode = projectConfig.importMap ? 'esm' : 'classic';
+            importMap = projectConfig.importMap;
+            console.log(`[BaseBuilder] ====== 构建模式: ${buildMode} ======`);
+            if (importMap) {
+                console.log(`[BaseBuilder] Import Map ID: ${importMap.id}`);
+            }
+        }
+        catch (error) {
+            console.error('[BaseBuilder] 加载配置出错:', error.message);
+            console.log('[BaseBuilder] 无法加载 PlayCanvas 项目配置，使用传统模式');
+        }
         // 1. 创建 Vite 配置
-        const viteConfig = {
+        // 默认使用覆盖模式（不清空输出目录），只有显式设置 clean: true 时才清空
+        const shouldEmptyOutDir = this.options.clean === true;
+        const viteConfig = buildMode === 'esm' ? {
+            // ESM 模式：不需要打包用户脚本，只需触发插件复制文件
             root: this.projectDir,
             base: './',
             build: {
                 outDir: this.options.outputDir,
-                emptyOutDir: true,
+                emptyOutDir: shouldEmptyOutDir,
+                write: false, // 不写入文件，仅用于触发插件
+                rollupOptions: {
+                    input: {
+                        // 使用虚拟入口，仅用于触发插件
+                        'esm-entry': 'virtual:esm-entry',
+                    },
+                },
+            },
+            plugins: [
+                // 虚拟入口插件
+                {
+                    name: 'virtual-esm-entry',
+                    resolveId(id) {
+                        if (id === 'virtual:esm-entry') {
+                            return '\0virtual:esm-entry';
+                        }
+                        return null;
+                    },
+                    load(id) {
+                        if (id === '\0virtual:esm-entry') {
+                            return '// ESM mode - no bundling needed';
+                        }
+                        return null;
+                    },
+                },
+                // 源代码构建插件
+                viteSourceBuilderPlugin({
+                    projectDir: this.projectDir,
+                    outputDir: this.options.outputDir,
+                    selectedScenes: this.options.selectedScenes,
+                    buildMode: buildMode,
+                    importMap: importMap,
+                }),
+            ],
+        } : {
+            // 传统模式：打包用户脚本
+            root: this.projectDir,
+            base: './',
+            build: {
+                outDir: this.options.outputDir,
+                emptyOutDir: shouldEmptyOutDir,
                 // 多文件输出（不内联资源）
                 assetsInlineLimit: 0,
                 // Base Build 不压缩（保持可读性和调试性）
@@ -323,6 +487,8 @@ export class BaseBuilder {
                     projectDir: this.projectDir,
                     outputDir: this.options.outputDir,
                     selectedScenes: this.options.selectedScenes,
+                    buildMode: buildMode,
+                    importMap: importMap,
                 }),
                 // 打包分析报告（如果启用）
                 ...(this.options.analyze ? [
@@ -343,9 +509,19 @@ export class BaseBuilder {
         await viteBuild(viteConfig);
         // 3. 扫描生成的文件
         const files = await this.scanOutputFiles();
-        // 4. 返回构建结果
+        // 4. 构建元数据
+        const metadata = {
+            mode: buildMode,
+            importMap: importMap ? {
+                id: importMap.id,
+                imports: importMap.content.imports,
+            } : undefined,
+            entryPoint: buildMode === 'esm' ? 'js/index.mjs' : undefined,
+        };
+        // 5. 返回构建结果
         return {
             outputDir: this.options.outputDir,
+            metadata,
             files,
         };
     }

package/dist/generators/config-generator.js

@@ -61,7 +61,11 @@ export async function generateConfig(projectConfig, options) {
         if (pcProject.scenes) {
             allScenes = Array.isArray(pcProject.scenes)
                 ? pcProject.scenes
-                : Object.entries(pcProject.scenes).map(([id, scene]) => ({ id, ...scene }));
+                : Object.entries(pcProject.scenes).map(([keyId, scene]) => {
+                    // keyId 是场景文件名使用的 ID（如 "2388047"）
+                    // scene 中可能也有 id 字段（如 "2415082"），但场景文件名应该用 keyId
+                    return { ...scene, sceneFileId: keyId };
+                });
         }
         // 场景过滤：如果指定了选中的场景，则只包含这些场景
         let selectedScenes = allScenes;
@@ -79,8 +83,9 @@ export async function generateConfig(projectConfig, options) {
             });
         }
         config.scenes = selectedScenes.map((scene) => ({
-            name: scene.name || scene.id,
-            url: scene.url || scene.file || `${scene.id}.json`,
+            name: scene.name || scene.sceneFileId || scene.id,
+            // 场景文件名优先使用 sceneFileId（来自 scenes.json 的 key）
+            url: scene.url || scene.file || `${scene.sceneFileId || scene.id}.json`,
         }));
         // 处理资产：基于场景过滤
         if (pcProject.assets) {
@@ -90,6 +95,15 @@ export async function generateConfig(projectConfig, options) {
             // 如果启用了场景过滤，分析场景依赖
             if (options?.selectedScenes && options.selectedScenes.length > 0 && selectedScenes.length > 0) {
                 console.log(`\n🔍 分析场景资源依赖...`);
+                // 调试：检查场景数据结构
+                for (const scene of selectedScenes) {
+                    const sceneKeys = Object.keys(scene || {});
+                    const hasEntities = 'entities' in scene;
+                    console.log(`  [DEBUG] 场景 "${scene.name}" 字段: [${sceneKeys.slice(0, 10).join(', ')}${sceneKeys.length > 10 ? '...' : ''}]`);
+                    if (!hasEntities) {
+                        console.warn(`  ⚠️ 场景 "${scene.name}" 没有 entities 字段，可能导致资源收集不完整！`);
+                    }
+                }
                 allowedAssetIds = await collectScenesAssets(selectedScenes, pcProject.assets, scriptIds);
                 // 打印每个场景的依赖统计
                 for (const scene of selectedScenes) {
@@ -108,6 +122,12 @@ export async function generateConfig(projectConfig, options) {
                 if (!shouldIncludeAsset(asset, scriptIds, requiredScriptIds)) {
                     continue;
                 }
+                // template 资产始终包含（因为它们通常是运行时通过 assets.find() 动态引用的）
+                const assetAny = asset;
+                if (assetAny.type === 'template') {
+                    filtered[assetId] = asset;
+                    continue;
+                }
                 // 场景过滤：如果启用，只包含场景依赖的资源
                 if (allowedAssetIds && !allowedAssetIds.has(assetId)) {
                     continue;
@@ -179,6 +199,12 @@ export async function generateConfig(projectConfig, options) {
                 if (!shouldIncludeAsset(asset, scriptIds, requiredScriptIds)) {
                     continue;
                 }
+                // template 资产始终包含（因为它们通常是运行时通过 assets.find() 动态引用的）
+                const assetAny = asset;
+                if (assetAny.type === 'template') {
+                    filtered[assetId] = asset;
+                    continue;
+                }
                 // 场景过滤：如果启用，只包含场景依赖的资源
                 if (allowedAssetIds && !allowedAssetIds.has(assetId)) {
                     continue;

package/dist/loaders/playcanvas-loader.d.ts

@@ -1,8 +1,15 @@
+export interface ImportMapAsset {
+    id: string;
+    content: {
+        imports: Record<string, string>;
+    };
+}
 export interface PlayCanvasProject {
     project: any;
     scenes: any;
     assets: any;
     format: 'playcanvas';
+    importMap?: ImportMapAsset;
 }
 /**
  * 加载 PlayCanvas 源代码项目