@galacean/cli 0.0.1-alpha.7 → 0.0.1-alpha.8

package/dist/cli.bundle.cjs

@@ -1197,7 +1197,7 @@ var require_command = __commonJS({
     var EventEmitter3 = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
     var path16 = require("node:path");
-    var fs6 = require("node:fs");
+    var fs5 = require("node:fs");
     var process5 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2191,7 +2191,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs6.existsSync(executableFile)) return;
+        if (fs5.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2210,10 +2210,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path16.resolve(baseDir, baseName);
-          if (fs6.existsSync(localBin)) return localBin;
+          if (fs5.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path16.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs6.existsSync(`${localBin}${ext}`)
+            (ext) => fs5.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2225,7 +2225,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs6.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
@@ -3515,16 +3515,16 @@ var init_utils = __esm({
 // ../storage/src/manifest.ts
 function generateManifest(pathMap, contentHashes) {
   const entries = {};
-  for (const [assetId, entry] of pathMap) {
+  for (const [assetId, entry2] of pathMap) {
     entries[assetId] = {
       assetId,
-      name: entry.name,
-      path: entry.localPath,
-      type: entry.metaType,
+      name: entry2.name,
+      path: entry2.localPath,
+      type: entry2.metaType,
       contentHash: contentHashes.get(assetId) ?? "",
-      remoteVersion: entry.meta.version ?? "",
-      serverId: entry.serverId,
-      url: entry.url
+      remoteVersion: entry2.meta.version ?? "",
+      serverId: entry2.serverId,
+      url: entry2.url
     };
   }
   return { version: 1, entries };
@@ -3536,13 +3536,13 @@ var init_manifest = __esm({
 });
 
 // ../storage/src/meta-file.ts
-function generateMetaFile(entry) {
-  const { locked: _locked, id: _id, ...restMeta } = entry.meta;
+function generateMetaFile(entry2) {
+  const { locked: _locked, id: _id, ...restMeta } = entry2.meta;
   return {
     ...restMeta,
-    type: entry.metaType,
-    assetId: entry.assetId,
-    serverId: entry.serverId
+    type: entry2.metaType,
+    assetId: entry2.assetId,
+    serverId: entry2.serverId
   };
 }
 function metaFilePath(contentPath) {
@@ -4294,9 +4294,9 @@ async function resetNodeManagedProjectPaths(dirPath) {
     )
   );
 }
-async function assertDirectoryEmpty(fs6, dirPath) {
+async function assertDirectoryEmpty(fs5, dirPath) {
   try {
-    const entries = await fs6.readdir(dirPath);
+    const entries = await fs5.readdir(dirPath);
     if (entries.length > 0) {
       throw new Error(`Output directory is not empty: ${dirPath}. Use --force to continue.`);
     }
@@ -4304,8 +4304,8 @@ async function assertDirectoryEmpty(fs6, dirPath) {
     if (!isMissingPathError(err)) throw err;
   }
 }
-async function resetManagedProjectPaths(fs6, dirPath) {
-  await Promise.all(MANAGED_PROJECT_PATHS.map((managedPath) => fs6.remove(import_node_path3.default.join(dirPath, managedPath))));
+async function resetManagedProjectPaths(fs5, dirPath) {
+  await Promise.all(MANAGED_PROJECT_PATHS.map((managedPath) => fs5.remove(import_node_path3.default.join(dirPath, managedPath))));
 }
 async function readProjectConfig(projectDir) {
   return readJsonFile(import_node_path3.default.resolve(projectDir, "project.galacean"), "project config");
@@ -4319,9 +4319,9 @@ async function readNodeRemoteConfig(projectDir) {
   }
   return { projectId, serverUrl: typeof serverUrl === "string" ? serverUrl : "" };
 }
-async function readRemoteConfig(fs6, projectDir) {
+async function readRemoteConfig(fs5, projectDir) {
   const remotePath = import_node_path3.default.resolve(projectDir, ".galacean/remote.json");
-  const raw = decodeUtf8(await fs6.readFile(remotePath));
+  const raw = decodeUtf8(await fs5.readFile(remotePath));
   const parsed = safeParseJsonObject(raw);
   const projectId = parsed.projectId;
   const serverUrl = parsed.serverUrl;
@@ -4403,21 +4403,21 @@ var init_path_utils = __esm({
 });
 
 // ../storage/src/fs.ts
-async function atomicWriteFile(fs6, filePath, content) {
-  if (fs6.rename) {
+async function atomicWriteFile(fs5, filePath, content) {
+  if (fs5.rename) {
     const tmp = filePath + ".tmp";
-    await fs6.writeFile(tmp, content);
+    await fs5.writeFile(tmp, content);
     try {
-      await fs6.rename(tmp, filePath);
+      await fs5.rename(tmp, filePath);
     } catch (err) {
       try {
-        await fs6.remove(tmp);
+        await fs5.remove(tmp);
       } catch {
       }
       throw err;
     }
   } else {
-    await fs6.writeFile(filePath, content);
+    await fs5.writeFile(filePath, content);
   }
 }
 var init_fs = __esm({
@@ -43063,10 +43063,10 @@ void main () {
         }
       };
       _proto._emitByBurst = function _emitByBurst(lastPlayTime, playTime) {
-        var main = this._generator.main;
-        var duration3 = main.duration;
+        var main2 = this._generator.main;
+        var duration3 = main2.duration;
         var cycleCount = Math.floor((playTime - lastPlayTime) / duration3);
-        if (main.isLoop && (cycleCount > 0 || playTime % duration3 < lastPlayTime % duration3)) {
+        if (main2.isLoop && (cycleCount > 0 || playTime % duration3 < lastPlayTime % duration3)) {
           var middleTime = Math.ceil(lastPlayTime / duration3) * duration3;
           this._emitBySubBurst(lastPlayTime, middleTime, duration3);
           this._currentBurstIndex = 0;
@@ -44476,16 +44476,16 @@ void main () {
       _proto._emit = function _emit(playTime, count) {
         var emission = this.emission;
         if (emission.enabled) {
-          var main = this.main;
+          var main2 = this.main;
           var notRetireParticleCount = this._getNotRetiredParticleCount();
-          if (notRetireParticleCount >= main.maxParticles) {
+          if (notRetireParticleCount >= main2.maxParticles) {
             return;
           }
           var position = ParticleGenerator2._tempVector30;
           var direction = ParticleGenerator2._tempVector31;
           var transform2 = this._renderer.entity.transform;
           var shape = emission.shape;
-          var positionScale = main._getPositionScale();
+          var positionScale = main2._getPositionScale();
           for (var i = 0; i < count; i++) {
             if (shape == null ? void 0 : shape.enabled) {
               shape._generatePositionAndDirection(emission._shapeRand, playTime, position, direction);
@@ -44494,7 +44494,7 @@ void main () {
             } else {
               position.set(0, 0, 0);
               direction.set(0, 0, -1);
-              if (main.simulationSpace === ParticleSimulationSpace.Local) {
+              if (main2.simulationSpace === ParticleSimulationSpace.Local) {
                 direction.multiply(positionScale);
               }
             }
@@ -44504,10 +44504,10 @@ void main () {
       };
       _proto._update = function _update(elapsedTime) {
         var lastAlive = this.isAlive;
-        var _this = this, main = _this.main, emission = _this.emission;
-        var duration3 = main.duration;
+        var _this = this, main2 = _this.main, emission = _this.emission;
+        var duration3 = main2.duration;
         var lastPlayTime = this._playTime;
-        var deltaTime = elapsedTime * main.simulationSpeed;
+        var deltaTime = elapsedTime * main2.simulationSpeed;
         if (this._playStartDelay > 0) {
           var remainingDelay = this._playStartDelay -= deltaTime;
           if (remainingDelay < 0) {
@@ -44520,23 +44520,23 @@ void main () {
         this._playTime += deltaTime;
         this._retireActiveParticles();
         this._freeRetiredParticles();
-        if (main.simulationSpace === ParticleSimulationSpace.World) {
+        if (main2.simulationSpace === ParticleSimulationSpace.World) {
           this._retireTransformedBounds();
         }
         if (emission.enabled && this._isPlaying) {
-          if (this._currentParticleCount > main._maxParticleBuffer) {
+          if (this._currentParticleCount > main2._maxParticleBuffer) {
             var notRetireParticleCount = this._getNotRetiredParticleCount();
-            if (notRetireParticleCount < main._maxParticleBuffer) {
+            if (notRetireParticleCount < main2._maxParticleBuffer) {
               this._resizeInstanceBuffer(false);
             }
           }
           emission._emit(lastPlayTime, this._playTime);
-          if (!main.isLoop && this._playTime > duration3) {
+          if (!main2.isLoop && this._playTime > duration3) {
             this._isPlaying = false;
           }
         }
         if (this.isAlive) {
-          if (main.simulationSpace === ParticleSimulationSpace.World) {
+          if (main2.simulationSpace === ParticleSimulationSpace.World) {
             this._generateTransformedBounds();
           }
         } else {
@@ -44786,9 +44786,9 @@ void main () {
         if (nextFreeElement >= this._currentParticleCount) {
           nextFreeElement = 0;
         }
-        var main = this.main;
+        var main2 = this.main;
         if (nextFreeElement === this._firstRetiredElement) {
-          var increaseCount = Math.min(ParticleGenerator2._particleIncreaseCount, main._maxParticleBuffer - this._currentParticleCount);
+          var increaseCount = Math.min(ParticleGenerator2._particleIncreaseCount, main2._maxParticleBuffer - this._currentParticleCount);
           if (increaseCount === 0) {
             return;
           }
@@ -44796,42 +44796,42 @@ void main () {
           nextFreeElement = firstFreeElement + 1;
         }
         var pos, rot;
-        if (main.simulationSpace === ParticleSimulationSpace.World) {
+        if (main2.simulationSpace === ParticleSimulationSpace.World) {
           pos = transform2.worldPosition;
           rot = transform2.worldRotationQuaternion;
         }
-        var startSpeed = main.startSpeed.evaluate(void 0, main._startSpeedRand.random());
+        var startSpeed = main2.startSpeed.evaluate(void 0, main2._startSpeedRand.random());
         var instanceVertices = this._instanceVertices;
         var offset = firstFreeElement * ParticleBufferUtils.instanceVertexFloatStride;
         position.copyToArray(instanceVertices, offset);
-        instanceVertices[offset + ParticleBufferUtils.startLifeTimeOffset] = main.startLifetime.evaluate(void 0, main._startLifeTimeRand.random());
+        instanceVertices[offset + ParticleBufferUtils.startLifeTimeOffset] = main2.startLifetime.evaluate(void 0, main2._startLifeTimeRand.random());
         direction.copyToArray(instanceVertices, offset + 4);
         instanceVertices[offset + ParticleBufferUtils.timeOffset] = playTime;
         var startColor = ParticleGenerator2._tempColor0;
-        main.startColor.evaluate(void 0, main._startColorRand.random(), startColor);
+        main2.startColor.evaluate(void 0, main2._startColorRand.random(), startColor);
         startColor.copyToArray(instanceVertices, offset + 8);
         var duration3 = this.main.duration;
         var normalizedEmitAge = playTime % duration3 / duration3;
-        var startSizeRand = main._startSizeRand;
-        if (main.startSize3D) {
-          instanceVertices[offset + 12] = main.startSizeX.evaluate(normalizedEmitAge, startSizeRand.random());
-          instanceVertices[offset + 13] = main.startSizeY.evaluate(normalizedEmitAge, startSizeRand.random());
-          instanceVertices[offset + 14] = main.startSizeZ.evaluate(normalizedEmitAge, startSizeRand.random());
+        var startSizeRand = main2._startSizeRand;
+        if (main2.startSize3D) {
+          instanceVertices[offset + 12] = main2.startSizeX.evaluate(normalizedEmitAge, startSizeRand.random());
+          instanceVertices[offset + 13] = main2.startSizeY.evaluate(normalizedEmitAge, startSizeRand.random());
+          instanceVertices[offset + 14] = main2.startSizeZ.evaluate(normalizedEmitAge, startSizeRand.random());
         } else {
-          var size = main.startSize.evaluate(normalizedEmitAge, startSizeRand.random());
+          var size = main2.startSize.evaluate(normalizedEmitAge, startSizeRand.random());
           instanceVertices[offset + 12] = size;
           instanceVertices[offset + 13] = size;
           instanceVertices[offset + 14] = size;
         }
-        var startRotationRand = main._startRotationRand, flipRotation = main.flipRotation;
+        var startRotationRand = main2._startRotationRand, flipRotation = main2.flipRotation;
         var isFlip = flipRotation > startRotationRand.random();
         if (this._renderer.renderMode !== ParticleRenderMode.Mesh) {
           isFlip = !isFlip;
         }
-        var rotationZ = main.startRotationZ.evaluate(void 0, startRotationRand.random());
-        if (main.startRotation3D) {
-          var rotationX = main.startRotationX.evaluate(void 0, startRotationRand.random());
-          var rotationY = main.startRotationY.evaluate(void 0, startRotationRand.random());
+        var rotationZ = main2.startRotationZ.evaluate(void 0, startRotationRand.random());
+        if (main2.startRotation3D) {
+          var rotationX = main2.startRotationX.evaluate(void 0, startRotationRand.random());
+          var rotationY = main2.startRotationY.evaluate(void 0, startRotationRand.random());
           instanceVertices[offset + 15] = isFlip ? -rotationX : rotationX;
           instanceVertices[offset + 16] = isFlip ? -rotationY : rotationY;
           instanceVertices[offset + 17] = isFlip ? -rotationZ : rotationZ;
@@ -44839,12 +44839,12 @@ void main () {
           instanceVertices[offset + 15] = isFlip ? -rotationZ : rotationZ;
         }
         instanceVertices[offset + 18] = startSpeed;
-        switch (main.gravityModifier.mode) {
+        switch (main2.gravityModifier.mode) {
           case ParticleCurveMode.Constant:
-            instanceVertices[offset + 19] = main.gravityModifier.constant;
+            instanceVertices[offset + 19] = main2.gravityModifier.constant;
             break;
           case ParticleCurveMode.TwoConstants:
-            instanceVertices[offset + 19] = main.gravityModifier.evaluate(void 0, main._gravityModifierRand.random());
+            instanceVertices[offset + 19] = main2.gravityModifier.evaluate(void 0, main2._gravityModifierRand.random());
             break;
         }
         var colorOverLifetime = this.colorOverLifetime;
@@ -45000,7 +45000,7 @@ void main () {
       _proto._calculateGeneratorBounds = function _calculateGeneratorBounds(maxLifetime, bounds) {
         var directionMax = ParticleGenerator2._tempVector30, directionMin = ParticleGenerator2._tempVector31, speedMinMax = ParticleGenerator2._tempVector20;
         var min = bounds.min, max = bounds.max;
-        var main = this.main;
+        var main2 = this.main;
         var shape = this.emission.shape;
         if (shape == null ? void 0 : shape.enabled) {
           shape._getPositionRange(min, max);
@@ -45011,19 +45011,19 @@ void main () {
           directionMin.set(0, 0, -1);
           directionMax.set(0, 0, 0);
         }
-        this._getExtremeValueFromZero(main.startSpeed, speedMinMax);
+        this._getExtremeValueFromZero(main2.startSpeed, speedMinMax);
         var speedMin = speedMinMax.x, speedMax = speedMinMax.y;
         var dirMinX = directionMin.x, dirMinY = directionMin.y, dirMinZ = directionMin.z;
         var dirMaxX = directionMax.x, dirMaxY = directionMax.y, dirMaxZ = directionMax.z;
         min.set(min.x + Math.min(dirMinX * speedMax, dirMaxX * speedMin) * maxLifetime, min.y + Math.min(dirMinY * speedMax, dirMaxY * speedMin) * maxLifetime, min.z + Math.min(dirMinZ * speedMax, dirMaxZ * speedMin) * maxLifetime);
         max.set(max.x + Math.max(dirMinX * speedMin, dirMaxX * speedMax) * maxLifetime, max.y + Math.max(dirMinY * speedMin, dirMaxY * speedMax) * maxLifetime, max.z + Math.max(dirMinZ * speedMin, dirMaxZ * speedMax) * maxLifetime);
-        var maxSize = main.startSize._getMax();
-        if (main.startSize3D) {
-          var startSizeYMax = main.startSizeY._getMax();
+        var maxSize = main2.startSize._getMax();
+        if (main2.startSize3D) {
+          var startSizeYMax = main2.startSizeY._getMax();
           if (this._renderer.renderMode === ParticleRenderMode.Billboard || ParticleRenderMode.StretchBillboard || ParticleRenderMode.HorizontalBillboard) {
             maxSize = Math.max(maxSize, startSizeYMax);
           } else {
-            var startSizeZMax = main.startSizeZ._getMax();
+            var startSizeZMax = main2.startSizeZ._getMax();
             maxSize = Math.max(maxSize, startSizeYMax, startSizeZMax);
           }
         }
@@ -53009,13 +53009,13 @@ var require_main4 = __commonJS({
         });
       };
       _proto._getBufferData = function _getBufferData(buffers, restoreInfo) {
-        var main = restoreInfo.main;
+        var main2 = restoreInfo.main;
         var data;
-        if (main) {
-          var buffer2 = buffers[main.bufferIndex];
-          data = new main.TypedArray(buffer2, main.byteOffset, main.length);
+        if (main2) {
+          var buffer2 = buffers[main2.bufferIndex];
+          data = new main2.TypedArray(buffer2, main2.byteOffset, main2.length);
         } else {
-          data = new main.TypedArray(main.length);
+          data = new main2.TypedArray(main2.length);
         }
         var sparseCount = restoreInfo.sparseCount;
         if (sparseCount) {
@@ -53054,8 +53054,8 @@ var require_main4 = __commonJS({
       this.buffer = buffer2;
       this.data = data;
     };
-    var BufferDataRestoreInfo = function BufferDataRestoreInfo2(main, typeSize, sparseCount, sparseIndices, sparseValues) {
-      this.main = main;
+    var BufferDataRestoreInfo = function BufferDataRestoreInfo2(main2, typeSize, sparseCount, sparseIndices, sparseValues) {
+      this.main = main2;
       this.typeSize = typeSize;
       this.sparseCount = sparseCount;
       this.sparseIndices = sparseIndices;
@@ -84845,15 +84845,15 @@ var require_mobx_cjs_development = __commonJS({
         if (!globalState.trackingDerivation) {
           return this.has_(key);
         }
-        var entry = this.hasMap_.get(key);
-        if (!entry) {
-          var newEntry = entry = new ObservableValue(this.has_(key), referenceEnhancer, this.name_ + "." + stringifyKey(key) + "?", false);
+        var entry2 = this.hasMap_.get(key);
+        if (!entry2) {
+          var newEntry = entry2 = new ObservableValue(this.has_(key), referenceEnhancer, this.name_ + "." + stringifyKey(key) + "?", false);
           this.hasMap_.set(key, newEntry);
           onBecomeUnobserved(newEntry, function() {
             return _this2.hasMap_["delete"](key);
           });
         }
-        return entry.get();
+        return entry2.get();
       };
       _proto.set = function set3(key, value) {
         var hasKey = this.has_(key);
@@ -85549,12 +85549,12 @@ var require_mobx_cjs_development = __commonJS({
           return key in this.target_;
         }
         this.pendingKeys_ || (this.pendingKeys_ = /* @__PURE__ */ new Map());
-        var entry = this.pendingKeys_.get(key);
-        if (!entry) {
-          entry = new ObservableValue(key in this.target_, referenceEnhancer, this.name_ + "." + stringifyKey(key) + "?", false);
-          this.pendingKeys_.set(key, entry);
+        var entry2 = this.pendingKeys_.get(key);
+        if (!entry2) {
+          entry2 = new ObservableValue(key in this.target_, referenceEnhancer, this.name_ + "." + stringifyKey(key) + "?", false);
+          this.pendingKeys_.set(key, entry2);
         }
-        return entry.get();
+        return entry2.get();
       };
       _proto.make_ = function make_2(key, annotation) {
         if (annotation === true) {
@@ -88642,20 +88642,20 @@ var init_VanillaPackage = __esm({
         }, "");
         this._eta.configure({ functionHeader });
         const eta = this._eta;
-        const entry = eta.renderString(templates.entry, params);
-        const html = eta.renderString(templates.html, params);
+        const entry2 = eta.renderString(templates.entry, params);
+        const html2 = eta.renderString(templates.html, params);
         const mainEntry = eta.renderString(templates.main, params);
-        const scriptEntry = eta.renderString(templates.scriptEntry, params);
-        const packageJson = eta.renderString(templates.packageJson, params);
-        const viteConfig = eta.renderString(templates.viteConfig, params);
+        const scriptEntry2 = eta.renderString(templates.scriptEntry, params);
+        const packageJson2 = eta.renderString(templates.packageJson, params);
+        const viteConfig2 = eta.renderString(templates.viteConfig, params);
         const vfs = this._vfs;
-        vfs.getFileByPath("/src/index.ts").content = entry;
-        vfs.getFileByPath("/src/scripts/index.ts").content = scriptEntry;
-        vfs.getFileByPath("/package.json").content = JSON.stringify(JSON.parse(packageJson), null, 2);
-        vfs.getFileByPath("/index.html").content = html;
+        vfs.getFileByPath("/src/index.ts").content = entry2;
+        vfs.getFileByPath("/src/scripts/index.ts").content = scriptEntry2;
+        vfs.getFileByPath("/package.json").content = JSON.stringify(JSON.parse(packageJson2), null, 2);
+        vfs.getFileByPath("/index.html").content = html2;
         vfs.getFileByPath("/main.js").content = mainEntry;
         vfs.getFileByPath("/tsconfig.json").content = templates.tsconfig;
-        vfs.getFileByPath("/vite.config.ts").content = viteConfig;
+        vfs.getFileByPath("/vite.config.ts").content = viteConfig2;
       }
       /**
        * 写入文件到虚拟文件系统
@@ -88691,30 +88691,21 @@ function cliUploadFactory() {
   upload.download = true;
   return upload;
 }
-var import_promises8, import_node_path12, import_node_module, import_meta, require2, builderPkgPath, templateDir, CLIVanillaPackage;
+var import_index_ts, import_index_ts2, import_package_json, import_index_html, import_main_js, import_tsconfig_json, import_vite_config_ts, CLIVanillaPackage;
 var init_cli_vanilla_package = __esm({
   "src/cli-vanilla-package.ts"() {
     "use strict";
-    import_promises8 = __toESM(require("node:fs/promises"));
-    import_node_path12 = __toESM(require("node:path"));
-    import_node_module = require("node:module");
     init_VanillaPackage();
-    import_meta = {};
-    require2 = (0, import_node_module.createRequire)(typeof __filename !== "undefined" ? __filename : import_meta.url);
-    builderPkgPath = require2.resolve("@editor/builder/package.json");
-    templateDir = import_node_path12.default.join(import_node_path12.default.dirname(builderPkgPath), "templates/web");
+    import_index_ts = __toESM(require_index_ts());
+    import_index_ts2 = __toESM(require_index_ts2());
+    import_package_json = __toESM(require_package_json());
+    import_index_html = __toESM(require_index_html());
+    import_main_js = __toESM(require_main_js());
+    import_tsconfig_json = __toESM(require_tsconfig_json());
+    import_vite_config_ts = __toESM(require_vite_config_ts());
     CLIVanillaPackage = class extends VanillaPackage {
       async _loadTemplate() {
-        const [entry, scriptEntry, packageJson, html, main, tsconfig, viteConfig] = await Promise.all([
-          import_promises8.default.readFile(import_node_path12.default.join(templateDir, "src/index.ts.ejs"), "utf-8"),
-          import_promises8.default.readFile(import_node_path12.default.join(templateDir, "src/scripts/index.ts.ejs"), "utf-8"),
-          import_promises8.default.readFile(import_node_path12.default.join(templateDir, "package.json.ejs"), "utf-8"),
-          import_promises8.default.readFile(import_node_path12.default.join(templateDir, "index.html.ejs"), "utf-8"),
-          import_promises8.default.readFile(import_node_path12.default.join(templateDir, "main.js.ejs"), "utf-8"),
-          import_promises8.default.readFile(import_node_path12.default.join(templateDir, "tsconfig.json.ejs"), "utf-8"),
-          import_promises8.default.readFile(import_node_path12.default.join(templateDir, "vite.config.ts.ejs"), "utf-8")
-        ]);
-        return { entry, scriptEntry, packageJson, html, main, tsconfig, viteConfig };
+        return { entry: import_index_ts.default, scriptEntry: import_index_ts2.default, packageJson: import_package_json.default, html: import_index_html.default, main: import_main_js.default, tsconfig: import_tsconfig_json.default, viteConfig: import_vite_config_ts.default };
       }
       async _writeFiles(project, cacheMap, download = false) {
         const needWrittenLocally = download && !this._buildOptions.assetOptions.uploadCDN;
@@ -89271,9 +89262,9 @@ function toArrayBuffer(buffer2) {
 }
 function resolveBundledAssetPath(filename) {
   const candidates = [
-    (0, import_node_path13.join)(__dirname, "../assets", filename),
+    (0, import_node_path12.join)(__dirname, "../assets", filename),
     // dev: running from src/, assets at package root
-    (0, import_node_path13.join)(__dirname, "assets", filename)
+    (0, import_node_path12.join)(__dirname, "assets", filename)
     // prod: running from dist/, assets copied by build.mjs
   ];
   for (const candidate of candidates) {
@@ -89296,7 +89287,7 @@ async function loadBundledBasisAssets() {
     bundledBasisAssetsPromise = (async () => {
       const jsPath = resolveBundledAssetPath(BASIS_JS_FILENAME);
       const wasmPath = resolveBundledAssetPath(BASIS_WASM_FILENAME);
-      const [jsBuffer, wasmBuffer] = await Promise.all([(0, import_promises9.readFile)(jsPath), (0, import_promises9.readFile)(wasmPath)]);
+      const [jsBuffer, wasmBuffer] = await Promise.all([(0, import_promises8.readFile)(jsPath), (0, import_promises8.readFile)(wasmPath)]);
       assertChecksum(BASIS_JS_FILENAME, jsBuffer, BASIS_JS_SHA256);
       assertChecksum(BASIS_WASM_FILENAME, wasmBuffer, BASIS_WASM_SHA256);
       return { workerCode: buildWorkerCode(jsBuffer.toString("utf-8")), wasmBinary: toArrayBuffer(wasmBuffer) };
@@ -89364,15 +89355,15 @@ parentPort.on("message", async (msg) => {
 });
 `;
 }
-var import_node_worker_threads, import_node_crypto4, import_promises9, import_node_fs, import_node_path13, BASIS_JS_FILENAME, BASIS_WASM_FILENAME, BASIS_JS_SHA256, BASIS_WASM_SHA256, bundledBasisAssetsPromise, CLIKtx2Encoder;
+var import_node_worker_threads, import_node_crypto4, import_promises8, import_node_fs, import_node_path12, BASIS_JS_FILENAME, BASIS_WASM_FILENAME, BASIS_JS_SHA256, BASIS_WASM_SHA256, bundledBasisAssetsPromise, CLIKtx2Encoder;
 var init_cli_ktx2_encoder = __esm({
   "src/cli-ktx2-encoder.ts"() {
     "use strict";
     import_node_worker_threads = require("node:worker_threads");
     import_node_crypto4 = require("node:crypto");
-    import_promises9 = require("node:fs/promises");
+    import_promises8 = require("node:fs/promises");
     import_node_fs = require("node:fs");
-    import_node_path13 = require("node:path");
+    import_node_path12 = require("node:path");
     init_ktx_parse_modern();
     BASIS_JS_FILENAME = "basis_encoder.js";
     BASIS_WASM_FILENAME = "basis_encoder.wasm";
@@ -89598,11 +89589,11 @@ function createManifestEntryIndex(entries, options = {}) {
   const localPathRegistry = createLocalPathRegistry();
   const pathToId = /* @__PURE__ */ new Map();
   const folderIdByPath = /* @__PURE__ */ new Map();
-  for (const [assetId, entry] of Object.entries(entries)) {
-    const canonicalPath = assertCanonicalAssetPath(entry.path, `Manifest entry '${assetId}' path`);
+  for (const [assetId, entry2] of Object.entries(entries)) {
+    const canonicalPath = assertCanonicalAssetPath(entry2.path, `Manifest entry '${assetId}' path`);
     registerLocalPathOrThrow(localPathRegistry, assetId, canonicalPath, caseFold);
     pathToId.set(canonicalPath, assetId);
-    if (entry.type === "Folder") {
+    if (entry2.type === "Folder") {
       folderIdByPath.set(canonicalPath, assetId);
     }
   }
@@ -89729,8 +89720,8 @@ var init_sync_adapter = __esm({
 function extractMaterialProps(matData) {
   const props = {};
   if (matData.shaderData && typeof matData.shaderData === "object") {
-    for (const [key, entry] of Object.entries(matData.shaderData)) {
-      props[key] = entry.value !== void 0 ? entry.value : entry;
+    for (const [key, entry2] of Object.entries(matData.shaderData)) {
+      props[key] = entry2.value !== void 0 ? entry2.value : entry2;
     }
   } else {
     for (const [key, value] of Object.entries(matData)) {
@@ -89947,11 +89938,11 @@ function buildMaterialMainData(name, props, original) {
   const shaderData = Object.fromEntries(shaderDataEntries);
   if (original) {
     const originalShaderData = original.shaderData ?? {};
-    for (const [key, entry] of Object.entries(shaderData)) {
+    for (const [key, entry2] of Object.entries(shaderData)) {
       const orig = originalShaderData[key];
       if (orig && typeof orig === "object" && typeof orig.type === "string") {
         ;
-        entry.type = orig.type;
+        entry2.type = orig.type;
       }
     }
     const preservedOriginalEntries = Object.fromEntries(
@@ -90006,7 +89997,7 @@ var init_scene_parser = __esm({
 async function readLocalTextAsset(projectDir, entryPath, entryUrl, label) {
   if (isCdnUrl(entryUrl)) return null;
   try {
-    return await import_promises10.default.readFile(`${projectDir}/${entryPath}`, "utf-8");
+    return await import_promises9.default.readFile(`${projectDir}/${entryPath}`, "utf-8");
   } catch (error49) {
     if (isEnoent(error49)) return null;
     throw new Error(`[domain-bridge] failed to read ${label} ${entryPath}: ${errorMessage(error49)}`);
@@ -90020,7 +90011,7 @@ function parseJsonWithPath(text, filePath) {
   }
 }
 function resolveSceneAssetId(config2, manifest) {
-  const sceneAssetIds = Object.entries(manifest.entries).filter(([, entry]) => entry.type === "Scene").map(([assetId]) => assetId);
+  const sceneAssetIds = Object.entries(manifest.entries).filter(([, entry2]) => entry2.type === "Scene").map(([assetId]) => assetId);
   if (typeof config2.sceneId === "string" && config2.sceneId.length > 0) {
     const configuredEntry = manifest.entries[config2.sceneId];
     if (configuredEntry?.type === "Scene") {
@@ -90031,7 +90022,7 @@ function resolveSceneAssetId(config2, manifest) {
 }
 async function readRemoteProjectId(projectDir) {
   try {
-    const remoteText = await import_promises10.default.readFile(`${projectDir}/.galacean/remote.json`, "utf-8");
+    const remoteText = await import_promises9.default.readFile(`${projectDir}/.galacean/remote.json`, "utf-8");
     const remote = JSON.parse(remoteText);
     return typeof remote.projectId === "string" ? remote.projectId : "";
   } catch (error49) {
@@ -90040,10 +90031,10 @@ async function readRemoteProjectId(projectDir) {
   }
 }
 async function loadDomainState(projectDir) {
-  const configText = await import_promises10.default.readFile(`${projectDir}/project.galacean`, "utf-8");
+  const configText = await import_promises9.default.readFile(`${projectDir}/project.galacean`, "utf-8");
   const config2 = JSON.parse(configText);
   const remoteProjectId = await readRemoteProjectId(projectDir);
-  const manifestText = await import_promises10.default.readFile(`${projectDir}/.galacean/manifest.json`, "utf-8");
+  const manifestText = await import_promises9.default.readFile(`${projectDir}/.galacean/manifest.json`, "utf-8");
   const manifest = JSON.parse(manifestText);
   const sceneAssetId = resolveSceneAssetId(config2, manifest);
   if (sceneAssetId) {
@@ -90054,25 +90045,25 @@ async function loadDomainState(projectDir) {
   const rootEntityIds = [];
   let sceneSettings;
   const assetMeta = /* @__PURE__ */ new Map();
-  for (const [assetId, entry] of Object.entries(manifest.entries)) {
+  for (const [assetId, entry2] of Object.entries(manifest.entries)) {
     let meta3;
-    const inlineMeta = entry.meta;
+    const inlineMeta = entry2.meta;
     if (inlineMeta && typeof inlineMeta === "object") {
       meta3 = inlineMeta;
     } else {
-      const metaText = await import_promises10.default.readFile(`${projectDir}/${metaFilePath(entry.path)}`, "utf-8");
+      const metaText = await import_promises9.default.readFile(`${projectDir}/${metaFilePath(entry2.path)}`, "utf-8");
       meta3 = JSON.parse(metaText);
     }
-    const serverId = meta3.serverId || entry.serverId || `local-${assetId}`;
+    const serverId = meta3.serverId || entry2.serverId || `local-${assetId}`;
     assetMeta.set(assetId, { serverId, meta: meta3 });
-    const isFolder = entry.type === "Folder";
-    const parentId = findParentAssetId(entry.path, manifest.entries);
+    const isFolder = entry2.type === "Folder";
+    const parentId = findParentAssetId(entry2.path, manifest.entries);
     const assetState = {
       id: assetId,
-      name: assetNameFromPath(entry.path, entry.type),
-      type: entry.type,
+      name: assetNameFromPath(entry2.path, entry2.type),
+      type: entry2.type,
       parentFolderId: parentId,
-      url: entry.url || void 0,
+      url: entry2.url || void 0,
       meta: meta3,
       serverId,
       status: "ready"
@@ -90080,34 +90071,34 @@ async function loadDomainState(projectDir) {
     if (!isFolder) {
       if (assetId === sceneAssetId) {
         try {
-          const sceneText = await import_promises10.default.readFile(`${projectDir}/${entry.path}`, "utf-8");
+          const sceneText = await import_promises9.default.readFile(`${projectDir}/${entry2.path}`, "utf-8");
           const sceneFile = JSON.parse(sceneText);
           parseSceneEntities(sceneFile, entities, rootEntityIds);
           if (sceneFile.scene && typeof sceneFile.scene === "object") {
             sceneSettings = sceneFile.scene;
           }
         } catch (error49) {
-          throw new Error(`[domain-bridge] failed to parse scene file ${entry.path}: ${errorMessage(error49)}`);
+          throw new Error(`[domain-bridge] failed to parse scene file ${entry2.path}: ${errorMessage(error49)}`);
         }
-      } else if (entry.type === "script") {
-        const text = await readLocalTextAsset(projectDir, entry.path, entry.url, "script");
+      } else if (entry2.type === "script") {
+        const text = await readLocalTextAsset(projectDir, entry2.path, entry2.url, "script");
         if (text !== null) assetState.content = { code: text };
-      } else if (entry.type === "Prefab") {
-        const text = await readLocalTextAsset(projectDir, entry.path, entry.url, "prefab");
-        if (text !== null) assetState.content = parseJsonWithPath(text, entry.path);
-      } else if (entry.type === "Shader" || entry.type === "ShaderChunk") {
-        const text = await readLocalTextAsset(projectDir, entry.path, entry.url, entry.type.toLowerCase());
+      } else if (entry2.type === "Prefab") {
+        const text = await readLocalTextAsset(projectDir, entry2.path, entry2.url, "prefab");
+        if (text !== null) assetState.content = parseJsonWithPath(text, entry2.path);
+      } else if (entry2.type === "Shader" || entry2.type === "ShaderChunk") {
+        const text = await readLocalTextAsset(projectDir, entry2.path, entry2.url, entry2.type.toLowerCase());
         if (text !== null) assetState.content = { source: text };
-      } else if (entry.type === "Material") {
-        const text = await readLocalTextAsset(projectDir, entry.path, entry.url, "material");
+      } else if (entry2.type === "Material") {
+        const text = await readLocalTextAsset(projectDir, entry2.path, entry2.url, "material");
         if (text !== null) {
-          const matData = parseJsonWithPath(text, entry.path);
+          const matData = parseJsonWithPath(text, entry2.path);
           const props = extractMaterialProps(matData);
           if (Object.keys(props).length > 0) assetState.props = props;
           assetState.content = matData;
         }
-      } else if (isCdnUrl(entry.url)) {
-        assetState.url = entry.url;
+      } else if (isCdnUrl(entry2.url)) {
+        assetState.url = entry2.url;
       } else {
         assetState.url = "";
       }
@@ -90130,11 +90121,11 @@ async function loadDomainState(projectDir) {
     }
   };
 }
-var import_promises10;
+var import_promises9;
 var init_load = __esm({
   "src/domain-bridge/load.ts"() {
     "use strict";
-    import_promises10 = __toESM(require("node:fs/promises"));
+    import_promises9 = __toESM(require("node:fs/promises"));
     init_meta_file();
     init_sync_adapter();
     init_utils();
@@ -90145,7 +90136,7 @@ var init_load = __esm({
 // src/domain-bridge/save.ts
 async function isSameFileSystemEntry(pathA, pathB) {
   try {
-    const [a, b] = await Promise.all([import_promises11.default.stat(pathA), import_promises11.default.stat(pathB)]);
+    const [a, b] = await Promise.all([import_promises10.default.stat(pathA), import_promises10.default.stat(pathB)]);
     return a.dev === b.dev && a.ino === b.ino;
   } catch (error49) {
     if (isEnoent(error49)) return false;
@@ -90154,8 +90145,8 @@ async function isSameFileSystemEntry(pathA, pathB) {
 }
 async function atomicWriteNodeFs(filePath, content) {
   const tmp = filePath + ".tmp";
-  await import_promises11.default.writeFile(tmp, content);
-  await import_promises11.default.rename(tmp, filePath);
+  await import_promises10.default.writeFile(tmp, content);
+  await import_promises10.default.rename(tmp, filePath);
 }
 async function saveDomainState(projectDir, state, ctx) {
   let sceneJson;
@@ -90183,7 +90174,7 @@ async function saveDomainState(projectDir, state, ctx) {
   const newPathMap = buildLocalPathMap(remoteAssets);
   const useCaseFoldGuards = await shouldUseCaseFoldGuards(projectDir);
   if (useCaseFoldGuards) {
-    const pathCollisions = findCaseFoldPathCollisions(Array.from(newPathMap.values(), (entry) => entry.localPath));
+    const pathCollisions = findCaseFoldPathCollisions(Array.from(newPathMap.values(), (entry2) => entry2.localPath));
     if (pathCollisions.length > 0) {
       const preview = formatConflictPreview(pathCollisions.map((item) => `${item.firstPath} <-> ${item.secondPath}`));
       throw new Error(
@@ -90192,18 +90183,18 @@ async function saveDomainState(projectDir, state, ctx) {
     }
   }
   const contentHashes = /* @__PURE__ */ new Map();
-  const removedEntries = Object.entries(ctx.manifest.entries).filter(([assetId]) => !state.assets[assetId]).map(([, entry]) => entry);
-  for (const [, entry] of newPathMap) {
-    if (entry.isFolder) {
-      await import_promises11.default.mkdir(`${projectDir}/${entry.localPath}`, { recursive: true });
+  const removedEntries = Object.entries(ctx.manifest.entries).filter(([assetId]) => !state.assets[assetId]).map(([, entry2]) => entry2);
+  for (const [, entry2] of newPathMap) {
+    if (entry2.isFolder) {
+      await import_promises10.default.mkdir(`${projectDir}/${entry2.localPath}`, { recursive: true });
     }
   }
   const pendingFileMoves = [];
-  for (const [assetId, entry] of newPathMap) {
-    if (entry.isFolder) continue;
+  for (const [assetId, entry2] of newPathMap) {
+    if (entry2.isFolder) continue;
     const oldEntry = ctx.manifest.entries[assetId];
-    if (oldEntry && oldEntry.path !== entry.localPath) {
-      pendingFileMoves.push({ assetId, oldPath: oldEntry.path, newPath: entry.localPath });
+    if (oldEntry && oldEntry.path !== entry2.localPath) {
+      pendingFileMoves.push({ assetId, oldPath: oldEntry.path, newPath: entry2.localPath });
     }
   }
   if (useCaseFoldGuards) {
@@ -90227,12 +90218,12 @@ async function saveDomainState(projectDir, state, ctx) {
     }
     const tempPath = `${move.oldPath}.__tmp_move__${tempMoveIndex++}`;
     try {
-      await import_promises11.default.rename(`${projectDir}/${move.oldPath}`, `${projectDir}/${tempPath}`);
+      await import_promises10.default.rename(`${projectDir}/${move.oldPath}`, `${projectDir}/${tempPath}`);
     } catch (e) {
       if (!isEnoent(e)) throw e;
     }
     try {
-      await import_promises11.default.rename(`${projectDir}/${metaFilePath(move.oldPath)}`, `${projectDir}/${metaFilePath(tempPath)}`);
+      await import_promises10.default.rename(`${projectDir}/${metaFilePath(move.oldPath)}`, `${projectDir}/${metaFilePath(tempPath)}`);
     } catch (e) {
       if (!isEnoent(e)) throw e;
     }
@@ -90244,19 +90235,19 @@ async function saveDomainState(projectDir, state, ctx) {
       await atomicWriteNodeFs(`${projectDir}/${sceneNewEntry.localPath}`, sceneJson);
     }
   }
-  for (const [assetId, entry] of newPathMap) {
-    if (entry.isFolder) continue;
+  for (const [assetId, entry2] of newPathMap) {
+    if (entry2.isFolder) continue;
     if (assetId === ctx.sceneAssetId && sceneJson) {
       const oldEntry2 = ctx.manifest.entries[assetId];
-      if (oldEntry2 && oldEntry2.path !== entry.localPath) {
+      if (oldEntry2 && oldEntry2.path !== entry2.localPath) {
         const sourcePath = moveSourceByAssetId.get(assetId) ?? oldEntry2.path;
         try {
-          await import_promises11.default.unlink(`${projectDir}/${sourcePath}`);
+          await import_promises10.default.unlink(`${projectDir}/${sourcePath}`);
         } catch (e) {
           if (!isEnoent(e)) throw e;
         }
         try {
-          await import_promises11.default.unlink(`${projectDir}/${metaFilePath(sourcePath)}`);
+          await import_promises10.default.unlink(`${projectDir}/${metaFilePath(sourcePath)}`);
         } catch (e) {
           if (!isEnoent(e)) throw e;
         }
@@ -90267,31 +90258,31 @@ async function saveDomainState(projectDir, state, ctx) {
     const asset2 = state.assets[assetId];
     if (!asset2) continue;
     const oldEntry = ctx.manifest.entries[assetId];
-    const newPath = entry.localPath;
+    const newPath = entry2.localPath;
     let renameSourceMissing = false;
     if (oldEntry && oldEntry.path !== newPath) {
       const sourcePath = moveSourceByAssetId.get(assetId) ?? oldEntry.path;
       try {
-        await import_promises11.default.rename(`${projectDir}/${sourcePath}`, `${projectDir}/${newPath}`);
+        await import_promises10.default.rename(`${projectDir}/${sourcePath}`, `${projectDir}/${newPath}`);
       } catch (e) {
         if (!isEnoent(e)) throw e;
         renameSourceMissing = true;
       }
       try {
-        await import_promises11.default.rename(`${projectDir}/${metaFilePath(sourcePath)}`, `${projectDir}/${metaFilePath(newPath)}`);
+        await import_promises10.default.rename(`${projectDir}/${metaFilePath(sourcePath)}`, `${projectDir}/${metaFilePath(newPath)}`);
       } catch (e) {
         if (!isEnoent(e)) throw e;
       }
     }
     if (asset2.type === "script" && asset2.content) {
       const code = typeof asset2.content.code === "string" ? asset2.content.code : JSON.stringify(asset2.content);
-      await import_promises11.default.writeFile(`${projectDir}/${newPath}`, code);
+      await import_promises10.default.writeFile(`${projectDir}/${newPath}`, code);
       contentHashes.set(assetId, md5Text(code));
       continue;
     }
     if (asset2.type === "Prefab" && asset2.content) {
       const json2 = JSON.stringify(asset2.content);
-      await import_promises11.default.writeFile(`${projectDir}/${newPath}`, json2);
+      await import_promises10.default.writeFile(`${projectDir}/${newPath}`, json2);
       contentHashes.set(assetId, md5Text(json2));
       continue;
     }
@@ -90299,19 +90290,19 @@ async function saveDomainState(projectDir, state, ctx) {
       const json2 = JSON.stringify(
         buildMaterialMainData(asset2.name, asset2.props ?? {}, asset2.content)
       );
-      await import_promises11.default.writeFile(`${projectDir}/${newPath}`, json2);
+      await import_promises10.default.writeFile(`${projectDir}/${newPath}`, json2);
       contentHashes.set(assetId, md5Text(json2));
       continue;
     }
     if ((asset2.type === "Shader" || asset2.type === "ShaderChunk") && asset2.content != null) {
       const source = typeof asset2.content.source === "string" ? asset2.content.source : "";
-      await import_promises11.default.writeFile(`${projectDir}/${newPath}`, source);
+      await import_promises10.default.writeFile(`${projectDir}/${newPath}`, source);
       contentHashes.set(assetId, md5Text(source));
       continue;
     }
     if (asset2.content != null) {
       const text = JSON.stringify(asset2.content);
-      await import_promises11.default.writeFile(`${projectDir}/${newPath}`, text);
+      await import_promises10.default.writeFile(`${projectDir}/${newPath}`, text);
       contentHashes.set(assetId, md5Text(text));
       continue;
     }
@@ -90325,7 +90316,7 @@ async function saveDomainState(projectDir, state, ctx) {
         throw new Error(`[saveDomainState] Invalid data URL for asset '${assetId}': missing base64 payload`);
       }
       const buf = Buffer.from(base643, "base64");
-      await import_promises11.default.writeFile(`${projectDir}/${newPath}`, buf);
+      await import_promises10.default.writeFile(`${projectDir}/${newPath}`, buf);
       contentHashes.set(assetId, md5Buffer(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)));
       continue;
     }
@@ -90339,28 +90330,28 @@ async function saveDomainState(projectDir, state, ctx) {
     }
   }
   const newFolderPathKeys = /* @__PURE__ */ new Set();
-  for (const [, entry] of newPathMap) {
-    if (entry.isFolder) newFolderPathKeys.add(pathCompareKey(entry.localPath, useCaseFoldGuards));
+  for (const [, entry2] of newPathMap) {
+    if (entry2.isFolder) newFolderPathKeys.add(pathCompareKey(entry2.localPath, useCaseFoldGuards));
   }
-  for (const [assetId, entry] of newPathMap) {
-    if (!entry.isFolder) continue;
+  for (const [assetId, entry2] of newPathMap) {
+    if (!entry2.isFolder) continue;
     const oldEntry = ctx.manifest.entries[assetId];
     const oldPathReusedAsTarget = oldEntry ? newFolderPathKeys.has(pathCompareKey(oldEntry.path, useCaseFoldGuards)) : false;
-    if (oldEntry && oldEntry.path !== entry.localPath) {
+    if (oldEntry && oldEntry.path !== entry2.localPath) {
       const oldFolderPath = `${projectDir}/${oldEntry.path}`;
-      const newFolderPath = `${projectDir}/${entry.localPath}`;
-      if (isCaseOnlyPathChange(oldEntry.path, entry.localPath) && await isSameFileSystemEntry(oldFolderPath, newFolderPath)) {
-        await import_promises11.default.rename(oldFolderPath, newFolderPath);
+      const newFolderPath = `${projectDir}/${entry2.localPath}`;
+      if (isCaseOnlyPathChange(oldEntry.path, entry2.localPath) && await isSameFileSystemEntry(oldFolderPath, newFolderPath)) {
+        await import_promises10.default.rename(oldFolderPath, newFolderPath);
         continue;
       }
       if (!oldPathReusedAsTarget) {
         try {
-          await import_promises11.default.unlink(`${projectDir}/${metaFilePath(oldEntry.path)}`);
+          await import_promises10.default.unlink(`${projectDir}/${metaFilePath(oldEntry.path)}`);
         } catch (e) {
           if (!isEnoent(e)) throw e;
         }
         try {
-          await import_promises11.default.rm(`${projectDir}/${oldEntry.path}`, { recursive: true, force: true });
+          await import_promises10.default.rm(`${projectDir}/${oldEntry.path}`, { recursive: true, force: true });
         } catch (e) {
           if (!isEnoent(e)) throw e;
         }
@@ -90368,28 +90359,28 @@ async function saveDomainState(projectDir, state, ctx) {
     }
   }
   const newPathKeys = new Set(
-    Array.from(newPathMap.values(), (entry) => pathCompareKey(entry.localPath, useCaseFoldGuards))
+    Array.from(newPathMap.values(), (entry2) => pathCompareKey(entry2.localPath, useCaseFoldGuards))
   );
   const removedOrdered = [
-    ...removedEntries.filter((entry) => entry.type !== "Folder"),
-    ...removedEntries.filter((entry) => entry.type === "Folder").sort((a, b) => b.path.split("/").length - a.path.split("/").length)
+    ...removedEntries.filter((entry2) => entry2.type !== "Folder"),
+    ...removedEntries.filter((entry2) => entry2.type === "Folder").sort((a, b) => b.path.split("/").length - a.path.split("/").length)
   ];
-  for (const entry of removedOrdered) {
-    if (newPathKeys.has(pathCompareKey(entry.path, useCaseFoldGuards))) continue;
+  for (const entry2 of removedOrdered) {
+    if (newPathKeys.has(pathCompareKey(entry2.path, useCaseFoldGuards))) continue;
     try {
-      await import_promises11.default.unlink(`${projectDir}/${metaFilePath(entry.path)}`);
+      await import_promises10.default.unlink(`${projectDir}/${metaFilePath(entry2.path)}`);
     } catch (e) {
       if (!isEnoent(e)) throw e;
     }
     try {
-      await import_promises11.default.rm(`${projectDir}/${entry.path}`, { recursive: true, force: true });
+      await import_promises10.default.rm(`${projectDir}/${entry2.path}`, { recursive: true, force: true });
     } catch (e) {
       if (!isEnoent(e)) throw e;
     }
   }
   const manifestPath = `${projectDir}/.galacean/manifest.json`;
   try {
-    const diskManifestText = await import_promises11.default.readFile(manifestPath, "utf-8");
+    const diskManifestText = await import_promises10.default.readFile(manifestPath, "utf-8");
     const diskManifest = JSON.parse(diskManifestText);
     if (diskManifest.entries) {
       for (const [assetId, diskEntry] of Object.entries(diskManifest.entries)) {
@@ -90403,20 +90394,20 @@ async function saveDomainState(projectDir, state, ctx) {
     console.warn("[saveDomainState] Failed to read existing manifest for serverId merge:", err);
   }
   await Promise.all(
-    [...newPathMap.values()].map((entry) => {
-      const meta3 = generateMetaFile(entry);
-      return import_promises11.default.writeFile(`${projectDir}/${metaFilePath(entry.localPath)}`, JSON.stringify(meta3, null, 2));
+    [...newPathMap.values()].map((entry2) => {
+      const meta3 = generateMetaFile(entry2);
+      return import_promises10.default.writeFile(`${projectDir}/${metaFilePath(entry2.localPath)}`, JSON.stringify(meta3, null, 2));
     })
   );
   const newManifest = generateManifest(newPathMap, contentHashes);
   await atomicWriteNodeFs(manifestPath, JSON.stringify(newManifest, null, 2));
   await atomicWriteNodeFs(`${projectDir}/project.galacean`, JSON.stringify(ctx.config, null, 2));
 }
-var import_promises11;
+var import_promises10;
 var init_save = __esm({
   "src/domain-bridge/save.ts"() {
     "use strict";
-    import_promises11 = __toESM(require("node:fs/promises"));
+    import_promises10 = __toESM(require("node:fs/promises"));
     init_hash();
     init_manifest();
     init_meta_file();
@@ -90517,12 +90508,12 @@ function toBlobArrayBuffer(bytes) {
   return copy2.buffer;
 }
 function normalizePathForComparison(filePath) {
-  const normalized = import_node_path14.default.resolve(filePath);
+  const normalized = import_node_path13.default.resolve(filePath);
   return process.platform === "linux" ? normalized : normalized.toLowerCase();
 }
 function isSameOrNestedPath(targetPath, basePath) {
-  const relative5 = import_node_path14.default.relative(basePath, targetPath);
-  return relative5 === "" || !relative5.startsWith("..") && !import_node_path14.default.isAbsolute(relative5);
+  const relative5 = import_node_path13.default.relative(basePath, targetPath);
+  return relative5 === "" || !relative5.startsWith("..") && !import_node_path13.default.isAbsolute(relative5);
 }
 function assertSafeBuildOutputDir(projectDir, outputDir) {
   const normalizedProjectDir = normalizePathForComparison(projectDir);
@@ -90533,7 +90524,7 @@ function assertSafeBuildOutputDir(projectDir, outputDir) {
     );
   }
   for (const managedPath of MANAGED_PROJECT_PATHS) {
-    const normalizedManagedPath = normalizePathForComparison(import_node_path14.default.join(projectDir, managedPath));
+    const normalizedManagedPath = normalizePathForComparison(import_node_path13.default.join(projectDir, managedPath));
     const overlapsManagedPath = managedPath === "project.galacean" ? normalizedOutputDir === normalizedManagedPath : isSameOrNestedPath(normalizedOutputDir, normalizedManagedPath);
     if (overlapsManagedPath) {
       throw new Error(
@@ -90543,8 +90534,8 @@ function assertSafeBuildOutputDir(projectDir, outputDir) {
   }
 }
 async function buildProject(options) {
-  const projectDir = import_node_path14.default.resolve(options.projectDir);
-  const outputDir = import_node_path14.default.resolve(options.output);
+  const projectDir = import_node_path13.default.resolve(options.projectDir);
+  const outputDir = import_node_path13.default.resolve(options.output);
   assertSafeBuildOutputDir(projectDir, outputDir);
   console.log("Reading project...");
   const { state, ctx } = await loadDomainState(projectDir);
@@ -90602,13 +90593,13 @@ function buildProjectAssets(manifest, projectDir) {
   for (const [id, e] of Object.entries(entries)) {
     if (e.type === "Folder") folderPathToId.set(e.path, id);
   }
-  for (const [assetId, entry] of Object.entries(entries)) {
+  for (const [assetId, entry2] of Object.entries(entries)) {
     let meta3;
-    const inlineMeta = entry.meta;
+    const inlineMeta = entry2.meta;
     if (inlineMeta && typeof inlineMeta === "object") {
       meta3 = inlineMeta;
     } else {
-      const metaPath = import_node_path14.default.join(projectDir, metaFilePath(entry.path));
+      const metaPath = import_node_path13.default.join(projectDir, metaFilePath(entry2.path));
       let metaText;
       try {
         metaText = import_node_fs2.default.readFileSync(metaPath, "utf-8");
@@ -90616,7 +90607,7 @@ function buildProjectAssets(manifest, projectDir) {
         console.warn(`[buildProjectAssets] Failed to read meta file: ${metaPath}`, e);
         skippedAssets.push({
           assetId,
-          path: entry.path,
+          path: entry2.path,
           reason: `failed to read meta file: ${e instanceof Error ? e.message : String(e)}`
         });
         continue;
@@ -90627,28 +90618,28 @@ function buildProjectAssets(manifest, projectDir) {
         console.warn(`[buildProjectAssets] Failed to parse meta JSON: ${metaPath}`, e);
         skippedAssets.push({
           assetId,
-          path: entry.path,
+          path: entry2.path,
           reason: `failed to parse meta JSON: ${e instanceof Error ? e.message : String(e)}`
         });
         continue;
       }
     }
     metaMap.set(assetId, meta3);
-    const parts = entry.path.split("/");
+    const parts = entry2.path.split("/");
     const fileName = parts[parts.length - 1];
-    const ext = TYPE_EXTENSION[entry.type];
+    const ext = TYPE_EXTENSION[entry2.type];
     const name = ext && fileName.endsWith(ext) ? fileName.slice(0, -ext.length) : fileName;
     let parentId = null;
     if (parts.length > 2) {
       parentId = folderPathToId.get(parts.slice(0, -1).join("/")) ?? null;
     }
-    const isFolder = entry.type === "Folder";
-    const filePath = import_node_path14.default.join(projectDir, entry.path);
+    const isFolder = entry2.type === "Folder";
+    const filePath = import_node_path13.default.join(projectDir, entry2.path);
     const fileUrl = !isFolder && import_node_fs2.default.existsSync(filePath) ? `file://${filePath}` : (
       // Non-http URLs are treated as local/non-materialized inputs and will be validated later in compile.
-      !isFolder && isHttpUrl(entry.url) ? entry.url : isFolder ? "" : `file://${filePath}`
+      !isFolder && isHttpUrl(entry2.url) ? entry2.url : isFolder ? "" : `file://${filePath}`
     );
-    const serverId = typeof meta3.serverId === "string" && meta3.serverId.length > 0 ? meta3.serverId : typeof entry.serverId === "string" && entry.serverId.length > 0 ? entry.serverId : `local-${assetId}`;
+    const serverId = typeof meta3.serverId === "string" && meta3.serverId.length > 0 ? meta3.serverId : typeof entry2.serverId === "string" && entry2.serverId.length > 0 ? entry2.serverId : `local-${assetId}`;
     assets.push({
       id: serverId,
       uuid: assetId,
@@ -90698,7 +90689,7 @@ async function cliCompile(vfs, config2, options) {
     if (url2?.startsWith("file://")) {
       const filePath = url2.slice(7);
       try {
-        const buf = await import_promises12.default.readFile(filePath);
+        const buf = await import_promises11.default.readFile(filePath);
         content = TEXT_ASSET_TYPES.has(type) ? buf.toString("utf-8") : new Blob([buf]);
       } catch (e) {
         console.warn(`[cliCompile] Failed to read asset file: ${filePath}`, e);
@@ -90873,33 +90864,33 @@ function createSkippedAssetsError(skippedAssets) {
 ${details}`);
 }
 async function writeOutputToDisk(vfs, outputDir) {
-  await import_promises12.default.rm(outputDir, { recursive: true, force: true });
-  await import_promises12.default.mkdir(outputDir, { recursive: true });
+  await import_promises11.default.rm(outputDir, { recursive: true, force: true });
+  await import_promises11.default.mkdir(outputDir, { recursive: true });
   const writes = [];
   for (const [vfsPath, vfile] of vfs.filePathMap) {
     if (vfile.type === "Folder" || vfile.type === 1) continue;
     const content = vfile.content;
     if (content == null) continue;
-    const outputPath = import_node_path14.default.join(outputDir, vfsPath);
+    const outputPath = import_node_path13.default.join(outputDir, vfsPath);
     writes.push(
-      import_promises12.default.mkdir(import_node_path14.default.dirname(outputPath), { recursive: true }).then(async () => {
+      import_promises11.default.mkdir(import_node_path13.default.dirname(outputPath), { recursive: true }).then(async () => {
         if (content instanceof Blob) {
-          await import_promises12.default.writeFile(outputPath, Buffer.from(await content.arrayBuffer()));
+          await import_promises11.default.writeFile(outputPath, Buffer.from(await content.arrayBuffer()));
         } else {
-          await import_promises12.default.writeFile(outputPath, content, "utf-8");
+          await import_promises11.default.writeFile(outputPath, content, "utf-8");
         }
       })
     );
   }
   await Promise.all(writes);
 }
-var import_promises12, import_node_fs2, import_node_path14, import_js_md52;
+var import_promises11, import_node_fs2, import_node_path13, import_js_md52;
 var init_cli_builder = __esm({
   "src/cli-builder.ts"() {
     "use strict";
-    import_promises12 = __toESM(require("node:fs/promises"));
+    import_promises11 = __toESM(require("node:fs/promises"));
     import_node_fs2 = __toESM(require("node:fs"));
-    import_node_path14 = __toESM(require("node:path"));
+    import_node_path13 = __toESM(require("node:path"));
     import_js_md52 = __toESM(require_md52());
     init_src();
     init_meta_file();
@@ -101820,42 +101811,42 @@ function extractDefs(ctx, schema) {
   if (!root2)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
-  for (const entry of ctx.seen.entries()) {
-    const id = ctx.metadataRegistry.get(entry[0])?.id;
+  for (const entry2 of ctx.seen.entries()) {
+    const id = ctx.metadataRegistry.get(entry2[0])?.id;
     if (id) {
       const existing = idToSchema.get(id);
-      if (existing && existing !== entry[0]) {
+      if (existing && existing !== entry2[0]) {
         throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
       }
-      idToSchema.set(id, entry[0]);
+      idToSchema.set(id, entry2[0]);
     }
   }
-  const makeURI = (entry) => {
+  const makeURI = (entry2) => {
     const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
     if (ctx.external) {
-      const externalId = ctx.external.registry.get(entry[0])?.id;
+      const externalId = ctx.external.registry.get(entry2[0])?.id;
       const uriGenerator = ctx.external.uri ?? ((id2) => id2);
       if (externalId) {
         return { ref: uriGenerator(externalId) };
       }
-      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
-      entry[1].defId = id;
+      const id = entry2[1].defId ?? entry2[1].schema.id ?? `schema${ctx.counter++}`;
+      entry2[1].defId = id;
       return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
     }
-    if (entry[1] === root2) {
+    if (entry2[1] === root2) {
       return { ref: "#" };
     }
     const uriPrefix = `#`;
     const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
-    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+    const defId = entry2[1].schema.id ?? `__schema${ctx.counter++}`;
     return { defId, ref: defUriPrefix + defId };
   };
-  const extractToDef = (entry) => {
-    if (entry[1].schema.$ref) {
+  const extractToDef = (entry2) => {
+    if (entry2[1].schema.$ref) {
       return;
     }
-    const seen = entry[1];
-    const { ref, defId } = makeURI(entry);
+    const seen = entry2[1];
+    const { ref, defId } = makeURI(entry2);
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
@@ -101866,8 +101857,8 @@ function extractDefs(ctx, schema) {
     schema2.$ref = ref;
   };
   if (ctx.cycles === "throw") {
-    for (const entry of ctx.seen.entries()) {
-      const seen = entry[1];
+    for (const entry2 of ctx.seen.entries()) {
+      const seen = entry2[1];
       if (seen.cycle) {
         throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
 
@@ -101875,31 +101866,31 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
   }
-  for (const entry of ctx.seen.entries()) {
-    const seen = entry[1];
-    if (schema === entry[0]) {
-      extractToDef(entry);
+  for (const entry2 of ctx.seen.entries()) {
+    const seen = entry2[1];
+    if (schema === entry2[0]) {
+      extractToDef(entry2);
       continue;
     }
     if (ctx.external) {
-      const ext = ctx.external.registry.get(entry[0])?.id;
-      if (schema !== entry[0] && ext) {
-        extractToDef(entry);
+      const ext = ctx.external.registry.get(entry2[0])?.id;
+      if (schema !== entry2[0] && ext) {
+        extractToDef(entry2);
         continue;
       }
     }
-    const id = ctx.metadataRegistry.get(entry[0])?.id;
+    const id = ctx.metadataRegistry.get(entry2[0])?.id;
     if (id) {
-      extractToDef(entry);
+      extractToDef(entry2);
       continue;
     }
     if (seen.cycle) {
-      extractToDef(entry);
+      extractToDef(entry2);
       continue;
     }
     if (seen.count > 1) {
       if (ctx.reused === "ref") {
-        extractToDef(entry);
+        extractToDef(entry2);
         continue;
       }
     }
@@ -101971,8 +101962,8 @@ function finalize(ctx, schema) {
       path: seen.path ?? []
     });
   };
-  for (const entry of [...ctx.seen.entries()].reverse()) {
-    flattenRef(entry[0]);
+  for (const entry2 of [...ctx.seen.entries()].reverse()) {
+    flattenRef(entry2[0]);
   }
   const result = {};
   if (ctx.target === "draft-2020-12") {
@@ -101992,8 +101983,8 @@ function finalize(ctx, schema) {
   }
   Object.assign(result, root2.def ?? root2.schema);
   const defs = ctx.external?.defs ?? {};
-  for (const entry of ctx.seen.entries()) {
-    const seen = entry[1];
+  for (const entry2 of ctx.seen.entries()) {
+    const seen = entry2[1];
     if (seen.def && seen.defId) {
       defs[seen.defId] = seen.def;
     }
@@ -102103,8 +102094,8 @@ function toJSONSchema(input, params) {
     const registry2 = input;
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
-    for (const entry of registry2._idmap.entries()) {
-      const [_24, schema] = entry;
+    for (const entry2 of registry2._idmap.entries()) {
+      const [_24, schema] = entry2;
       process3(schema, ctx2);
     }
     const schemas = {};
@@ -102114,8 +102105,8 @@ function toJSONSchema(input, params) {
       defs
     };
     ctx2.external = external;
-    for (const entry of registry2._idmap.entries()) {
-      const [key, schema] = entry;
+    for (const entry2 of registry2._idmap.entries()) {
+      const [key, schema] = entry2;
       extractDefs(ctx2, schema);
       schemas[key] = finalize(ctx2, schema);
     }
@@ -117574,16 +117565,16 @@ var require_BufferList = __commonJS({
         this.length = 0;
       }
       BufferList.prototype.push = function push(v) {
-        var entry = { data: v, next: null };
-        if (this.length > 0) this.tail.next = entry;
-        else this.head = entry;
-        this.tail = entry;
+        var entry2 = { data: v, next: null };
+        if (this.length > 0) this.tail.next = entry2;
+        else this.head = entry2;
+        this.tail = entry2;
         ++this.length;
       };
       BufferList.prototype.unshift = function unshift(v) {
-        var entry = { data: v, next: this.head };
-        if (this.length === 0) this.tail = entry;
-        this.head = entry;
+        var entry2 = { data: v, next: this.head };
+        if (this.length === 0) this.tail = entry2;
+        this.head = entry2;
         ++this.length;
       };
       BufferList.prototype.shift = function shift() {
@@ -118001,18 +117992,18 @@ var require_stream_writable = __commonJS({
     }
     function clearBuffer(stream, state) {
       state.bufferProcessing = true;
-      var entry = state.bufferedRequest;
-      if (stream._writev && entry && entry.next) {
+      var entry2 = state.bufferedRequest;
+      if (stream._writev && entry2 && entry2.next) {
         var l = state.bufferedRequestCount;
         var buffer2 = new Array(l);
         var holder = state.corkedRequestsFree;
-        holder.entry = entry;
+        holder.entry = entry2;
         var count = 0;
         var allBuffers = true;
-        while (entry) {
-          buffer2[count] = entry;
-          if (!entry.isBuf) allBuffers = false;
-          entry = entry.next;
+        while (entry2) {
+          buffer2[count] = entry2;
+          if (!entry2.isBuf) allBuffers = false;
+          entry2 = entry2.next;
           count += 1;
         }
         buffer2.allBuffers = allBuffers;
@@ -118027,21 +118018,21 @@ var require_stream_writable = __commonJS({
         }
         state.bufferedRequestCount = 0;
       } else {
-        while (entry) {
-          var chunk = entry.chunk;
-          var encoding = entry.encoding;
-          var cb = entry.callback;
+        while (entry2) {
+          var chunk = entry2.chunk;
+          var encoding = entry2.encoding;
+          var cb = entry2.callback;
           var len = state.objectMode ? 1 : chunk.length;
           doWrite(stream, state, false, len, chunk, encoding, cb);
-          entry = entry.next;
+          entry2 = entry2.next;
           state.bufferedRequestCount--;
           if (state.writing) {
             break;
           }
         }
-        if (entry === null) state.lastBufferedRequest = null;
+        if (entry2 === null) state.lastBufferedRequest = null;
       }
-      state.bufferedRequest = entry;
+      state.bufferedRequest = entry2;
       state.bufferProcessing = false;
     }
     Writable.prototype._write = function(chunk, encoding, cb) {
@@ -118113,13 +118104,13 @@ var require_stream_writable = __commonJS({
       stream.writable = false;
     }
     function onCorkedFinish(corkReq, state, err) {
-      var entry = corkReq.entry;
+      var entry2 = corkReq.entry;
       corkReq.entry = null;
-      while (entry) {
-        var cb = entry.callback;
+      while (entry2) {
+        var cb = entry2.callback;
         state.pendingcb--;
         cb(err);
-        entry = entry.next;
+        entry2 = entry2.next;
       }
       state.corkedRequestsFree.next = corkReq;
     }
@@ -125962,9 +125953,9 @@ var require_object = __commonJS({
        */
       filter: function(search) {
         var result = [];
-        this.forEach(function(relativePath2, entry) {
-          if (search(relativePath2, entry)) {
-            result.push(entry);
+        this.forEach(function(relativePath2, entry2) {
+          if (search(relativePath2, entry2)) {
+            result.push(entry2);
           }
         });
         return result;
@@ -127005,24 +126996,24 @@ var init_import = __esm({
           const manifest = parseResult.data;
           const isCdnMode = manifest.mode === "cdn";
           const files = /* @__PURE__ */ new Map();
-          for (const entry of manifest.assets) {
-            const metaFile = zip.file(entry.metaFile);
+          for (const entry2 of manifest.assets) {
+            const metaFile = zip.file(entry2.metaFile);
             if (!metaFile) {
-              throw new EditorAPIError("OPERATION_FAILED", `Missing metadata for asset: ${entry.name} (${entry.metaFile})`);
+              throw new EditorAPIError("OPERATION_FAILED", `Missing metadata for asset: ${entry2.name} (${entry2.metaFile})`);
             }
             const meta3 = JSON.parse(await metaFile.async("text"));
             if (isCdnMode) {
-              files.set(entry.uuid, { main: new Blob([]), meta: meta3 });
+              files.set(entry2.uuid, { main: new Blob([]), meta: meta3 });
             } else {
-              const mainFile = zip.file(entry.mainFile);
+              const mainFile = zip.file(entry2.mainFile);
               if (!mainFile) {
                 throw new EditorAPIError(
                   "OPERATION_FAILED",
-                  `Missing main file for asset: ${entry.name} (${entry.mainFile})`
+                  `Missing main file for asset: ${entry2.name} (${entry2.mainFile})`
                 );
               }
-              const main = await mainFile.async("blob");
-              files.set(entry.uuid, { main, meta: meta3 });
+              const main2 = await mainFile.async("blob");
+              files.set(entry2.uuid, { main: main2, meta: meta3 });
             }
           }
           const result = await assetFacade.importResourcePackageData(manifest, files, {
@@ -129827,9 +129818,9 @@ var init_ContextQuery = __esm({
           }
           return null;
         }
-        const entry = Object.entries(entity.components).find(([, c]) => types.includes(c.type));
-        if (!entry) return null;
-        return deepClone2({ id: entry[0], ...entry[1] });
+        const entry2 = Object.entries(entity.components).find(([, c]) => types.includes(c.type));
+        if (!entry2) return null;
+        return deepClone2({ id: entry2[0], ...entry2[1] });
       }
       /**
        * 收集实体及其所有后代 ID（含自身），迭代实现。
@@ -130104,7 +130095,7 @@ var init_EditorCoreAPI = __esm({
 
 // src/cli.ts
 var import_node_os2 = __toESM(require("node:os"));
-var import_node_path18 = __toESM(require("node:path"));
+var import_node_path17 = __toESM(require("node:path"));
 var import_node_process2 = __toESM(require("node:process"));
 
 // node_modules/commander/esm.mjs
@@ -130142,7 +130133,7 @@ var NodeFs = class {
   }
   async readdir(p) {
     const entries = await (0, import_promises.readdir)(p, { withFileTypes: true });
-    return entries.map((entry) => ({ name: entry.name, kind: entry.isDirectory() ? "directory" : "file" }));
+    return entries.map((entry2) => ({ name: entry2.name, kind: entry2.isDirectory() ? "directory" : "file" }));
   }
   async remove(p) {
     await (0, import_promises.rm)(p, { recursive: true, force: true });
@@ -130714,23 +130705,23 @@ init_hash();
 
 // ../storage/src/project-writer.ts
 init_meta_file();
-async function writeProject(fs6, root2, opts) {
+async function writeProject(fs5, root2, opts) {
   const { pathMap, manifest, remoteConfig, projectConfig, metaFiles, contents } = opts;
-  await fs6.mkdir(`${root2}/.galacean`);
-  await fs6.mkdir(`${root2}/.galacean/cache`);
-  await fs6.writeFile(`${root2}/.galacean/manifest.json`, JSON.stringify(manifest, null, 2));
-  await fs6.writeFile(`${root2}/.galacean/remote.json`, JSON.stringify(remoteConfig, null, 2));
-  await fs6.writeFile(`${root2}/project.galacean`, JSON.stringify(projectConfig, null, 2));
-  for (const [, entry] of pathMap) {
-    if (entry.isFolder) await fs6.mkdir(`${root2}/${entry.localPath}`);
-  }
-  for (const [assetId, entry] of pathMap) {
-    if (!entry.isFolder) {
+  await fs5.mkdir(`${root2}/.galacean`);
+  await fs5.mkdir(`${root2}/.galacean/cache`);
+  await fs5.writeFile(`${root2}/.galacean/manifest.json`, JSON.stringify(manifest, null, 2));
+  await fs5.writeFile(`${root2}/.galacean/remote.json`, JSON.stringify(remoteConfig, null, 2));
+  await fs5.writeFile(`${root2}/project.galacean`, JSON.stringify(projectConfig, null, 2));
+  for (const [, entry2] of pathMap) {
+    if (entry2.isFolder) await fs5.mkdir(`${root2}/${entry2.localPath}`);
+  }
+  for (const [assetId, entry2] of pathMap) {
+    if (!entry2.isFolder) {
       const content = contents.get(assetId);
-      if (content) await fs6.writeFile(`${root2}/${entry.localPath}`, content);
+      if (content) await fs5.writeFile(`${root2}/${entry2.localPath}`, content);
     }
     const meta3 = metaFiles.get(assetId);
-    if (meta3) await fs6.writeFile(`${root2}/${metaFilePath(entry.localPath)}`, JSON.stringify(meta3, null, 2));
+    if (meta3) await fs5.writeFile(`${root2}/${metaFilePath(entry2.localPath)}`, JSON.stringify(meta3, null, 2));
   }
 }
 
@@ -130738,9 +130729,9 @@ async function writeProject(fs6, root2, opts) {
 init_local_project();
 init_utils();
 async function initProject(opts) {
-  const { projectId, outputDir, apiClient, fs: fs6, serverUrl = "", force = false } = opts;
+  const { projectId, outputDir, apiClient, fs: fs5, serverUrl = "", force = false } = opts;
   if (!force) {
-    await assertDirectoryEmpty(fs6, outputDir);
+    await assertDirectoryEmpty(fs5, outputDir);
   }
   const project = await apiClient.fetchProject(projectId);
   let sceneId = "";
@@ -130781,13 +130772,13 @@ async function initProject(opts) {
   }
   const manifest = generateManifest(pathMap, hashes);
   const metaFiles = /* @__PURE__ */ new Map();
-  for (const [id, entry] of pathMap) {
-    metaFiles.set(id, generateMetaFile(entry));
+  for (const [id, entry2] of pathMap) {
+    metaFiles.set(id, generateMetaFile(entry2));
   }
   if (force) {
-    await resetManagedProjectPaths(fs6, outputDir);
+    await resetManagedProjectPaths(fs5, outputDir);
   }
-  await writeProject(fs6, outputDir, {
+  await writeProject(fs5, outputDir, {
     pathMap,
     manifest,
     remoteConfig: { projectId, serverUrl },
@@ -130813,9 +130804,9 @@ init_local_project();
 init_path_case_guard();
 init_utils();
 var CONCURRENCY_LIMIT = 5;
-async function readManifest2(fs6, projectDir) {
+async function readManifest2(fs5, projectDir) {
   const manifestPath = import_node_path5.default.resolve(projectDir, ".galacean/manifest.json");
-  const raw = decodeUtf8(await fs6.readFile(manifestPath));
+  const raw = decodeUtf8(await fs5.readFile(manifestPath));
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -130833,16 +130824,16 @@ function isPathUnderFolder(assetPath, folderPath) {
   return normalizedAsset === normalizedFolder || normalizedAsset.startsWith(`${normalizedFolder}/`);
 }
 async function pullProject(opts) {
-  const { projectDir, apiClient, fs: fs6, signal, caseFoldGuards } = opts;
+  const { projectDir, apiClient, fs: fs5, signal, caseFoldGuards } = opts;
   throwIfAborted(signal);
-  const remote = await readRemoteConfig(fs6, projectDir);
-  const manifest = await readManifest2(fs6, projectDir);
+  const remote = await readRemoteConfig(fs5, projectDir);
+  const manifest = await readManifest2(fs5, projectDir);
   throwIfAborted(signal);
   const project = await apiClient.fetchProject(remote.projectId, { signal });
   const newPathMap = buildLocalPathMap(project.assets);
   const useCaseFoldGuards = caseFoldGuards ?? await shouldUseCaseFoldGuards(projectDir);
   if (useCaseFoldGuards) {
-    const pathCollisions = findCaseFoldPathCollisions(Array.from(newPathMap.values(), (entry) => entry.localPath));
+    const pathCollisions = findCaseFoldPathCollisions(Array.from(newPathMap.values(), (entry2) => entry2.localPath));
     if (pathCollisions.length > 0) {
       const preview = formatConflictPreview(pathCollisions.map((item) => `${item.firstPath} <-> ${item.secondPath}`));
       throw new Error(
@@ -130850,10 +130841,10 @@ async function pullProject(opts) {
       );
     }
   }
-  for (const [, entry] of newPathMap) {
-    if (!entry.isFolder && entry.url?.startsWith("data:")) {
+  for (const [, entry2] of newPathMap) {
+    if (!entry2.isFolder && entry2.url?.startsWith("data:")) {
       throw new Error(
-        `[pull] Unexpected data: URL for asset '${entry.assetId}' (path: ${entry.localPath}). Server should return http(s) URLs; data: URLs indicate a server-side issue.`
+        `[pull] Unexpected data: URL for asset '${entry2.assetId}' (path: ${entry2.localPath}). Server should return http(s) URLs; data: URLs indicate a server-side issue.`
       );
     }
   }
@@ -130909,12 +130900,12 @@ async function pullProject(opts) {
   const foldersToDelete = toDelete.filter((e) => e.type === "Folder").sort((a, b) => b.path.split("/").length - a.path.split("/").length);
   for (const local of filesToDelete) {
     try {
-      await fs6.remove(import_node_path5.default.resolve(projectDir, local.path));
+      await fs5.remove(import_node_path5.default.resolve(projectDir, local.path));
     } catch (err) {
       if (!isEnoent(err)) throw err;
     }
     try {
-      await fs6.remove(import_node_path5.default.resolve(projectDir, metaFilePath(local.path)));
+      await fs5.remove(import_node_path5.default.resolve(projectDir, metaFilePath(local.path)));
     } catch (err) {
       if (!isEnoent(err)) throw err;
     }
@@ -130922,14 +130913,14 @@ async function pullProject(opts) {
   }
   const movedResult = [];
   const pullWarnings = [];
-  const fileMoves = toMove.filter(({ entry }) => !entry.isFolder);
-  const folderMoves = toMove.filter(({ entry }) => entry.isFolder);
+  const fileMoves = toMove.filter(({ entry: entry2 }) => !entry2.isFolder);
+  const folderMoves = toMove.filter(({ entry: entry2 }) => entry2.isFolder);
   if (useCaseFoldGuards) {
     const moveConflicts = findCaseFoldMoveConflicts(
-      fileMoves.map(({ entry, oldPath }) => ({
-        assetId: entry.assetId,
+      fileMoves.map(({ entry: entry2, oldPath }) => ({
+        assetId: entry2.assetId,
         oldPath,
-        newPath: entry.localPath
+        newPath: entry2.localPath
       }))
     );
     if (moveConflicts.length > 0) {
@@ -130941,22 +130932,22 @@ async function pullProject(opts) {
   }
   const preparedFileMoves = [];
   const skippedFileMoveSourcePathSet = /* @__PURE__ */ new Set();
-  for (const { entry, oldPath } of fileMoves) {
+  for (const { entry: entry2, oldPath } of fileMoves) {
     const oldAbs = import_node_path5.default.resolve(projectDir, oldPath);
-    const newAbs = import_node_path5.default.resolve(projectDir, entry.localPath);
+    const newAbs = import_node_path5.default.resolve(projectDir, entry2.localPath);
     const isCaseOnlyRename = oldAbs.toLowerCase() === newAbs.toLowerCase() && oldAbs !== newAbs;
     let content;
     try {
-      content = await fs6.readFile(oldAbs);
+      content = await fs5.readFile(oldAbs);
     } catch (err) {
-      const warnMsg = `Skip move for ${oldPath} -> ${entry.localPath}: failed to read source file`;
+      const warnMsg = `Skip move for ${oldPath} -> ${entry2.localPath}: failed to read source file`;
       console.warn(`[pull] ${warnMsg}`, err);
       pullWarnings.push(warnMsg);
       skippedFileMoveSourcePathSet.add(normalizePath(oldPath));
       continue;
     }
     preparedFileMoves.push({
-      entry,
+      entry: entry2,
       oldPath,
       oldAbs,
       newAbs,
@@ -130977,41 +130968,41 @@ async function pullProject(opts) {
     }
     return !blockedByFolder;
   });
-  const activeFileMoveTargetPathSet = new Set(activeFileMoves.map(({ entry }) => normalizePath(entry.localPath)));
+  const activeFileMoveTargetPathSet = new Set(activeFileMoves.map(({ entry: entry2 }) => normalizePath(entry2.localPath)));
   for (const move of activeFileMoves) {
-    const { entry, oldPath, oldAbs, newAbs, isCaseOnlyRename, content } = move;
+    const { entry: entry2, oldPath, oldAbs, newAbs, isCaseOnlyRename, content } = move;
     const parentDir = import_node_path5.default.dirname(newAbs);
     try {
-      await fs6.mkdir(parentDir);
+      await fs5.mkdir(parentDir);
     } catch {
     }
     if (isCaseOnlyRename) {
       try {
-        await fs6.remove(oldAbs);
+        await fs5.remove(oldAbs);
       } catch (err) {
         if (!isEnoent(err)) throw err;
       }
       try {
-        await fs6.remove(oldAbs + ".meta.json");
+        await fs5.remove(oldAbs + ".meta.json");
       } catch (err) {
         if (!isEnoent(err)) throw err;
       }
     }
-    await fs6.writeFile(newAbs, content);
-    await fs6.writeFile(newAbs + ".meta.json", JSON.stringify(generateMetaFile(entry), null, 2));
-    manifest.entries[entry.assetId] = {
-      assetId: entry.assetId,
-      path: entry.localPath,
-      type: entry.metaType,
-      contentHash: manifest.entries[entry.assetId]?.contentHash ?? "",
-      remoteVersion: entry.meta.version ?? "",
-      serverId: entry.serverId,
-      url: entry.url
+    await fs5.writeFile(newAbs, content);
+    await fs5.writeFile(newAbs + ".meta.json", JSON.stringify(generateMetaFile(entry2), null, 2));
+    manifest.entries[entry2.assetId] = {
+      assetId: entry2.assetId,
+      path: entry2.localPath,
+      type: entry2.metaType,
+      contentHash: manifest.entries[entry2.assetId]?.contentHash ?? "",
+      remoteVersion: entry2.meta.version ?? "",
+      serverId: entry2.serverId,
+      url: entry2.url
     };
     movedResult.push({
-      assetId: entry.assetId,
+      assetId: entry2.assetId,
       oldPath,
-      path: entry.localPath
+      path: entry2.localPath
     });
   }
   for (const move of activeFileMoves) {
@@ -131021,142 +131012,142 @@ async function pullProject(opts) {
       continue;
     }
     try {
-      await fs6.remove(oldAbs);
+      await fs5.remove(oldAbs);
     } catch (err) {
       if (!isEnoent(err)) throw err;
     }
     try {
-      await fs6.remove(oldAbs + ".meta.json");
+      await fs5.remove(oldAbs + ".meta.json");
     } catch (err) {
       if (!isEnoent(err)) throw err;
     }
   }
   const activeFolderMoveTargetPathSet = new Set(
-    folderMoves.filter(({ oldPath }) => !blockedFolderMoveOldPathSet.has(normalizePath(oldPath))).map(({ entry }) => pathCompareKey(entry.localPath, useCaseFoldGuards))
+    folderMoves.filter(({ oldPath }) => !blockedFolderMoveOldPathSet.has(normalizePath(oldPath))).map(({ entry: entry2 }) => pathCompareKey(entry2.localPath, useCaseFoldGuards))
   );
-  for (const { entry, oldPath } of folderMoves) {
+  for (const { entry: entry2, oldPath } of folderMoves) {
     const normalizedOldPath = normalizePath(oldPath);
     if (blockedFolderMoveOldPathSet.has(normalizedOldPath)) {
-      console.warn(`[pull] Skip folder move for ${oldPath} -> ${entry.localPath}: child file move source read failed`);
+      console.warn(`[pull] Skip folder move for ${oldPath} -> ${entry2.localPath}: child file move source read failed`);
       continue;
     }
     const oldAbs = import_node_path5.default.resolve(projectDir, oldPath);
-    const newAbs = import_node_path5.default.resolve(projectDir, entry.localPath);
+    const newAbs = import_node_path5.default.resolve(projectDir, entry2.localPath);
     const isCaseOnlyRename = oldAbs.toLowerCase() === newAbs.toLowerCase() && oldAbs !== newAbs;
     const oldPathReusedAsMoveTarget = activeFolderMoveTargetPathSet.has(pathCompareKey(oldPath, useCaseFoldGuards));
     if (isCaseOnlyRename && useCaseFoldGuards) {
-      if (fs6.rename) {
-        await fs6.rename(oldAbs, newAbs);
+      if (fs5.rename) {
+        await fs5.rename(oldAbs, newAbs);
       }
       try {
-        await fs6.remove(oldAbs + ".meta.json");
+        await fs5.remove(oldAbs + ".meta.json");
       } catch (err) {
         if (!isEnoent(err)) throw err;
       }
     } else {
       try {
-        await fs6.mkdir(newAbs);
+        await fs5.mkdir(newAbs);
       } catch {
       }
       if (!oldPathReusedAsMoveTarget) {
         try {
-          await fs6.remove(oldAbs);
+          await fs5.remove(oldAbs);
         } catch (err) {
           if (!isEnoent(err)) throw err;
         }
         try {
-          await fs6.remove(oldAbs + ".meta.json");
+          await fs5.remove(oldAbs + ".meta.json");
         } catch (err) {
           if (!isEnoent(err)) throw err;
         }
       }
     }
-    await fs6.writeFile(newAbs + ".meta.json", JSON.stringify(generateMetaFile(entry), null, 2));
-    manifest.entries[entry.assetId] = {
-      assetId: entry.assetId,
-      path: entry.localPath,
-      type: entry.metaType,
-      contentHash: manifest.entries[entry.assetId]?.contentHash ?? "",
-      remoteVersion: entry.meta.version ?? "",
-      serverId: entry.serverId,
-      url: entry.url
+    await fs5.writeFile(newAbs + ".meta.json", JSON.stringify(generateMetaFile(entry2), null, 2));
+    manifest.entries[entry2.assetId] = {
+      assetId: entry2.assetId,
+      path: entry2.localPath,
+      type: entry2.metaType,
+      contentHash: manifest.entries[entry2.assetId]?.contentHash ?? "",
+      remoteVersion: entry2.meta.version ?? "",
+      serverId: entry2.serverId,
+      url: entry2.url
     };
     movedResult.push({
-      assetId: entry.assetId,
+      assetId: entry2.assetId,
       oldPath,
-      path: entry.localPath
+      path: entry2.localPath
     });
   }
   for (const local of foldersToDelete) {
     try {
-      await fs6.remove(import_node_path5.default.resolve(projectDir, local.path));
+      await fs5.remove(import_node_path5.default.resolve(projectDir, local.path));
     } catch (err) {
       if (!isEnoent(err)) throw err;
     }
     try {
-      await fs6.remove(import_node_path5.default.resolve(projectDir, metaFilePath(local.path)));
+      await fs5.remove(import_node_path5.default.resolve(projectDir, metaFilePath(local.path)));
     } catch (err) {
       if (!isEnoent(err)) throw err;
     }
     delete manifest.entries[local.assetId];
   }
   const addedFolders = toAdd.filter((e) => e.isFolder).sort((a, b) => a.localPath.split("/").length - b.localPath.split("/").length);
-  for (const entry of addedFolders) {
-    await fs6.mkdir(import_node_path5.default.resolve(projectDir, entry.localPath));
-    await fs6.writeFile(
-      import_node_path5.default.resolve(projectDir, entry.localPath) + ".meta.json",
-      JSON.stringify(generateMetaFile(entry), null, 2)
+  for (const entry2 of addedFolders) {
+    await fs5.mkdir(import_node_path5.default.resolve(projectDir, entry2.localPath));
+    await fs5.writeFile(
+      import_node_path5.default.resolve(projectDir, entry2.localPath) + ".meta.json",
+      JSON.stringify(generateMetaFile(entry2), null, 2)
     );
-    manifest.entries[entry.assetId] = {
-      assetId: entry.assetId,
-      path: entry.localPath,
-      type: entry.metaType,
+    manifest.entries[entry2.assetId] = {
+      assetId: entry2.assetId,
+      path: entry2.localPath,
+      type: entry2.metaType,
       contentHash: "",
-      remoteVersion: entry.meta.version ?? "",
-      serverId: entry.serverId,
-      url: entry.url
+      remoteVersion: entry2.meta.version ?? "",
+      serverId: entry2.serverId,
+      url: entry2.url
     };
   }
   const addedResult = [];
-  for (const entry of toAdd.filter((e) => !e.isFolder)) {
-    const abs = import_node_path5.default.resolve(projectDir, entry.localPath);
-    const content = downloadedContent.get(entry.assetId);
-    if (content !== void 0) await fs6.writeFile(abs, content);
-    await fs6.writeFile(abs + ".meta.json", JSON.stringify(generateMetaFile(entry), null, 2));
-    manifest.entries[entry.assetId] = {
-      assetId: entry.assetId,
-      path: entry.localPath,
-      type: entry.metaType,
-      contentHash: downloadedHash.get(entry.assetId) ?? "",
-      remoteVersion: entry.meta.version ?? "",
-      serverId: entry.serverId,
-      url: entry.url
-    };
-    addedResult.push({ assetId: entry.assetId, path: entry.localPath });
+  for (const entry2 of toAdd.filter((e) => !e.isFolder)) {
+    const abs = import_node_path5.default.resolve(projectDir, entry2.localPath);
+    const content = downloadedContent.get(entry2.assetId);
+    if (content !== void 0) await fs5.writeFile(abs, content);
+    await fs5.writeFile(abs + ".meta.json", JSON.stringify(generateMetaFile(entry2), null, 2));
+    manifest.entries[entry2.assetId] = {
+      assetId: entry2.assetId,
+      path: entry2.localPath,
+      type: entry2.metaType,
+      contentHash: downloadedHash.get(entry2.assetId) ?? "",
+      remoteVersion: entry2.meta.version ?? "",
+      serverId: entry2.serverId,
+      url: entry2.url
+    };
+    addedResult.push({ assetId: entry2.assetId, path: entry2.localPath });
   }
   const updatedResult = [];
-  for (const entry of toUpdate) {
-    const abs = import_node_path5.default.resolve(projectDir, entry.localPath);
-    const content = downloadedContent.get(entry.assetId);
-    if (content !== void 0) await fs6.writeFile(abs, content);
-    await fs6.writeFile(abs + ".meta.json", JSON.stringify(generateMetaFile(entry), null, 2));
-    manifest.entries[entry.assetId] = {
-      ...manifest.entries[entry.assetId],
-      contentHash: downloadedHash.get(entry.assetId) ?? manifest.entries[entry.assetId]?.contentHash ?? "",
-      remoteVersion: entry.meta.version ?? "",
-      serverId: entry.serverId,
-      url: entry.url
-    };
-    updatedResult.push({ assetId: entry.assetId, path: entry.localPath });
-  }
-  await atomicWriteFile(fs6, import_node_path5.default.resolve(projectDir, ".galacean/manifest.json"), JSON.stringify(manifest, null, 2));
+  for (const entry2 of toUpdate) {
+    const abs = import_node_path5.default.resolve(projectDir, entry2.localPath);
+    const content = downloadedContent.get(entry2.assetId);
+    if (content !== void 0) await fs5.writeFile(abs, content);
+    await fs5.writeFile(abs + ".meta.json", JSON.stringify(generateMetaFile(entry2), null, 2));
+    manifest.entries[entry2.assetId] = {
+      ...manifest.entries[entry2.assetId],
+      contentHash: downloadedHash.get(entry2.assetId) ?? manifest.entries[entry2.assetId]?.contentHash ?? "",
+      remoteVersion: entry2.meta.version ?? "",
+      serverId: entry2.serverId,
+      url: entry2.url
+    };
+    updatedResult.push({ assetId: entry2.assetId, path: entry2.localPath });
+  }
+  await atomicWriteFile(fs5, import_node_path5.default.resolve(projectDir, ".galacean/manifest.json"), JSON.stringify(manifest, null, 2));
   let sceneId = "";
   if (project.content && typeof project.content === "object") {
     sceneId = project.content.scene ?? "";
   }
   const dependencies = extractProjectDependencies(project, "pull");
   await atomicWriteFile(
-    fs6,
+    fs5,
     import_node_path5.default.resolve(projectDir, "project.galacean"),
     JSON.stringify(
       {
@@ -131764,7 +131755,7 @@ function areStringRecordEqual(a, b) {
 }
 function resolveProjectSceneId(projectConfig, manifest) {
   const configuredSceneId = typeof projectConfig.sceneId === "string" ? projectConfig.sceneId : "";
-  const sceneAssetIds = Object.entries(manifest.entries).filter(([, entry]) => entry.type === "Scene").map(([assetId]) => assetId);
+  const sceneAssetIds = Object.entries(manifest.entries).filter(([, entry2]) => entry2.type === "Scene").map(([assetId]) => assetId);
   if (configuredSceneId) {
     if (manifest.entries[configuredSceneId]?.type === "Scene") return configuredSceneId;
     if (Object.keys(manifest.entries).length === 0) return configuredSceneId;
@@ -131789,33 +131780,33 @@ function isPathInsideFolder(childPath, folderPath) {
   const normalizedFolder = folderPath.replaceAll("\\", "/").replace(/\/+$/, "");
   return normalizedChild.startsWith(`${normalizedFolder}/`);
 }
-function shouldTreatMissingLocalFileAsDelete(entry) {
-  if (!entry.serverId || entry.serverId.startsWith("local-")) return true;
-  if (entry.contentHash) return true;
-  if (typeof entry.url === "string" && entry.url.length > 0) return false;
+function shouldTreatMissingLocalFileAsDelete(entry2) {
+  if (!entry2.serverId || entry2.serverId.startsWith("local-")) return true;
+  if (entry2.contentHash) return true;
+  if (typeof entry2.url === "string" && entry2.url.length > 0) return false;
   return true;
 }
 function hasMaterializedDescendant(manifestEntries, folderPath) {
-  for (const entry of Object.values(manifestEntries)) {
-    if (!isPathInsideFolder(entry.path, folderPath)) continue;
-    if (entry.contentHash) return true;
+  for (const entry2 of Object.values(manifestEntries)) {
+    if (!isPathInsideFolder(entry2.path, folderPath)) continue;
+    if (entry2.contentHash) return true;
   }
   return false;
 }
 function hasRemoteOnlyDescendant(manifestEntries, folderPath) {
-  for (const entry of Object.values(manifestEntries)) {
-    if (entry.type === "Folder") continue;
-    if (!isPathInsideFolder(entry.path, folderPath)) continue;
-    if (!shouldTreatMissingLocalFileAsDelete(entry)) return true;
+  for (const entry2 of Object.values(manifestEntries)) {
+    if (entry2.type === "Folder") continue;
+    if (!isPathInsideFolder(entry2.path, folderPath)) continue;
+    if (!shouldTreatMissingLocalFileAsDelete(entry2)) return true;
   }
   return false;
 }
 
 // src/commands/push/io.ts
-async function assertNoCaseOnlyPathCoexistence(fs6, projectDir, manifestEntries, localDirs, localFiles, manifestEntryByPath) {
+async function assertNoCaseOnlyPathCoexistence(fs5, projectDir, manifestEntries, localDirs, localFiles, manifestEntryByPath) {
   const manifestByLowerPath = /* @__PURE__ */ new Map();
-  for (const [assetId, entry] of Object.entries(manifestEntries)) {
-    const normalizedPath = normalizePath(entry.path);
+  for (const [assetId, entry2] of Object.entries(manifestEntries)) {
+    const normalizedPath = normalizePath(entry2.path);
     const lowerPath = normalizePathLower(normalizedPath);
     const existing = manifestByLowerPath.get(lowerPath);
     if (existing && existing.assetId !== assetId && existing.path !== normalizedPath) {
@@ -131823,7 +131814,7 @@ async function assertNoCaseOnlyPathCoexistence(fs6, projectDir, manifestEntries,
         `[push] Manifest has case-colliding paths: '${existing.path}' and '${normalizedPath}'. Keep only one path and retry.`
       );
     }
-    manifestByLowerPath.set(lowerPath, { assetId, path: normalizedPath, type: entry.type });
+    manifestByLowerPath.set(lowerPath, { assetId, path: normalizedPath, type: entry2.type });
   }
   const localDirSet = new Set(localDirs.map((p) => normalizePath(p)));
   const localFileSet = new Set(localFiles.map((p) => normalizePath(p)));
@@ -131847,7 +131838,7 @@ async function assertNoCaseOnlyPathCoexistence(fs6, projectDir, manifestEntries,
       continue;
     }
     if (localFileSet.has(localPath) && matched.type !== "Folder" && !localFileSet.has(matched.path)) {
-      const localMeta = await readMetaFileIfExists(fs6, import_node_path7.default.resolve(projectDir, localPath)) ?? {};
+      const localMeta = await readMetaFileIfExists(fs5, import_node_path7.default.resolve(projectDir, localPath)) ?? {};
       const persistedId = resolvePersistedId(localMeta);
       if (persistedId && persistedId === matched.assetId) {
         continue;
@@ -131858,10 +131849,10 @@ async function assertNoCaseOnlyPathCoexistence(fs6, projectDir, manifestEntries,
     );
   }
 }
-async function readEngineVersion(fs6, projectDir) {
+async function readEngineVersion(fs5, projectDir) {
   const projectPath = import_node_path7.default.resolve(projectDir, "project.galacean");
   try {
-    const raw = decodeUtf8(await fs6.readFile(projectPath));
+    const raw = decodeUtf8(await fs5.readFile(projectPath));
     const parsed = parseJsonObjectOrThrow(raw, projectPath);
     const engineVersion = parsed.engineVersion;
     return typeof engineVersion === "string" && engineVersion.length > 0 ? engineVersion : void 0;
@@ -131870,17 +131861,17 @@ async function readEngineVersion(fs6, projectDir) {
     throw error49;
   }
 }
-async function readProjectConfig2(fs6, projectDir) {
+async function readProjectConfig2(fs5, projectDir) {
   const projectPath = import_node_path7.default.resolve(projectDir, "project.galacean");
   try {
-    const raw = decodeUtf8(await fs6.readFile(projectPath));
+    const raw = decodeUtf8(await fs5.readFile(projectPath));
     return parseJsonObjectOrThrow(raw, projectPath);
   } catch (error49) {
     if (isEnoent(error49)) return {};
     throw error49;
   }
 }
-async function autoCreateRemoteProject(fs6, projectDir, opts, projectConfig, resolvedSceneId) {
+async function autoCreateRemoteProject(fs5, projectDir, opts, projectConfig, resolvedSceneId) {
   const { serverUrl, apiClient } = opts;
   if (!serverUrl || !apiClient) {
     throw new Error("No remote.json found. To auto-create, provide --serverUrl and --token.");
@@ -131909,7 +131900,7 @@ async function autoCreateRemoteProject(fs6, projectDir, opts, projectConfig, res
   const remoteConfig = { projectId, serverUrl };
   throwIfAborted(opts.signal);
   const remotePath = import_node_path7.default.resolve(projectDir, ".galacean/remote.json");
-  await fs6.writeFile(remotePath, JSON.stringify(remoteConfig, null, 2));
+  await fs5.writeFile(remotePath, JSON.stringify(remoteConfig, null, 2));
   return remoteConfig;
 }
 async function syncRemoteProjectMetadata(apiClient, projectId, localConfig, resolvedSceneId, remoteProject, signal) {
@@ -131936,31 +131927,31 @@ async function syncRemoteProjectMetadata(apiClient, projectId, localConfig, reso
     await apiClient.updateProjectSchema(projectId, { scene: localSceneId }, { signal });
   }
 }
-async function listFilesAndDirs(fs6, root2) {
+async function listFilesAndDirs(fs5, root2) {
   const files = [];
   const dirs = [];
   const stack = [root2];
   while (stack.length) {
     const current = stack.pop();
-    const entries = await fs6.readdir(current);
-    for (const entry of entries) {
-      if (isIgnoredLocalEntryName(entry.name)) continue;
-      const fullPath = import_node_path7.default.join(current, entry.name);
-      if (entry.kind === "directory") {
+    const entries = await fs5.readdir(current);
+    for (const entry2 of entries) {
+      if (isIgnoredLocalEntryName(entry2.name)) continue;
+      const fullPath = import_node_path7.default.join(current, entry2.name);
+      if (entry2.kind === "directory") {
         if (fullPath !== root2) dirs.push(fullPath);
         stack.push(fullPath);
       } else {
-        if (entry.name.endsWith(".meta.json")) continue;
+        if (entry2.name.endsWith(".meta.json")) continue;
         files.push(fullPath);
       }
     }
   }
   return { files, dirs };
 }
-async function readMetaFileIfExists(fs6, absContentPath) {
+async function readMetaFileIfExists(fs5, absContentPath) {
   const p = metaFilePath(absContentPath);
   try {
-    const raw = decodeUtf8(await fs6.readFile(p));
+    const raw = decodeUtf8(await fs5.readFile(p));
     return safeParseJsonObject(raw);
   } catch (err) {
     if (!isEnoent(err)) {
@@ -131969,7 +131960,7 @@ async function readMetaFileIfExists(fs6, absContentPath) {
     return void 0;
   }
 }
-async function writeMetaFile(fs6, absContentPath, meta3, assetId, serverId, metaType) {
+async function writeMetaFile(fs5, absContentPath, meta3, assetId, serverId, metaType) {
   const p = metaFilePath(absContentPath);
   const { locked: _locked, ...restMeta } = meta3;
   const merged = {
@@ -131978,17 +131969,17 @@ async function writeMetaFile(fs6, absContentPath, meta3, assetId, serverId, meta
     assetId,
     serverId
   };
-  await fs6.writeFile(p, JSON.stringify(merged, null, 2));
+  await fs5.writeFile(p, JSON.stringify(merged, null, 2));
 }
 
 // src/commands/push/push-project.ts
 async function pushProject(opts) {
-  const { projectDir, apiClient, fs: fs6, signal } = opts;
+  const { projectDir, apiClient, fs: fs5, signal } = opts;
   throwIfAborted(signal);
   const manifestPath = import_node_path8.default.resolve(projectDir, ".galacean/manifest.json");
-  const manifestRaw = await fs6.readFile(manifestPath);
+  const manifestRaw = await fs5.readFile(manifestPath);
   const manifest = parseManifest(manifestRaw, manifestPath);
-  const projectConfig = await readProjectConfig2(fs6, projectDir);
+  const projectConfig = await readProjectConfig2(fs5, projectDir);
   const resolvedProjectSceneId = resolveProjectSceneId(projectConfig, manifest);
   const pushed = [];
   const deleted = [];
@@ -131997,32 +131988,32 @@ async function pushProject(opts) {
   try {
     const assetsRoot = import_node_path8.default.resolve(projectDir, "assets");
     throwIfAborted(signal);
-    const { files: localFilesAbs, dirs: localDirsAbs } = await listFilesAndDirs(fs6, assetsRoot);
+    const { files: localFilesAbs, dirs: localDirsAbs } = await listFilesAndDirs(fs5, assetsRoot);
     const manifestEntryByPath = /* @__PURE__ */ new Map();
     const folderIdByPath = /* @__PURE__ */ new Map();
-    for (const [assetId, entry] of Object.entries(manifest.entries)) {
-      manifestEntryByPath.set(entry.path, { assetId, entry });
-      if (entry.type === "Folder") folderIdByPath.set(entry.path, assetId);
+    for (const [assetId, entry2] of Object.entries(manifest.entries)) {
+      manifestEntryByPath.set(entry2.path, { assetId, entry: entry2 });
+      if (entry2.type === "Folder") folderIdByPath.set(entry2.path, assetId);
     }
     const localDirs = localDirsAbs.map((abs) => toManifestPath(projectDir, abs)).filter((p) => p !== "assets");
     const localFiles = localFilesAbs.map((abs) => toManifestPath(projectDir, abs));
-    await assertNoCaseOnlyPathCoexistence(fs6, projectDir, manifest.entries, localDirs, localFiles, manifestEntryByPath);
+    await assertNoCaseOnlyPathCoexistence(fs5, projectDir, manifest.entries, localDirs, localFiles, manifestEntryByPath);
     const newFolderPaths = localDirs.filter((p) => !manifestEntryByPath.has(p));
     const newFilePaths = localFiles.filter((p) => !manifestEntryByPath.has(p));
     const localDirSet = new Set(localDirs);
     const localFileSet = new Set(localFiles);
     const folderCaseRenameMap = /* @__PURE__ */ new Map();
     const manifestFolderByLowerPath = /* @__PURE__ */ new Map();
-    for (const [assetId, entry] of Object.entries(manifest.entries)) {
-      if (entry.type !== "Folder") continue;
-      const lowerPath = normalizePathLower(entry.path);
+    for (const [assetId, entry2] of Object.entries(manifest.entries)) {
+      if (entry2.type !== "Folder") continue;
+      const lowerPath = normalizePathLower(entry2.path);
       const existing = manifestFolderByLowerPath.get(lowerPath);
       if (existing && existing.assetId !== assetId) {
         throw new Error(
-          `[push] Manifest has case-colliding folder paths: '${existing.path}' and '${entry.path}'. Keep only one path and retry.`
+          `[push] Manifest has case-colliding folder paths: '${existing.path}' and '${entry2.path}'. Keep only one path and retry.`
         );
       }
-      manifestFolderByLowerPath.set(lowerPath, { assetId, path: entry.path });
+      manifestFolderByLowerPath.set(lowerPath, { assetId, path: entry2.path });
     }
     for (const folderPath of newFolderPaths) {
       const matched = manifestFolderByLowerPath.get(normalizePathLower(folderPath));
@@ -132039,7 +132030,7 @@ async function pushProject(opts) {
     const effectiveNewFolderPaths = newFolderPaths;
     let remote = null;
     try {
-      remote = await readRemoteConfig(fs6, projectDir);
+      remote = await readRemoteConfig(fs5, projectDir);
     } catch (err) {
       if (!isEnoent(err)) throw err;
     }
@@ -132047,12 +132038,12 @@ async function pushProject(opts) {
       const backup = new Map(
         Object.entries(manifest.entries).map(([id, e]) => [id, { serverId: e.serverId, contentHash: e.contentHash }])
       );
-      for (const entry of Object.values(manifest.entries)) {
-        entry.serverId = "";
-        entry.contentHash = "";
+      for (const entry2 of Object.values(manifest.entries)) {
+        entry2.serverId = "";
+        entry2.contentHash = "";
       }
       try {
-        remote = await autoCreateRemoteProject(fs6, projectDir, opts, projectConfig, resolvedProjectSceneId);
+        remote = await autoCreateRemoteProject(fs5, projectDir, opts, projectConfig, resolvedProjectSceneId);
       } catch (err) {
         for (const [id, orig] of backup) {
           if (manifest.entries[id]) {
@@ -132062,13 +132053,13 @@ async function pushProject(opts) {
         }
         const remotePath = import_node_path8.default.resolve(projectDir, ".galacean/remote.json");
         try {
-          await fs6.remove(remotePath);
+          await fs5.remove(remotePath);
         } catch {
         }
         throw err;
       }
     }
-    const engineVersion = await readEngineVersion(fs6, projectDir);
+    const engineVersion = await readEngineVersion(fs5, projectDir);
     const existingServerAssets = /* @__PURE__ */ new Map();
     const serverAssetDetails = [];
     let remoteProjectDetail = null;
@@ -132085,54 +132076,54 @@ async function pushProject(opts) {
       }
     }
     const unregisteredBuiltins = [];
-    for (const [assetId, entry] of Object.entries(manifest.entries)) {
-      const isUnregistered = !entry.serverId || entry.serverId.startsWith("local-");
-      const isFolderOrCdn = entry.type === "Folder" || entry.url?.startsWith("http");
+    for (const [assetId, entry2] of Object.entries(manifest.entries)) {
+      const isUnregistered = !entry2.serverId || entry2.serverId.startsWith("local-");
+      const isFolderOrCdn = entry2.type === "Folder" || entry2.url?.startsWith("http");
       if (!isUnregistered || !isFolderOrCdn) continue;
-      if (entry.type === "Folder") {
-        if (localDirSet.has(entry.path) || isBuiltinFolderAssetId(assetId)) {
-          unregisteredBuiltins.push([assetId, entry]);
+      if (entry2.type === "Folder") {
+        if (localDirSet.has(entry2.path) || isBuiltinFolderAssetId(assetId)) {
+          unregisteredBuiltins.push([assetId, entry2]);
           continue;
         }
-        const folderMeta = await readMetaFileIfExists(fs6, import_node_path8.default.resolve(projectDir, entry.path));
+        const folderMeta = await readMetaFileIfExists(fs5, import_node_path8.default.resolve(projectDir, entry2.path));
         if (folderMeta) {
-          unregisteredBuiltins.push([assetId, entry]);
+          unregisteredBuiltins.push([assetId, entry2]);
         }
         continue;
       }
-      if (localFileSet.has(entry.path) || isBuiltinAssetId(assetId)) {
-        unregisteredBuiltins.push([assetId, entry]);
+      if (localFileSet.has(entry2.path) || isBuiltinAssetId(assetId)) {
+        unregisteredBuiltins.push([assetId, entry2]);
         continue;
       }
-      const fileMeta = await readMetaFileIfExists(fs6, import_node_path8.default.resolve(projectDir, entry.path));
+      const fileMeta = await readMetaFileIfExists(fs5, import_node_path8.default.resolve(projectDir, entry2.path));
       if (fileMeta) {
-        unregisteredBuiltins.push([assetId, entry]);
+        unregisteredBuiltins.push([assetId, entry2]);
       }
     }
     if (unregisteredBuiltins.length > 0) {
       if (!remote) {
-        remote = await autoCreateRemoteProject(fs6, projectDir, opts, projectConfig, resolvedProjectSceneId);
+        remote = await autoCreateRemoteProject(fs5, projectDir, opts, projectConfig, resolvedProjectSceneId);
       }
       const builtinFolders = unregisteredBuiltins.filter(([_24, e]) => e.type === "Folder").sort(([, a], [, b]) => a.path.split("/").length - b.path.split("/").length);
       const builtinFiles = unregisteredBuiltins.filter(([_24, e]) => e.type !== "Folder");
-      for (const [assetId, entry] of [...builtinFolders, ...builtinFiles]) {
+      for (const [assetId, entry2] of [...builtinFolders, ...builtinFiles]) {
         throwIfAborted(signal);
-        const absPath = import_node_path8.default.resolve(projectDir, entry.path);
-        const existingMeta = await readMetaFileIfExists(fs6, absPath) ?? {};
+        const absPath = import_node_path8.default.resolve(projectDir, entry2.path);
+        const existingMeta = await readMetaFileIfExists(fs5, absPath) ?? {};
         const existingId = existingServerAssets.get(assetId);
         if (existingId) {
-          entry.serverId = existingId;
-          await writeMetaFile(fs6, absPath, existingMeta, assetId, existingId, entry.type);
+          entry2.serverId = existingId;
+          await writeMetaFile(fs5, absPath, existingMeta, assetId, existingId, entry2.type);
           continue;
         }
-        const parentId = resolveParentId(import_node_path8.default.posix.dirname(entry.path), folderIdByPath, entry.path);
-        const serverName = getServerFileName(entry.path, entry.type);
+        const parentId = resolveParentId(import_node_path8.default.posix.dirname(entry2.path), folderIdByPath, entry2.path);
+        const serverName = getServerFileName(entry2.path, entry2.type);
         const lockedFromMeta = existingMeta.locked;
         const shouldForceLocked = isBuiltinAssetId(assetId);
         const lockedForServer = shouldForceLocked ? true : typeof lockedFromMeta === "boolean" ? lockedFromMeta : void 0;
         const metaForServer = {
           ...stripLocalMetaFields(existingMeta),
-          type: entry.type,
+          type: entry2.type,
           id: assetId,
           version: existingMeta.version || engineVersion,
           ...lockedForServer === void 0 ? {} : { locked: lockedForServer }
@@ -132144,12 +132135,12 @@ async function pushProject(opts) {
             name: serverName,
             meta: JSON.stringify(metaForServer),
             parentId,
-            url: entry.type !== "Folder" ? entry.url : void 0
+            url: entry2.type !== "Folder" ? entry2.url : void 0
           },
           { signal }
         );
-        entry.serverId = created.id;
-        await writeMetaFile(fs6, absPath, existingMeta, assetId, created.id, entry.type);
+        entry2.serverId = created.id;
+        await writeMetaFile(fs5, absPath, existingMeta, assetId, created.id, entry2.type);
       }
     }
     effectiveNewFolderPaths.sort((a, b) => a.split("/").length - b.split("/").length);
@@ -132164,9 +132155,9 @@ async function pushProject(opts) {
         if (!existingEntry || existingEntry.type !== "Folder") {
           throw new Error(`[push] Missing tracked folder entry for case-only rename: '${oldPath}' -> '${folderPath}'`);
         }
-        let existingMeta2 = await readMetaFileIfExists(fs6, absFolderPath) ?? {};
+        let existingMeta2 = await readMetaFileIfExists(fs5, absFolderPath) ?? {};
         if (Object.keys(existingMeta2).length === 0) {
-          existingMeta2 = await readMetaFileIfExists(fs6, import_node_path8.default.resolve(projectDir, oldPath)) ?? {};
+          existingMeta2 = await readMetaFileIfExists(fs5, import_node_path8.default.resolve(projectDir, oldPath)) ?? {};
         }
         const baseMeta2 = {
           ...stripLocalMetaFields(existingMeta2),
@@ -132174,7 +132165,7 @@ async function pushProject(opts) {
           id: assetId2,
           version: engineVersion
         };
-        await writeMetaFile(fs6, absFolderPath, baseMeta2, assetId2, existingEntry.serverId, "Folder");
+        await writeMetaFile(fs5, absFolderPath, baseMeta2, assetId2, existingEntry.serverId, "Folder");
         existingEntry.path = folderPath;
         existingEntry.remoteVersion = existingEntry.remoteVersion || engineVersion || "";
         manifestEntryByPath.delete(oldPath);
@@ -132184,7 +132175,7 @@ async function pushProject(opts) {
         continue;
       }
       const parentId = resolveParentId(import_node_path8.default.posix.dirname(folderPath), folderIdByPath, folderPath);
-      const existingMeta = await readMetaFileIfExists(fs6, absFolderPath) ?? {};
+      const existingMeta = await readMetaFileIfExists(fs5, absFolderPath) ?? {};
       const persistedId = resolvePersistedId(existingMeta);
       const assetId = persistedId ?? (0, import_node_crypto3.randomUUID)();
       const baseMeta = {
@@ -132195,7 +132186,7 @@ async function pushProject(opts) {
       };
       const existingId = existingServerAssets.get(assetId);
       if (existingId) {
-        await writeMetaFile(fs6, absFolderPath, baseMeta, assetId, existingId, "Folder");
+        await writeMetaFile(fs5, absFolderPath, baseMeta, assetId, existingId, "Folder");
         manifest.entries[assetId] = {
           assetId,
           path: folderPath,
@@ -132210,7 +132201,7 @@ async function pushProject(opts) {
         continue;
       }
       if (!persistedId) {
-        await writeMetaFile(fs6, absFolderPath, baseMeta, assetId, "", "Folder");
+        await writeMetaFile(fs5, absFolderPath, baseMeta, assetId, "", "Folder");
       }
       const metaForServer = safeParseJsonObject(JSON.stringify(baseMeta));
       const created = await apiClient.createAsset(
@@ -132224,7 +132215,7 @@ async function pushProject(opts) {
         { signal }
       );
       const returnedMeta = parseJsonObjectOrThrow(created.meta, `createAsset response for folder '${folderPath}'`);
-      await writeMetaFile(fs6, absFolderPath, returnedMeta, assetId, created.id, "Folder");
+      await writeMetaFile(fs5, absFolderPath, returnedMeta, assetId, created.id, "Folder");
       manifest.entries[assetId] = {
         assetId,
         path: folderPath,
@@ -132241,8 +132232,8 @@ async function pushProject(opts) {
       throwIfAborted(signal);
       const parentId = resolveParentId(import_node_path8.default.posix.dirname(filePath), folderIdByPath, filePath);
       const absFilePath = import_node_path8.default.resolve(projectDir, filePath);
-      const content = await fs6.readFile(absFilePath);
-      const existingMeta = await readMetaFileIfExists(fs6, absFilePath) ?? {};
+      const content = await fs5.readFile(absFilePath);
+      const existingMeta = await readMetaFileIfExists(fs5, absFilePath) ?? {};
       const persistedType = existingMeta.type;
       const localFileName = import_node_path8.default.posix.basename(filePath);
       const metaType = (typeof persistedType === "string" && persistedType.length > 0 ? persistedType : void 0) ?? (localFileName.endsWith(".ts") ? "script" : void 0);
@@ -132264,7 +132255,7 @@ async function pushProject(opts) {
       const existingId = existingServerAssets.get(assetId);
       if (existingId) {
         const upload = await apiClient.uploadAsset(existingId, content, serverName, { signal });
-        await writeMetaFile(fs6, absFilePath, baseMeta, assetId, existingId, metaType);
+        await writeMetaFile(fs5, absFilePath, baseMeta, assetId, existingId, metaType);
         manifest.entries[assetId] = {
           assetId,
           path: filePath,
@@ -132279,7 +132270,7 @@ async function pushProject(opts) {
         continue;
       }
       if (!persistedId) {
-        await writeMetaFile(fs6, absFilePath, baseMeta, assetId, "", metaType);
+        await writeMetaFile(fs5, absFilePath, baseMeta, assetId, "", metaType);
       }
       const metaForServer = safeParseJsonObject(JSON.stringify(baseMeta));
       const created = await apiClient.createAsset(
@@ -132294,7 +132285,7 @@ async function pushProject(opts) {
         { signal }
       );
       const returnedMeta = parseJsonObjectOrThrow(created.meta, `createAsset response for file '${filePath}'`);
-      await writeMetaFile(fs6, absFilePath, returnedMeta, assetId, created.id, metaType);
+      await writeMetaFile(fs5, absFilePath, returnedMeta, assetId, created.id, metaType);
       manifest.entries[assetId] = {
         assetId,
         path: filePath,
@@ -132308,56 +132299,56 @@ async function pushProject(opts) {
       pushed.push({ assetId, path: filePath, serverId: created.id, url: created.url });
     }
     const deletedLocalAssetIds = /* @__PURE__ */ new Set();
-    for (const [assetId, entry] of Object.entries(manifest.entries)) {
+    for (const [assetId, entry2] of Object.entries(manifest.entries)) {
       throwIfAborted(signal);
-      if (entry.type === "Folder") continue;
-      const filePath = import_node_path8.default.resolve(projectDir, entry.path);
+      if (entry2.type === "Folder") continue;
+      const filePath = import_node_path8.default.resolve(projectDir, entry2.path);
       let content;
       try {
-        content = await fs6.readFile(filePath);
+        content = await fs5.readFile(filePath);
       } catch (err) {
         if (!isEnoent(err)) {
           throw err;
         }
-        if (shouldTreatMissingLocalFileAsDelete(entry)) {
+        if (shouldTreatMissingLocalFileAsDelete(entry2)) {
           deletedLocalAssetIds.add(assetId);
           continue;
         }
         warnings.push(
-          `[push] Missing local file for remote-only asset '${entry.path}'; leaving manifest entry unchanged.`
+          `[push] Missing local file for remote-only asset '${entry2.path}'; leaving manifest entry unchanged.`
         );
         continue;
       }
       const currentHash = md5Buffer(content);
-      const isLocalOnly = !entry.serverId || entry.serverId.startsWith("local-");
-      if (currentHash === entry.contentHash && !isLocalOnly) continue;
-      const serverName = getServerFileName(entry.path, entry.type);
+      const isLocalOnly = !entry2.serverId || entry2.serverId.startsWith("local-");
+      if (currentHash === entry2.contentHash && !isLocalOnly) continue;
+      const serverName = getServerFileName(entry2.path, entry2.type);
       if (isLocalOnly) {
         const existingId = existingServerAssets.get(assetId);
         if (existingId) {
           const upload = await apiClient.uploadAsset(existingId, content, serverName, { signal });
-          const absFilePath = import_node_path8.default.resolve(projectDir, entry.path);
-          const existingMeta = await readMetaFileIfExists(fs6, absFilePath) ?? {};
-          const metaType = typeof existingMeta.type === "string" && existingMeta.type || entry.type;
-          await writeMetaFile(fs6, absFilePath, existingMeta, assetId, existingId, metaType);
-          entry.contentHash = currentHash;
-          entry.serverId = existingId;
-          entry.url = upload.url;
-          pushed.push({ assetId, path: entry.path, serverId: existingId, url: upload.url });
+          const absFilePath = import_node_path8.default.resolve(projectDir, entry2.path);
+          const existingMeta = await readMetaFileIfExists(fs5, absFilePath) ?? {};
+          const metaType = typeof existingMeta.type === "string" && existingMeta.type || entry2.type;
+          await writeMetaFile(fs5, absFilePath, existingMeta, assetId, existingId, metaType);
+          entry2.contentHash = currentHash;
+          entry2.serverId = existingId;
+          entry2.url = upload.url;
+          pushed.push({ assetId, path: entry2.path, serverId: existingId, url: upload.url });
         } else {
           if (!remote) {
-            remote = await autoCreateRemoteProject(fs6, projectDir, opts, projectConfig, resolvedProjectSceneId);
+            remote = await autoCreateRemoteProject(fs5, projectDir, opts, projectConfig, resolvedProjectSceneId);
           }
-          const absFilePath = import_node_path8.default.resolve(projectDir, entry.path);
-          const existingMeta = await readMetaFileIfExists(fs6, absFilePath) ?? {};
-          const metaType = typeof existingMeta.type === "string" && existingMeta.type || entry.type;
+          const absFilePath = import_node_path8.default.resolve(projectDir, entry2.path);
+          const existingMeta = await readMetaFileIfExists(fs5, absFilePath) ?? {};
+          const metaType = typeof existingMeta.type === "string" && existingMeta.type || entry2.type;
           const metaForServer = {
             ...stripLocalMetaFields(existingMeta),
             type: metaType,
             id: assetId,
             version: engineVersion
           };
-          const parentId = resolveParentId(import_node_path8.default.posix.dirname(entry.path), folderIdByPath, entry.path);
+          const parentId = resolveParentId(import_node_path8.default.posix.dirname(entry2.path), folderIdByPath, entry2.path);
           const created = await apiClient.createAsset(
             {
               projectId: remote.projectId,
@@ -132369,28 +132360,28 @@ async function pushProject(opts) {
             },
             { signal }
           );
-          const returnedMeta = parseJsonObjectOrThrow(created.meta, `createAsset response for file '${entry.path}'`);
-          await writeMetaFile(fs6, absFilePath, returnedMeta, assetId, created.id, metaType);
-          entry.contentHash = currentHash;
-          entry.serverId = created.id;
-          entry.url = created.url;
-          pushed.push({ assetId, path: entry.path, serverId: created.id, url: created.url });
+          const returnedMeta = parseJsonObjectOrThrow(created.meta, `createAsset response for file '${entry2.path}'`);
+          await writeMetaFile(fs5, absFilePath, returnedMeta, assetId, created.id, metaType);
+          entry2.contentHash = currentHash;
+          entry2.serverId = created.id;
+          entry2.url = created.url;
+          pushed.push({ assetId, path: entry2.path, serverId: created.id, url: created.url });
         }
       } else {
-        const upload = await apiClient.uploadAsset(entry.serverId, content, serverName, { signal });
-        entry.contentHash = currentHash;
-        entry.url = upload.url;
-        pushed.push({ assetId, path: entry.path, serverId: entry.serverId, url: upload.url });
+        const upload = await apiClient.uploadAsset(entry2.serverId, content, serverName, { signal });
+        entry2.contentHash = currentHash;
+        entry2.url = upload.url;
+        pushed.push({ assetId, path: entry2.path, serverId: entry2.serverId, url: upload.url });
       }
     }
     const deletedFolderPaths = [];
     const folderDeleteCandidates = Object.values(manifest.entries).filter(
-      (entry) => entry.type === "Folder" && !localDirSet.has(entry.path)
+      (entry2) => entry2.type === "Folder" && !localDirSet.has(entry2.path)
     );
     for (const folderEntry of folderDeleteCandidates) {
       const folderPath = folderEntry.path;
       const hasDeletedDescendant = Object.entries(manifest.entries).some(
-        ([assetId, entry]) => deletedLocalAssetIds.has(assetId) && isPathInsideFolder(entry.path, folderPath)
+        ([assetId, entry2]) => deletedLocalAssetIds.has(assetId) && isPathInsideFolder(entry2.path, folderPath)
       );
       if (hasDeletedDescendant || hasMaterializedDescendant(manifest.entries, folderPath)) {
         deletedFolderPaths.push(folderPath);
@@ -132402,9 +132393,9 @@ async function pushProject(opts) {
     }
     deletedFolderPaths.sort((a, b) => a.length - b.length);
     for (const folderPath of deletedFolderPaths) {
-      for (const [assetId, entry] of Object.entries(manifest.entries)) {
-        if (entry.path === folderPath || isPathInsideFolder(entry.path, folderPath)) {
-          if (entry.type !== "Folder" && !shouldTreatMissingLocalFileAsDelete(entry)) continue;
+      for (const [assetId, entry2] of Object.entries(manifest.entries)) {
+        if (entry2.path === folderPath || isPathInsideFolder(entry2.path, folderPath)) {
+          if (entry2.type !== "Folder" && !shouldTreatMissingLocalFileAsDelete(entry2)) continue;
           deletedLocalAssetIds.add(assetId);
         }
       }
@@ -132424,12 +132415,12 @@ async function pushProject(opts) {
       pendingManifestDeletes.push({ assetId, entry: removedEntry });
       const absFilePath = import_node_path8.default.resolve(projectDir, removedEntry.path);
       try {
-        await fs6.remove(metaFilePath(absFilePath));
+        await fs5.remove(metaFilePath(absFilePath));
       } catch (err) {
         if (!isEnoent(err)) throw err;
       }
       try {
-        await fs6.remove(absFilePath);
+        await fs5.remove(absFilePath);
       } catch (err) {
         if (!isEnoent(err)) throw err;
       }
@@ -132461,10 +132452,10 @@ async function pushProject(opts) {
       await apiClient.deleteAssets(remote.projectId, toDelete, { signal });
       deleted.push(...toDelete);
     }
-    for (const { assetId, entry } of pendingManifestDeletes) {
+    for (const { assetId, entry: entry2 } of pendingManifestDeletes) {
       delete manifest.entries[assetId];
-      manifestEntryByPath.delete(entry.path);
-      if (entry.type === "Folder") folderIdByPath.delete(entry.path);
+      manifestEntryByPath.delete(entry2.path);
+      if (entry2.type === "Folder") folderIdByPath.delete(entry2.path);
     }
     if (remote && remoteProjectDetail) {
       await syncRemoteProjectMetadata(
@@ -132481,7 +132472,7 @@ async function pushProject(opts) {
   }
   let writeError;
   try {
-    await atomicWriteFile(fs6, manifestPath, JSON.stringify(manifest, null, 2));
+    await atomicWriteFile(fs5, manifestPath, JSON.stringify(manifest, null, 2));
   } catch (err) {
     writeError = err;
   }
@@ -132551,11 +132542,11 @@ var normalizeFilter = (filter) => {
     return filter;
   if (typeof filter === "string") {
     const fl = filter.trim();
-    return (entry) => entry.basename === fl;
+    return (entry2) => entry2.basename === fl;
   }
   if (Array.isArray(filter)) {
     const trItems = filter.map((item) => item.trim());
-    return (entry) => trItems.some((f) => entry.basename === f);
+    return (entry2) => trItems.some((f) => entry2.basename === f);
   }
   return emptyFn;
 };
@@ -132600,23 +132591,23 @@ var ReaddirpStream = class extends import_node_stream.Readable {
           const { path: path16, depth } = par;
           const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path16));
           const awaited = await Promise.all(slice);
-          for (const entry of awaited) {
-            if (!entry)
+          for (const entry2 of awaited) {
+            if (!entry2)
               continue;
             if (this.destroyed)
               return;
-            const entryType = await this._getEntryType(entry);
-            if (entryType === "directory" && this._directoryFilter(entry)) {
+            const entryType = await this._getEntryType(entry2);
+            if (entryType === "directory" && this._directoryFilter(entry2)) {
               if (depth <= this._maxDepth) {
-                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                this.parents.push(this._exploreDir(entry2.fullPath, depth + 1));
               }
               if (this._wantsDir) {
-                this.push(entry);
+                this.push(entry2);
                 batch--;
               }
-            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+            } else if ((entryType === "file" || this._includeAsFile(entry2)) && this._fileFilter(entry2)) {
               if (this._wantsFile) {
-                this.push(entry);
+                this.push(entry2);
                 batch--;
               }
             }
@@ -132648,17 +132639,17 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     return { files, depth, path: path16 };
   }
   async _formatEntry(dirent, path16) {
-    let entry;
+    let entry2;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
       const fullPath = (0, import_node_path9.resolve)((0, import_node_path9.join)(path16, basename4));
-      entry = { path: (0, import_node_path9.relative)(this._root, fullPath), fullPath, basename: basename4 };
-      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+      entry2 = { path: (0, import_node_path9.relative)(this._root, fullPath), fullPath, basename: basename4 };
+      entry2[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
       return;
     }
-    return entry;
+    return entry2;
   }
   _onError(err) {
     if (isNormalFlowError(err) && !this.destroyed) {
@@ -132667,17 +132658,17 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.destroy(err);
     }
   }
-  async _getEntryType(entry) {
-    if (!entry && this._statsProp in entry) {
+  async _getEntryType(entry2) {
+    if (!entry2 && this._statsProp in entry2) {
       return "";
     }
-    const stats = entry[this._statsProp];
+    const stats = entry2[this._statsProp];
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
       return "directory";
     if (stats && stats.isSymbolicLink()) {
-      const full = entry.fullPath;
+      const full = entry2.fullPath;
       try {
         const entryRealPath = await (0, import_promises5.realpath)(full);
         const entryRealPathStats = await (0, import_promises5.lstat)(entryRealPath);
@@ -132699,8 +132690,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       }
     }
   }
-  _includeAsFile(entry) {
-    const stats = entry && entry[this._statsProp];
+  _includeAsFile(entry2) {
+    const stats = entry2 && entry2[this._statsProp];
     return stats && this._wantsEverything && !stats.isDirectory();
   }
 };
@@ -133026,10 +133017,10 @@ var foreach = (val, fn) => {
     fn(val);
   }
 };
-var addAndConvert = (main, prop, item) => {
-  let container = main[prop];
+var addAndConvert = (main2, prop, item) => {
+  let container = main2[prop];
   if (!(container instanceof Set)) {
-    main[prop] = container = /* @__PURE__ */ new Set([container]);
+    main2[prop] = container = /* @__PURE__ */ new Set([container]);
   }
   container.add(item);
 };
@@ -133041,12 +133032,12 @@ var clearItem = (cont) => (key) => {
     delete cont[key];
   }
 };
-var delFromSet = (main, prop, item) => {
-  const container = main[prop];
+var delFromSet = (main2, prop, item) => {
+  const container = main2[prop];
   if (container instanceof Set) {
     container.delete(item);
   } else if (container === item) {
-    delete main[prop];
+    delete main2[prop];
   }
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
@@ -133281,11 +133272,11 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path16, item) {
+  async _handleSymlink(entry2, directory, path16, item) {
     if (this.fsw.closed) {
       return;
     }
-    const full = entry.fullPath;
+    const full = entry2.fullPath;
     const dir = this.fsw._getWatchedDir(directory);
     if (!this.fsw.options.followSymlinks) {
       this.fsw._incrReadyCount();
@@ -133301,12 +133292,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path16, entry.stats);
+          this.fsw._emit(EV.CHANGE, path16, entry2.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path16, entry.stats);
+        this.fsw._emit(EV.ADD, path16, entry2.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -133324,20 +133315,20 @@ var NodeFsHandler = class {
     const previous = this.fsw._getWatchedDir(wh.path);
     const current = /* @__PURE__ */ new Set();
     let stream = this.fsw._readdirp(directory, {
-      fileFilter: (entry) => wh.filterPath(entry),
-      directoryFilter: (entry) => wh.filterDir(entry)
+      fileFilter: (entry2) => wh.filterPath(entry2),
+      directoryFilter: (entry2) => wh.filterDir(entry2)
     });
     if (!stream)
       return;
-    stream.on(STR_DATA, async (entry) => {
+    stream.on(STR_DATA, async (entry2) => {
       if (this.fsw.closed) {
         stream = void 0;
         return;
       }
-      const item = entry.path;
+      const item = entry2.path;
       let path16 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path16, item)) {
+      if (entry2.stats.isSymbolicLink() && await this._handleSymlink(entry2, directory, path16, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -133424,8 +133415,8 @@ var NodeFsHandler = class {
     }
     const wh = this.fsw._getWatchHelpers(path16);
     if (priorWh) {
-      wh.filterPath = (entry) => priorWh.filterPath(entry);
-      wh.filterDir = (entry) => priorWh.filterDir(entry);
+      wh.filterPath = (entry2) => priorWh.filterPath(entry2);
+      wh.filterDir = (entry2) => priorWh.filterDir(entry2);
     }
     try {
       const stats = await statMethods[wh.statMethod](wh.watchPath);
@@ -133654,18 +133645,18 @@ var WatchHelper = class {
     this.followSymlinks = follow;
     this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
   }
-  entryPath(entry) {
-    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+  entryPath(entry2) {
+    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry2.fullPath));
   }
-  filterPath(entry) {
-    const { stats } = entry;
+  filterPath(entry2) {
+    const { stats } = entry2;
     if (stats && stats.isSymbolicLink())
-      return this.filterDir(entry);
-    const resolvedPath = this.entryPath(entry);
+      return this.filterDir(entry2);
+    const resolvedPath = this.entryPath(entry2);
     return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
   }
-  filterDir(entry) {
-    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  filterDir(entry2) {
+    return this.fsw._isntIgnored(this.entryPath(entry2), entry2.stats);
   }
 };
 var FSWatcher = class extends import_events.EventEmitter {
@@ -133852,10 +133843,10 @@ var FSWatcher = class extends import_events.EventEmitter {
    */
   getWatched() {
     const watchList = {};
-    this._watched.forEach((entry, dir) => {
+    this._watched.forEach((entry2, dir) => {
       const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
       const index2 = key || ONE_DOT;
-      watchList[index2] = entry.getChildren().sort();
+      watchList[index2] = entry2.getChildren().sort();
     });
     return watchList;
   }
@@ -133895,9 +133886,9 @@ var FSWatcher = class extends import_events.EventEmitter {
       if (event === EVENTS.UNLINK) {
         this._pendingUnlinks.set(path16, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path17) => {
-            this.emit(...entry);
-            this.emit(EVENTS.ALL, ...entry);
+          this._pendingUnlinks.forEach((entry2, path17) => {
+            this.emit(...entry2);
+            this.emit(EVENTS.ALL, ...entry2);
             this._pendingUnlinks.delete(path17);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
@@ -134286,7 +134277,7 @@ function watchProject(opts) {
   const {
     projectDir,
     apiClient,
-    fs: fs6,
+    fs: fs5,
     debounceMs,
     onPush,
     onError,
@@ -134310,7 +134301,7 @@ function watchProject(opts) {
           const result = await pushProject({
             projectDir: import_node_path11.default.resolve(projectDir),
             apiClient,
-            fs: fs6,
+            fs: fs5,
             signal,
             serverUrl,
             token
@@ -134478,25 +134469,25 @@ function registerAssetInfo(parent) {
     const dir = projectDir ?? process.cwd();
     const globals = parent.optsWithGlobals();
     const manifest = await readManifest(dir);
-    const entry = manifest.entries[assetId];
-    if (!entry) {
+    const entry2 = manifest.entries[assetId];
+    if (!entry2) {
       throw new Error(`Asset "${assetId}" not found in manifest`);
     }
     let meta3 = null;
     try {
-      meta3 = await readAssetMeta(dir, metaFilePath(entry.path));
+      meta3 = await readAssetMeta(dir, metaFilePath(entry2.path));
     } catch (err) {
       if (!(err instanceof FileReadError)) throw err;
     }
     if (globals.json) {
-      console.log(JSON.stringify({ ...entry, meta: meta3 }, null, 2));
+      console.log(JSON.stringify({ ...entry2, meta: meta3 }, null, 2));
     } else {
-      console.log(`Asset ID: ${entry.assetId}`);
-      console.log(`Path: ${entry.path}`);
-      console.log(`Type: ${entry.type}`);
-      console.log(`Content Hash: ${entry.contentHash}`);
-      console.log(`Server ID: ${entry.serverId}`);
-      console.log(`URL: ${entry.url}`);
+      console.log(`Asset ID: ${entry2.assetId}`);
+      console.log(`Path: ${entry2.path}`);
+      console.log(`Type: ${entry2.type}`);
+      console.log(`Content Hash: ${entry2.contentHash}`);
+      console.log(`Server ID: ${entry2.serverId}`);
+      console.log(`URL: ${entry2.url}`);
       if (meta3) {
         console.log(`Meta: ${JSON.stringify(meta3, null, 2)}`);
       }
@@ -134508,8 +134499,8 @@ function registerAssetInfo(parent) {
 init_local_project();
 function buildTreeFromPaths(entries) {
   const root2 = { name: "", children: [] };
-  for (const entry of Object.values(entries)) {
-    const parts = entry.path.split("/").filter(Boolean);
+  for (const entry2 of Object.values(entries)) {
+    const parts = entry2.path.split("/").filter(Boolean);
     let current = root2;
     for (let i = 0; i < parts.length; i++) {
       const part = parts[i];
@@ -134517,7 +134508,7 @@ function buildTreeFromPaths(entries) {
       if (!current.children) current.children = [];
       let child = current.children.find((c) => c.name === part);
       if (!child) {
-        child = isLeaf ? { name: part, type: entry.type } : { name: part, children: [] };
+        child = isLeaf ? { name: part, type: entry2.type } : { name: part, children: [] };
         current.children.push(child);
       }
       if (!isLeaf) current = child;
@@ -134554,7 +134545,7 @@ function registerAssetTree(parent) {
 }
 
 // src/commands/build.ts
-var import_node_path15 = __toESM(require("node:path"));
+var import_node_path14 = __toESM(require("node:path"));
 function parseKtx2Quality(raw) {
   if (raw == null) return void 0;
   const value = Number(raw);
@@ -134574,8 +134565,8 @@ function registerBuildCommand(program3) {
     try {
       const { buildProject: buildProject2 } = await Promise.resolve().then(() => (init_cli_builder(), cli_builder_exports));
       await buildProject2({
-        projectDir: import_node_path15.default.resolve(dir),
-        output: import_node_path15.default.resolve(cmdOpts.output),
+        projectDir: import_node_path14.default.resolve(dir),
+        output: import_node_path14.default.resolve(cmdOpts.output),
         ktx2: cmdOpts.ktx2 ?? false,
         ktx2Mode: cmdOpts.ktx2Mode,
         ktx2Quality,
@@ -134588,8 +134579,8 @@ function registerBuildCommand(program3) {
 }
 
 // src/commands/create.ts
-var import_promises13 = require("node:fs/promises");
-var import_node_path16 = __toESM(require("node:path"));
+var import_promises12 = require("node:fs/promises");
+var import_node_path15 = __toESM(require("node:path"));
 init_manifest();
 init_meta_file();
 init_path_tree();
@@ -134813,14 +134804,14 @@ function buildDefaultScene(platform) {
 async function createProject(opts) {
   const { name, platform = "3d", engineVersion = "1.6.0", force = false } = opts;
   const outputDir = opts.outputDir ?? `./${slugify(name)}`;
-  const absDir = import_node_path16.default.resolve(outputDir);
-  await (0, import_promises13.mkdir)(absDir, { recursive: true });
+  const absDir = import_node_path15.default.resolve(outputDir);
+  await (0, import_promises12.mkdir)(absDir, { recursive: true });
   if (!force) {
     await assertNodeDirectoryEmpty(absDir);
   } else {
     await resetNodeManagedProjectPaths(absDir);
   }
-  await (0, import_promises13.mkdir)(import_node_path16.default.join(absDir, ".galacean/cache"), { recursive: true });
+  await (0, import_promises12.mkdir)(import_node_path15.default.join(absDir, ".galacean/cache"), { recursive: true });
   const sceneJson = JSON.stringify(buildDefaultScene(platform), null, 2);
   const sceneAsset = {
     id: `local-${DEFAULT_SCENE_ID}`,
@@ -134834,24 +134825,24 @@ async function createProject(opts) {
   const allAssets = [sceneAsset, ...BUILTIN_REMOTE_ASSETS];
   const pathMap = buildLocalPathMap(allAssets);
   const contentHashes = /* @__PURE__ */ new Map();
-  for (const [, entry] of pathMap) {
-    if (entry.isFolder) {
-      await (0, import_promises13.mkdir)(import_node_path16.default.join(absDir, entry.localPath), { recursive: true });
+  for (const [, entry2] of pathMap) {
+    if (entry2.isFolder) {
+      await (0, import_promises12.mkdir)(import_node_path15.default.join(absDir, entry2.localPath), { recursive: true });
     }
   }
   const sceneEntry = pathMap.get(DEFAULT_SCENE_ID);
-  await (0, import_promises13.writeFile)(import_node_path16.default.join(absDir, sceneEntry.localPath), sceneJson);
+  await (0, import_promises12.writeFile)(import_node_path15.default.join(absDir, sceneEntry.localPath), sceneJson);
   contentHashes.set(DEFAULT_SCENE_ID, md5Text(sceneJson));
-  for (const [, entry] of pathMap) {
-    const meta3 = generateMetaFile(entry);
-    const metaPath = import_node_path16.default.join(absDir, metaFilePath(entry.localPath));
-    await (0, import_promises13.mkdir)(import_node_path16.default.dirname(metaPath), { recursive: true });
-    await (0, import_promises13.writeFile)(metaPath, JSON.stringify(meta3, null, 2));
+  for (const [, entry2] of pathMap) {
+    const meta3 = generateMetaFile(entry2);
+    const metaPath = import_node_path15.default.join(absDir, metaFilePath(entry2.localPath));
+    await (0, import_promises12.mkdir)(import_node_path15.default.dirname(metaPath), { recursive: true });
+    await (0, import_promises12.writeFile)(metaPath, JSON.stringify(meta3, null, 2));
   }
   const manifest = generateManifest(pathMap, contentHashes);
-  await (0, import_promises13.writeFile)(import_node_path16.default.join(absDir, ".galacean/manifest.json"), JSON.stringify(manifest, null, 2));
+  await (0, import_promises12.writeFile)(import_node_path15.default.join(absDir, ".galacean/manifest.json"), JSON.stringify(manifest, null, 2));
   const projectConfig = { name, platform, engineVersion, sceneId: DEFAULT_SCENE_ID };
-  await (0, import_promises13.writeFile)(import_node_path16.default.join(absDir, "project.galacean"), JSON.stringify(projectConfig, null, 2));
+  await (0, import_promises12.writeFile)(import_node_path15.default.join(absDir, "project.galacean"), JSON.stringify(projectConfig, null, 2));
   return { outputDir };
 }
 function registerCreateCommand(program3) {
@@ -134863,12 +134854,12 @@ function registerCreateCommand(program3) {
       engineVersion: options.engineVersion,
       force: options.force
     });
-    console.log(`Project created at: ${import_node_path16.default.resolve(outputDir)}`);
+    console.log(`Project created at: ${import_node_path15.default.resolve(outputDir)}`);
   });
 }
 
 // src/commands/exec.ts
-var import_node_path17 = __toESM(require("node:path"));
+var import_node_path16 = __toESM(require("node:path"));
 var UNSUPPORTED_HEADLESS_TOOL_IDS = /* @__PURE__ */ new Set(["prefab.create", "prefab.instantiate", "grp.import"]);
 var HEADLESS_TOOL_FOLLOWUP_ISSUES = {
   "prefab.create": 3583,
@@ -134919,7 +134910,7 @@ async function execTool(options) {
   }
   const { HeadlessRoot: HeadlessRoot2 } = await Promise.resolve().then(() => (init_headless(), headless_exports));
   const { loadDomainState: loadDomainState2, saveDomainState: saveDomainState2 } = await Promise.resolve().then(() => (init_domain_bridge(), domain_bridge_exports));
-  const projectDir = import_node_path17.default.resolve(options.projectDir);
+  const projectDir = import_node_path16.default.resolve(options.projectDir);
   const { state, ctx } = await loadDomainState2(projectDir);
   const root2 = new HeadlessRoot2(ctx.remoteProjectId, {
     name: ctx.config.name,
@@ -134940,7 +134931,7 @@ function registerExecCommand(program3) {
   program3.command("exec [toolId] [params]").description("Execute an editor-api tool on a local project").option("-p, --project <dir>", "project directory", ".").option("--list", "list all available tools").option("--schema <toolId>", "show tool input schema").option("--dry-run", "show what would change without saving").action(async (toolId, paramsStr, opts) => {
     try {
       const result = await execTool({
-        projectDir: import_node_path17.default.resolve(opts.project),
+        projectDir: import_node_path16.default.resolve(opts.project),
         toolId,
         params: paramsStr,
         list: opts.list,
@@ -134960,13 +134951,13 @@ function registerExecCommand(program3) {
 
 // src/cli-version.ts
 var import_node_fs3 = require("node:fs");
-var import_meta2 = {};
+var import_meta = {};
 function readCliVersionFromPackageJson() {
-  const raw = (0, import_node_fs3.readFileSync)(new URL("../package.json", import_meta2.url), "utf-8");
+  const raw = (0, import_node_fs3.readFileSync)(new URL("../package.json", import_meta.url), "utf-8");
   const parsed = JSON.parse(raw);
   return typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "0.0.0";
 }
-var CLI_VERSION = "0.0.1-alpha.7".length > 0 ? "0.0.1-alpha.7" : readCliVersionFromPackageJson();
+var CLI_VERSION = "0.0.1-alpha.8".length > 0 ? "0.0.1-alpha.8" : readCliVersionFromPackageJson();
 
 // src/push-output.ts
 function printPushResult(result, options = {}) {
@@ -135015,7 +135006,7 @@ program2.command("init <projectId>").description("Initialize a project locally")
   const globals = program2.optsWithGlobals();
   const serverUrl = await getServerUrl(globals);
   const token = getToken(globals);
-  const outputDir = cmdOpts.output ?? cmdOpts.outputDir ?? import_node_path18.default.resolve(globals._config?.projectsDir ?? import_node_path18.default.join(import_node_os2.default.homedir(), ".galacean/workspace"), projectId);
+  const outputDir = cmdOpts.output ?? cmdOpts.outputDir ?? import_node_path17.default.resolve(globals._config?.projectsDir ?? import_node_path17.default.join(import_node_os2.default.homedir(), ".galacean/workspace"), projectId);
   await initProject({
     projectId,
     outputDir,
@@ -135031,7 +135022,7 @@ program2.command("pull [projectDir]").description("Pull remote changes to local"
   const serverUrl = await getServerUrl(globals, dir);
   const token = getToken(globals);
   const result = await pullProject({
-    projectDir: import_node_path18.default.resolve(dir),
+    projectDir: import_node_path17.default.resolve(dir),
     apiClient: new HttpSyncApiClient(serverUrl, token),
     fs: new NodeFs()
   });
@@ -135063,7 +135054,7 @@ program2.command("push [projectDir]").description("Push local changes to remote"
   const serverUrl = await getServerUrl(globals, dir);
   const token = getToken(globals);
   const result = await pushProject({
-    projectDir: import_node_path18.default.resolve(dir),
+    projectDir: import_node_path17.default.resolve(dir),
     apiClient: new HttpSyncApiClient(serverUrl, token),
     fs: new NodeFs(),
     serverUrl,
@@ -135076,7 +135067,7 @@ program2.command("watch [projectDir]").description("Watch for local changes and
   const globals = program2.optsWithGlobals();
   const serverUrl = await getServerUrl(globals, dir);
   const token = getToken(globals);
-  const absProjectDir = import_node_path18.default.resolve(dir);
+  const absProjectDir = import_node_path17.default.resolve(dir);
   const handle2 = watchProject({
     projectDir: absProjectDir,
     apiClient: new HttpSyncApiClient(serverUrl, token),
@@ -135090,7 +135081,7 @@ program2.command("watch [projectDir]").description("Watch for local changes and
       console.error(err);
     }
   });
-  console.log(`Watching ${import_node_path18.default.join(absProjectDir, "assets")} for changes...`);
+  console.log(`Watching ${import_node_path17.default.join(absProjectDir, "assets")} for changes...`);
   console.log("Press Ctrl+C to stop");
   await new Promise((resolve4) => {
     const shutdown = () => {