weapp-vite 5.6.1 → 5.6.2

package/dist/{chunk-LWQW2GQC.mjs → chunk-S4QPBSDQ.mjs}

@@ -4483,6 +4483,7 @@ function createAutoRoutesServicePlugin(ctx) {
 
 // src/runtime/buildPlugin.ts
 init_esm_shims();
+import fs7 from "fs";
 import process3 from "process";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
@@ -9536,8 +9537,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs25 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs25);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs26 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs26);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -10095,8 +10096,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs25) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs25 });
+  newRoot(fs26) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs26 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -10124,8 +10125,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs25) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs25 });
+  newRoot(fs26) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs26 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -12537,11 +12538,45 @@ function createBuildService(ctx) {
             ignoreInitial: true
           }
         );
+        const logWorkerEvent = (type, target, level = "info") => {
+          if (!target) {
+            return;
+          }
+          const relative3 = configService.relativeCwd(target);
+          const message = `[workers:${type}] ${relative3}`;
+          if (level === "success") {
+            logger_default.success(message);
+          } else {
+            logger_default.info(message);
+          }
+        };
         watcher2.on("all", (event, id) => {
+          if (!id) {
+            return;
+          }
           if (event === "add") {
-            logger_default.success(`[workers:${event}] ${configService.relativeCwd(id)}`);
+            logWorkerEvent(event, id, "success");
             void devWorkers(workersDir);
+            return;
           }
+          logWorkerEvent(event, id);
+        });
+        watcher2.on("raw", (eventName, rawPath, details) => {
+          if (eventName !== "rename") {
+            return;
+          }
+          const candidate = typeof rawPath === "string" ? rawPath : rawPath && typeof rawPath.toString === "function" ? rawPath.toString() : "";
+          if (!candidate) {
+            return;
+          }
+          const baseDir = typeof details === "object" && details && "watchedPath" in details ? details.watchedPath ?? absWorkerRoot : absWorkerRoot;
+          const resolved = path11.isAbsolute(candidate) ? candidate : path11.resolve(baseDir, candidate);
+          const exists = fs7.existsSync(resolved);
+          if (exists) {
+            logWorkerEvent("rename->add", resolved);
+            return;
+          }
+          logWorkerEvent("rename->unlink", resolved);
         });
         watcherService.sidecarWatcherMap.set(absWorkerRoot, {
           close: () => watcher2.close()
@@ -12660,7 +12695,7 @@ import { defu as defu5 } from "@weapp-core/shared";
 
 // ../../node_modules/.pnpm/local-pkg@1.1.2/node_modules/local-pkg/dist/index.mjs
 init_esm_shims();
-import fs8 from "fs";
+import fs9 from "fs";
 import { createRequire as createRequire2 } from "module";
 import path13, { dirname as dirname4, join as join3, win32 as win322 } from "path";
 import process4 from "process";
@@ -18282,7 +18317,7 @@ Parser.acorn = {
 
 // ../../node_modules/.pnpm/mlly@1.8.0/node_modules/mlly/dist/index.mjs
 import { builtinModules, createRequire } from "module";
-import fs7, { realpathSync as realpathSync2, statSync as statSync2, promises as promises2 } from "fs";
+import fs8, { realpathSync as realpathSync2, statSync as statSync2, promises as promises2 } from "fs";
 
 // ../../node_modules/.pnpm/ufo@1.6.1/node_modules/ufo/dist/index.mjs
 init_esm_shims();
@@ -18686,7 +18721,7 @@ function read(jsonPath, { base, specifier }) {
   }
   let string;
   try {
-    string = fs7.readFileSync(path12.toNamespacedPath(jsonPath), "utf8");
+    string = fs8.readFileSync(path12.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = (
       /** @type {ErrnoException} */
@@ -19821,7 +19856,7 @@ function findUpSync(name, {
   while (directory) {
     const filePath = isAbsoluteName ? name : path13.join(directory, name);
     try {
-      const stats = fs8.statSync(filePath, { throwIfNoEntry: false });
+      const stats = fs9.statSync(filePath, { throwIfNoEntry: false });
       if (type === "file" && stats?.isFile() || type === "directory" && stats?.isDirectory()) {
         return filePath;
       }
@@ -19867,8 +19902,8 @@ function getPackageJsonPath(name, options = {}) {
   return searchPackageJSON(entry);
 }
 var readFile = quansync2({
-  async: (id) => fs8.promises.readFile(id, "utf8"),
-  sync: (id) => fs8.readFileSync(id, "utf8")
+  async: (id) => fs9.promises.readFile(id, "utf8"),
+  sync: (id) => fs9.readFileSync(id, "utf8")
 });
 var getPackageInfo = quansync2(function* (name, options = {}) {
   const packageJsonPath = getPackageJsonPath(name, options);
@@ -19907,7 +19942,7 @@ function searchPackageJSON(dir) {
       return;
     dir = newDir;
     packageJsonPath = join3(dir, "package.json");
-    if (fs8.existsSync(packageJsonPath))
+    if (fs9.existsSync(packageJsonPath))
       break;
   }
   return packageJsonPath;
@@ -19918,7 +19953,7 @@ var findUp = quansync2({
 });
 var loadPackageJSON = quansync2(function* (cwd = process4.cwd()) {
   const path36 = yield findUp("package.json", { cwd });
-  if (!path36 || !fs8.existsSync(path36))
+  if (!path36 || !fs9.existsSync(path36))
     return null;
   return JSON.parse(yield readFile(path36));
 });
@@ -19931,7 +19966,7 @@ var isPackageListedSync = isPackageListed.sync;
 
 // ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/detect.mjs
 init_esm_shims();
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 import path14 from "path";
 import process5 from "process";
 
@@ -19975,7 +20010,7 @@ var INSTALL_METADATA = {
 // ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/detect.mjs
 async function pathExists(path210, type) {
   try {
-    const stat6 = await fs9.stat(path210);
+    const stat6 = await fs10.stat(path210);
     return type === "file" ? stat6.isFile() : stat6.isDirectory();
   } catch {
     return false;
@@ -20062,7 +20097,7 @@ function getNameAndVer(pkg) {
 }
 async function handlePackageManager(filepath, onUnknown) {
   try {
-    const pkg = JSON.parse(await fs9.readFile(filepath, "utf8"));
+    const pkg = JSON.parse(await fs10.readFile(filepath, "utf8"));
     let agent;
     const nameAndVer = getNameAndVer(pkg);
     if (nameAndVer) {
@@ -20096,7 +20131,7 @@ import path32 from "pathe";
 
 // src/runtime/oxcRuntime.ts
 init_esm_shims();
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 import path15 from "pathe";
 var NULL_BYTE = "\0";
 var OXC_RUNTIME_HELPER_ALIAS = new RegExp(`^(?:${NULL_BYTE})?@oxc-project(?:/|\\+)runtime(?:@[^/]+)?/helpers/(.+)\\.js$`);
@@ -20206,9 +20241,9 @@ function createOxcRuntimeSupport() {
       const helperName = getOxcHelperName(id);
       if (helperName) {
         const helperPath = id.startsWith(NULL_BYTE) ? path15.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
-        if (await fs10.pathExists(helperPath)) {
-          console.warn("[weapp-vite] resolving oxc helper via Rolldown plugin:", helperName);
-          return fs10.readFile(helperPath, "utf8");
+        if (await fs11.pathExists(helperPath)) {
+          logger_default.warn(`[weapp-vite] resolving oxc helper via Rolldown plugin: ${helperName}`);
+          return fs11.readFile(helperPath, "utf8");
         }
         const fallback = fallbackHelpers[helperName];
         if (fallback) {
@@ -20226,7 +20261,7 @@ function createOxcRuntimeSupport() {
         return null;
       }
       if (source.includes("@oxc-project/runtime/helpers")) {
-        console.warn("[weapp-vite] resolveId intercepted:", source);
+        logger_default.warn(`[weapp-vite] resolveId intercepted: ${source}`);
       }
       const helperName = getOxcHelperName(source);
       if (helperName) {
@@ -20243,8 +20278,8 @@ function createOxcRuntimeSupport() {
         return null;
       }
       const helperPath = path15.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
-      console.warn("[weapp-vite] resolving oxc helper via Vite plugin:", helperName);
-      return fs10.readFile(helperPath, "utf8");
+      logger_default.warn(`[weapp-vite] resolving oxc helper via Vite plugin: ${helperName}`);
+      return fs11.readFile(helperPath, "utf8");
     }
   };
   return {
@@ -20337,7 +20372,7 @@ function createAliasManager(oxcAlias, builtinAliases) {
 // src/runtime/config/internal/loadConfig.ts
 init_esm_shims();
 import { defu } from "@weapp-core/shared";
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 import path18 from "pathe";
 import { loadConfigFromFile } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
@@ -20646,8 +20681,8 @@ function createLoadConfig(options) {
     }
     const packageJsonPath = path18.resolve(cwd, "package.json");
     let packageJson = {};
-    if (await fs11.exists(packageJsonPath)) {
-      const content = await fs11.readJson(packageJsonPath, {
+    if (await fs12.exists(packageJsonPath)) {
+      const content = await fs12.readJson(packageJsonPath, {
         throws: false
       }) || {};
       packageJson = content;
@@ -20834,42 +20869,10 @@ import { wrapPlugin } from "vite-plugin-performance";
 // src/plugins/asset.ts
 init_esm_shims();
 import { fdir as Fdir2 } from "fdir";
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 import path19 from "pathe";
-function asset(ctx) {
-  const state = { ctx };
-  return [createAssetCollector(state)];
-}
-function createAssetCollector(state) {
-  const { ctx } = state;
-  const { configService } = ctx;
-  return {
-    name: "weapp-vite:asset",
-    enforce: "pre",
-    configResolved(config) {
-      state.resolvedConfig = config;
-    },
-    buildStart() {
-      if (!state.resolvedConfig) {
-        state.pendingAssets = Promise.resolve([]);
-        return;
-      }
-      state.pendingAssets = scanAssetFiles(configService, state.resolvedConfig);
-    },
-    async buildEnd() {
-      const assets = await state.pendingAssets;
-      if (!assets?.length) {
-        return;
-      }
-      for (const candidate of assets) {
-        this.emitFile({
-          type: "asset",
-          fileName: configService.relativeAbsoluteSrcRoot(candidate.file),
-          source: candidate.buffer
-        });
-      }
-    }
-  };
+function normalizeCopyGlobs(globs) {
+  return Array.isArray(globs) ? globs : [];
 }
 function scanAssetFiles(configService, config) {
   const weappViteConfig = configService.weappViteConfig;
@@ -20909,14 +20912,46 @@ function scanAssetFiles(configService, config) {
       Array.from(files).filter(filter3).map(async (file) => {
         return {
           file,
-          buffer: await fs12.readFile(file)
+          buffer: await fs13.readFile(file)
         };
       })
     );
   });
 }
-function normalizeCopyGlobs(globs) {
-  return Array.isArray(globs) ? globs : [];
+function createAssetCollector(state) {
+  const { ctx } = state;
+  const { configService } = ctx;
+  return {
+    name: "weapp-vite:asset",
+    enforce: "pre",
+    configResolved(config) {
+      state.resolvedConfig = config;
+    },
+    buildStart() {
+      if (!state.resolvedConfig) {
+        state.pendingAssets = Promise.resolve([]);
+        return;
+      }
+      state.pendingAssets = scanAssetFiles(configService, state.resolvedConfig);
+    },
+    async buildEnd() {
+      const assets = await state.pendingAssets;
+      if (!assets?.length) {
+        return;
+      }
+      for (const candidate of assets) {
+        this.emitFile({
+          type: "asset",
+          fileName: configService.relativeAbsoluteSrcRoot(candidate.file),
+          source: candidate.buffer
+        });
+      }
+    }
+  };
+}
+function asset(ctx) {
+  const state = { ctx };
+  return [createAssetCollector(state)];
 }
 
 // src/plugins/autoImport.ts
@@ -21125,13 +21160,13 @@ function autoRoutes(ctx) {
 // src/plugins/core.ts
 init_esm_shims();
 import { isEmptyObject as isEmptyObject2, isObject as isObject6, removeExtensionDeep as removeExtensionDeep5 } from "@weapp-core/shared";
-import fs16 from "fs-extra";
+import fs17 from "fs-extra";
 import path26 from "pathe";
 
 // src/plugins/css/shared/preprocessor.ts
 init_esm_shims();
 import { createHash } from "crypto";
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 import path21 from "pathe";
 import { preprocessCSS } from "vite";
 
@@ -21301,7 +21336,7 @@ async function renderSharedStyleEntry(entry, _configService, resolvedConfig) {
   const cacheKey = `${absolutePath}:${resolvedConfig ? "resolved" : "raw"}`;
   let stats;
   try {
-    stats = await fs13.stat(absolutePath);
+    stats = await fs14.stat(absolutePath);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     throw new Error(`[subpackages] \u7F16\u8BD1\u5171\u4EAB\u6837\u5F0F \`${entry.source}\` \u5931\u8D25\uFF1A${reason}`);
@@ -21314,7 +21349,7 @@ async function renderSharedStyleEntry(entry, _configService, resolvedConfig) {
     };
   }
   try {
-    const css2 = await fs13.readFile(absolutePath, "utf8");
+    const css2 = await fs14.readFile(absolutePath, "utf8");
     if (!resolvedConfig) {
       const result2 = {
         css: css2,
@@ -21461,7 +21496,7 @@ function createJsonEmitManager(configService) {
 init_esm_shims();
 import { performance as performance3 } from "perf_hooks";
 import { removeExtensionDeep as removeExtensionDeep3 } from "@weapp-core/shared";
-import fs14 from "fs-extra";
+import fs15 from "fs-extra";
 
 // ../../node_modules/.pnpm/magic-string@0.30.21/node_modules/magic-string/dist/magic-string.es.mjs
 init_esm_shims();
@@ -22627,7 +22662,7 @@ async function addWatchTarget(pluginCtx, target, existsCache) {
     pluginCtx.addWatchFile(target);
     return cached;
   }
-  const exists = await fs14.exists(target);
+  const exists = await fs15.exists(target);
   pluginCtx.addWatchFile(target);
   existsCache.set(target, exists);
   return exists;
@@ -22819,7 +22854,7 @@ function createEntryLoader(options) {
         type: "plugin"
       });
     }
-    const code = await fs14.readFile(id, "utf8");
+    const code = await fs15.readFile(id, "utf8");
     const styleImports = await collectStyleImports(this, id, existsCache);
     debug4?.(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`);
     if (styleImports.length === 0) {
@@ -22842,22 +22877,6 @@ function createEntryLoader(options) {
 init_esm_shims();
 import { isObject as isObject5 } from "@weapp-core/shared";
 import path24 from "pathe";
-function createEntryNormalizer(configService) {
-  return function normalizeEntry(entry, jsonPath) {
-    if (/plugin:\/\//.test(entry)) {
-      return entry;
-    }
-    const tokens = entry.split("/");
-    if (tokens[0] && isObject5(configService.packageJson.dependencies) && hasDependencyPrefix(configService.packageJson.dependencies, tokens)) {
-      return `npm:${entry}`;
-    }
-    if (tokens[0] === "") {
-      return entry.substring(1);
-    }
-    const normalized = resolveImportee2(entry, jsonPath, configService);
-    return configService.relativeAbsoluteSrcRoot(normalized);
-  };
-}
 function resolveImportee2(importee, jsonPath, configService) {
   let updated = importee;
   if (jsonPath && Array.isArray(configService.aliasEntries)) {
@@ -22880,6 +22899,22 @@ function hasDependencyPrefix(dependencies, tokens) {
     return true;
   });
 }
+function createEntryNormalizer(configService) {
+  return function normalizeEntry(entry, jsonPath) {
+    if (/plugin:\/\//.test(entry)) {
+      return entry;
+    }
+    const tokens = entry.split("/");
+    if (tokens[0] && isObject5(configService.packageJson.dependencies) && hasDependencyPrefix(configService.packageJson.dependencies, tokens)) {
+      return `npm:${entry}`;
+    }
+    if (tokens[0] === "") {
+      return entry.substring(1);
+    }
+    const normalized = resolveImportee2(entry, jsonPath, configService);
+    return configService.relativeAbsoluteSrcRoot(normalized);
+  };
+}
 
 // src/plugins/hooks/useLoadEntry/template.ts
 init_esm_shims();
@@ -22956,15 +22991,19 @@ function collectRequireTokens(ast) {
 
 // src/plugins/utils/invalidateEntry.ts
 init_esm_shims();
-import fs15 from "fs";
+import fs16 from "fs";
 import process6 from "process";
 import path25 from "pathe";
 var watchedCssExts = new Set(supportedCssLangs.map((ext2) => `.${ext2}`));
+var watchedTemplateExts = new Set(templateExtensions.map((ext2) => `.${ext2}`));
 var configSuffixes = configExtensions.map((ext2) => `.${ext2}`);
-var sidecarSuffixes = [...configSuffixes, ...watchedCssExts];
+var sidecarSuffixes = [...configSuffixes, ...watchedCssExts, ...watchedTemplateExts];
 var watchLimitErrorCodes = /* @__PURE__ */ new Set(["EMFILE", "ENOSPC"]);
 var importProtocols = /^(?:https?:|data:|blob:|\/)/i;
-var cssImportRE = /@(import|wv-keep-import)\s+(?:url\()?['"]?([^'")\s]+)['"]?\)?/gi;
+var cssImportRE = /@(?:import|wv-keep-import)\s+(?:url\()?['"]?([^'")\s]+)['"]?\)?/gi;
+function isSidecarFile(filePath) {
+  return sidecarSuffixes.some((suffix) => filePath.endsWith(suffix));
+}
 function isWatchLimitError(error) {
   if (!error || typeof error !== "object") {
     return false;
@@ -23038,7 +23077,7 @@ function registerCssImports(ctx, importer, dependencies) {
 }
 async function extractCssImportDependencies(ctx, importer) {
   try {
-    const stats = await fs15.promises.stat(importer);
+    const stats = await fs16.promises.stat(importer);
     if (!stats.isFile()) {
       cleanupImporterGraph(ctx, importer);
       return;
@@ -23049,7 +23088,7 @@ async function extractCssImportDependencies(ctx, importer) {
   }
   let cssContent;
   try {
-    cssContent = await fs15.promises.readFile(importer, "utf8");
+    cssContent = await fs16.promises.readFile(importer, "utf8");
   } catch {
     cleanupImporterGraph(ctx, importer);
     return;
@@ -23062,7 +23101,7 @@ async function extractCssImportDependencies(ctx, importer) {
     if (!match2) {
       break;
     }
-    const rawSpecifier = match2[2]?.trim();
+    const rawSpecifier = match2[1]?.trim();
     if (!rawSpecifier) {
       continue;
     }
@@ -23172,6 +23211,8 @@ async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
     scriptBasePath = filePath.slice(0, -configSuffix.length);
   } else if (ext2 && watchedCssExts.has(ext2)) {
     scriptBasePath = filePath.slice(0, -ext2.length);
+  } else if (ext2 && watchedTemplateExts.has(ext2)) {
+    scriptBasePath = filePath.slice(0, -ext2.length);
   }
   if (!scriptBasePath) {
     return;
@@ -23192,6 +23233,7 @@ async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
     }
   }
   const isCssSidecar = Boolean(ext2 && watchedCssExts.has(ext2));
+  const isTemplateSidecar = Boolean(ext2 && watchedTemplateExts.has(ext2));
   const configService = ctx.configService;
   const relativeSource = configService.relativeCwd(normalizedPath);
   for (const target of touchedTargets) {
@@ -23207,7 +23249,7 @@ async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
     }
   }
   if (!touchedTargets.size && !touchedScripts.size) {
-    if (event === "create" && isCssSidecar) {
+    if (event === "create" && (isCssSidecar || isTemplateSidecar)) {
       logger_default.info(`[sidecar:${event}] ${relativeSource} \u65B0\u589E\uFF0C\u4F46\u672A\u627E\u5230\u5F15\u7528\u65B9\uFF0C\u7B49\u5F85\u540E\u7EED\u5173\u8054`);
     }
     return;
@@ -23228,7 +23270,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
   }
   const { sidecarWatcherMap } = ctx.runtimeState.watcher;
   const absRoot = path25.normalize(rootDir);
-  if (!fs15.existsSync(absRoot)) {
+  if (!fs16.existsSync(absRoot)) {
     return;
   }
   if (sidecarWatcherMap.has(absRoot)) {
@@ -23244,23 +23286,25 @@ function ensureSidecarWatcher(ctx, rootDir) {
     if (isCssFile && (event === "create" || event === "update")) {
       void extractCssImportDependencies(ctx, filePath);
     }
-    const shouldInvalidate = event === "create" && ready || event === "delete";
+    const isDeleteEvent = event === "delete";
+    const shouldInvalidate = event === "create" && ready || isDeleteEvent;
     if (shouldInvalidate) {
       void (async () => {
         await invalidateEntryForSidecar(ctx, filePath, event);
-        if (isCssFile && event === "delete") {
+        if (isCssFile && isDeleteEvent) {
           cleanupImporterGraph(ctx, filePath);
         }
       })();
       return;
     }
-    if (isCssFile && event === "delete") {
+    if (isCssFile && isDeleteEvent) {
       cleanupImporterGraph(ctx, filePath);
     }
   };
   const patterns = [
     ...configExtensions.map((ext2) => path25.join(absRoot, `**/*.${ext2}`)),
-    ...supportedCssLangs.map((ext2) => path25.join(absRoot, `**/*.${ext2}`))
+    ...supportedCssLangs.map((ext2) => path25.join(absRoot, `**/*.${ext2}`)),
+    ...templateExtensions.map((ext2) => path25.join(absRoot, `**/*.${ext2}`))
   ];
   const watcher = esm_default.watch(patterns, {
     ignoreInitial: false,
@@ -23270,11 +23314,15 @@ function ensureSidecarWatcher(ctx, rootDir) {
       pollInterval: 20
     }
   });
-  const forwardChange = (event, input) => {
+  const forwardChange = (event, input, options) => {
     if (!input) {
       return;
     }
-    handleSidecarChange(event, path25.normalize(input), isReady);
+    const normalizedPath = path25.normalize(input);
+    if (!options?.silent) {
+      logger_default.info(`[watch:${event}] ${ctx.configService.relativeCwd(normalizedPath)}`);
+    }
+    handleSidecarChange(event, normalizedPath, isReady);
   };
   watcher.on("add", (path36) => forwardChange("create", path36));
   watcher.on("change", (path36) => forwardChange("update", path36));
@@ -23289,7 +23337,11 @@ function ensureSidecarWatcher(ctx, rootDir) {
     }
     const baseDir = typeof details === "object" && details && "watchedPath" in details ? details.watchedPath ?? absRoot : absRoot;
     const resolved = path25.isAbsolute(candidate) ? candidate : path25.resolve(baseDir, candidate);
-    forwardChange("create", resolved);
+    const exists = fs16.existsSync(resolved);
+    const derivedEvent = exists ? "create" : "delete";
+    const relativeResolved = ctx.configService.relativeCwd(resolved);
+    logger_default.info(`[watch:rename->${derivedEvent}] ${relativeResolved}`);
+    forwardChange(derivedEvent, resolved, { silent: true });
   });
   watcher.on("ready", () => {
     isReady = true;
@@ -23306,9 +23358,6 @@ function ensureSidecarWatcher(ctx, rootDir) {
     close: () => void watcher.close()
   });
 }
-function isSidecarFile(filePath) {
-  return sidecarSuffixes.some((suffix) => filePath.endsWith(suffix));
-}
 
 // src/plugins/utils/parse.ts
 init_esm_shims();
@@ -23748,8 +23797,8 @@ function createCoreLifecyclePlugin(state) {
         if (parsed.query.wxss) {
           const realPath = getCssRealPath(parsed);
           this.addWatchFile(realPath);
-          if (await fs16.exists(realPath)) {
-            const css2 = await fs16.readFile(realPath, "utf8");
+          if (await fs17.exists(realPath)) {
+            const css2 = await fs17.readFile(realPath, "utf8");
             return { code: css2 };
           }
         }
@@ -23956,7 +24005,7 @@ async function flushIndependentBuilds(state) {
 
 // src/plugins/css.ts
 init_esm_shims();
-import fs17 from "fs-extra";
+import fs18 from "fs-extra";
 import path28 from "pathe";
 
 // src/plugins/css/shared/sharedStyles.ts
@@ -24174,7 +24223,7 @@ async function handleBundleEntry(bundle, bundleKey, asset2, configService, share
     }
     if (fileName && fileName !== bundleKey) {
       delete bundle[bundleKey];
-      const css2 = await fs17.readFile(absOriginal, "utf8");
+      const css2 = await fs18.readFile(absOriginal, "utf8");
       this.emitFile({
         type: "asset",
         fileName,
@@ -24235,7 +24284,7 @@ async function emitSharedStyleEntries(sharedStyles, emitted, configService, bund
       if (typeof this.addWatchFile === "function") {
         this.addWatchFile(absolutePath);
       }
-      if (!await fs17.pathExists(absolutePath)) {
+      if (!await fs18.pathExists(absolutePath)) {
         continue;
       }
       const { css: renderedCss, dependencies } = await renderSharedStyleEntry(entry, configService, resolvedConfig);
@@ -24338,9 +24387,6 @@ init_esm_shims();
 import { isObject as isObject7 } from "@weapp-core/shared";
 var debug3 = createDebugger("weapp-vite:preflight");
 var removePlugins = ["vite:build-import-analysis"];
-function preflight(ctx) {
-  return [createPluginPruner(), createEnvSynchronizer(ctx)];
-}
 function createPluginPruner() {
   return {
     name: "weapp-vite:preflight",
@@ -24373,18 +24419,35 @@ function createEnvSynchronizer({ configService }) {
     }
   };
 }
+function preflight(ctx) {
+  return [createPluginPruner(), createEnvSynchronizer(ctx)];
+}
 
 // src/plugins/workers.ts
 init_esm_shims();
 import { createHash as createHash2 } from "crypto";
 import { removeExtension as removeExtension2 } from "@weapp-core/shared";
-import fs18 from "fs-extra";
+import fs19 from "fs-extra";
 import path29 from "pathe";
-function workers(ctx) {
-  if (!ctx.scanService.workersDir) {
-    return [];
+async function resolveWorkerEntry(ctx, entry) {
+  const { configService, scanService } = ctx;
+  const relativeEntryPath = path29.join(scanService.workersDir, entry);
+  const key = removeExtension2(relativeEntryPath);
+  const absoluteEntry = path29.resolve(configService.absoluteSrcRoot, relativeEntryPath);
+  if (isJsOrTs(entry)) {
+    const exists = await fs19.exists(absoluteEntry);
+    if (!exists) {
+      logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
+      return { key };
+    }
+    return { key, value: absoluteEntry };
   }
-  return [createWorkerBuildPlugin(ctx)];
+  const { path: discovered } = await findJsEntry(absoluteEntry);
+  if (!discovered) {
+    logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
+    return { key };
+  }
+  return { key, value: discovered };
 }
 function createWorkerBuildPlugin(ctx) {
   const { configService, scanService } = ctx;
@@ -24417,86 +24480,26 @@ function createWorkerBuildPlugin(ctx) {
     }
   };
 }
-async function resolveWorkerEntry(ctx, entry) {
-  const { configService, scanService } = ctx;
-  const relativeEntryPath = path29.join(scanService.workersDir, entry);
-  const key = removeExtension2(relativeEntryPath);
-  const absoluteEntry = path29.resolve(configService.absoluteSrcRoot, relativeEntryPath);
-  if (isJsOrTs(entry)) {
-    const exists = await fs18.exists(absoluteEntry);
-    if (!exists) {
-      logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
-      return { key };
-    }
-    return { key, value: absoluteEntry };
-  }
-  const { path: discovered } = await findJsEntry(absoluteEntry);
-  if (!discovered) {
-    logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
-    return { key };
+function workers(ctx) {
+  if (!ctx.scanService.workersDir) {
+    return [];
   }
-  return { key, value: discovered };
+  return [createWorkerBuildPlugin(ctx)];
 }
 
 // src/plugins/wxs.ts
 init_esm_shims();
 import { removeExtension as removeExtension3 } from "@weapp-core/shared";
-import fs19 from "fs-extra";
+import fs20 from "fs-extra";
 import path30 from "pathe";
 var wxsCodeCache = new LRUCache({
   max: 512
 });
-function wxs(ctx) {
-  const state = {
-    ctx,
-    wxsMap: /* @__PURE__ */ new Map()
-  };
-  return [createWxsPlugin(state)];
-}
-function createWxsPlugin(state) {
-  const { ctx } = state;
-  const { wxmlService } = ctx;
-  return {
-    name: "weapp-vite:wxs",
-    enforce: "pre",
-    buildStart() {
-      state.wxsMap.clear();
-    },
-    async buildEnd() {
-      await Promise.all(
-        Array.from(wxmlService.tokenMap.entries()).map(([id, token]) => {
-          return handleWxsDeps.call(
-            // @ts-ignore rolldown context
-            this,
-            state,
-            token.deps,
-            id
-          );
-        })
-      );
-      for (const { emittedFile } of state.wxsMap.values()) {
-        this.emitFile(emittedFile);
-      }
-    }
-  };
-}
-async function handleWxsDeps(state, deps, absPath) {
-  await Promise.all(
-    deps.filter((dep) => dep.tagName === "wxs").map(async (dep) => {
-      const arr = dep.value.match(/\.wxs(\.[jt]s)?$/);
-      if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
-        return;
-      }
-      const wxsPath = path30.resolve(path30.dirname(absPath), dep.value);
-      await transformWxsFile.call(this, state, wxsPath);
-    })
-  );
-}
 async function transformWxsFile(state, wxsPath) {
   const { ctx } = state;
   const { configService } = ctx;
   this.addWatchFile(wxsPath);
-  if (!await fs19.exists(wxsPath)) {
+  if (!await fs20.exists(wxsPath)) {
     return;
   }
   const suffixMatch = wxsPath.match(/\.wxs(\.[jt]s)?$/);
@@ -24504,7 +24507,7 @@ async function transformWxsFile(state, wxsPath) {
   if (suffixMatch) {
     isRaw = !suffixMatch[1];
   }
-  const rawCode = await fs19.readFile(wxsPath, "utf8");
+  const rawCode = await fs20.readFile(wxsPath, "utf8");
   let code = wxsCodeCache.get(rawCode);
   if (code === void 0) {
     const { result, importees } = transformWxsCode(rawCode, {
@@ -24538,6 +24541,52 @@ async function transformWxsFile(state, wxsPath) {
   });
   wxsCodeCache.set(rawCode, code);
 }
+async function handleWxsDeps(state, deps, absPath) {
+  await Promise.all(
+    deps.filter((dep) => dep.tagName === "wxs").map(async (dep) => {
+      const arr = dep.value.match(/\.wxs(\.[jt]s)?$/);
+      if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
+        return;
+      }
+      const wxsPath = path30.resolve(path30.dirname(absPath), dep.value);
+      await transformWxsFile.call(this, state, wxsPath);
+    })
+  );
+}
+function createWxsPlugin(state) {
+  const { ctx } = state;
+  const { wxmlService } = ctx;
+  return {
+    name: "weapp-vite:wxs",
+    enforce: "pre",
+    buildStart() {
+      state.wxsMap.clear();
+    },
+    async buildEnd() {
+      await Promise.all(
+        Array.from(wxmlService.tokenMap.entries()).map(([id, token]) => {
+          return handleWxsDeps.call(
+            // @ts-ignore rolldown context
+            this,
+            state,
+            token.deps,
+            id
+          );
+        })
+      );
+      for (const { emittedFile } of state.wxsMap.values()) {
+        this.emitFile(emittedFile);
+      }
+    }
+  };
+}
+function wxs(ctx) {
+  const state = {
+    ctx,
+    wxsMap: /* @__PURE__ */ new Map()
+  };
+  return [createWxsPlugin(state)];
+}
 
 // src/plugins/index.ts
 var RUNTIME_PLUGINS_SYMBOL = Symbol.for("weapp-runtime:plugins");
@@ -25010,7 +25059,7 @@ init_esm_shims();
 import { createRequire as createRequire3 } from "module";
 import process8 from "process";
 import { parse as parseJson2 } from "comment-json";
-import fs20 from "fs-extra";
+import fs21 from "fs-extra";
 import { bundleRequire } from "rolldown-require";
 function parseCommentJson(json) {
   return parseJson2(json, void 0, true);
@@ -25075,7 +25124,7 @@ function createJsonService(ctx) {
         });
         resultJson = typeof mod.default === "function" ? await mod.default(ctx) : mod.default;
       } else {
-        resultJson = parseCommentJson(await fs20.readFile(filepath, "utf8"));
+        resultJson = parseCommentJson(await fs21.readFile(filepath, "utf8"));
       }
       cache2.set(filepath, resultJson);
       return resultJson;
@@ -25108,7 +25157,7 @@ function createJsonServicePlugin(ctx) {
 init_esm_shims();
 import { isBuiltin } from "module";
 import { defu as defu6, isObject as isObject8, objectHash } from "@weapp-core/shared";
-import fs21 from "fs-extra";
+import fs22 from "fs-extra";
 import path33 from "pathe";
 import { build as tsdownBuild } from "tsdown";
 function createNpmService(ctx) {
@@ -25130,22 +25179,22 @@ function createNpmService(ctx) {
     return Reflect.has(pkg, "miniprogram") && typeof pkg.miniprogram === "string";
   }
   async function shouldSkipBuild(outDir, isOutdated) {
-    return !isOutdated && await fs21.exists(outDir);
+    return !isOutdated && await fs22.exists(outDir);
   }
   async function writeDependenciesCache(root) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
     if (ctx.configService.weappViteConfig?.npm?.cache) {
-      await fs21.outputJSON(getDependenciesCacheFilePath(root), {
+      await fs22.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
     }
   }
   async function readDependenciesCache(root) {
     const cachePath = getDependenciesCacheFilePath(root);
-    if (await fs21.exists(cachePath)) {
-      return await fs21.readJson(cachePath, { throws: false });
+    if (await fs22.exists(cachePath)) {
+      return await fs22.readJson(cachePath, { throws: false });
     }
   }
   async function checkDependenciesCacheOutdate(root) {
@@ -25209,7 +25258,7 @@ function createNpmService(ctx) {
     }
   }
   async function copyBuild({ from, to }) {
-    await fs21.copy(
+    await fs22.copy(
       from,
       to
     );
@@ -25302,8 +25351,8 @@ function createNpmService(ctx) {
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
     const packageJsonPath = path33.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
-    if (await fs21.exists(packageJsonPath)) {
-      const pkgJson = await fs21.readJson(packageJsonPath);
+    if (await fs22.exists(packageJsonPath)) {
+      const pkgJson = await fs22.readJson(packageJsonPath);
       const outDir = path33.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
       if (pkgJson.dependencies) {
         const dependencies = Object.keys(pkgJson.dependencies);
@@ -25338,8 +25387,8 @@ function createNpmService(ctx) {
           await Promise.all(targetDirs.map(async (x) => {
             if (x.root) {
               const isDependenciesCacheOutdate2 = await checkDependenciesCacheOutdate(x.root);
-              if (isDependenciesCacheOutdate2 || !await fs21.exists(x.npmDistDir)) {
-                await fs21.copy(outDir, x.npmDistDir, {
+              if (isDependenciesCacheOutdate2 || !await fs22.exists(x.npmDistDir)) {
+                await fs22.copy(outDir, x.npmDistDir, {
                   overwrite: true,
                   filter: (src) => {
                     if (Array.isArray(x.dependencies)) {
@@ -25355,7 +25404,7 @@ function createNpmService(ctx) {
               }
               await writeDependenciesCache(x.root);
             } else {
-              await fs21.copy(outDir, x.npmDistDir, {
+              await fs22.copy(outDir, x.npmDistDir, {
                 overwrite: true,
                 filter: (src) => {
                   if (Array.isArray(x.dependencies)) {
@@ -26112,7 +26161,7 @@ init_esm_shims();
 
 // src/cache/file.ts
 init_esm_shims();
-import fs22 from "fs-extra";
+import fs23 from "fs-extra";
 var FNV_OFFSET_BASIS = 0xCBF29CE484222325n;
 var FNV_PRIME = 0x100000001B3n;
 var FNV_MASK = 0xFFFFFFFFFFFFFFFFn;
@@ -26162,7 +26211,7 @@ var FileCache = class {
   async isInvalidate(id, options) {
     let mtimeMs;
     try {
-      const stat6 = await fs22.stat(id);
+      const stat6 = await fs23.stat(id);
       mtimeMs = stat6.mtimeMs;
     } catch (error) {
       if (error && error.code === "ENOENT") {
@@ -26324,7 +26373,7 @@ function createRuntimeState() {
 // src/runtime/scanPlugin.ts
 init_esm_shims();
 import { isObject as isObject9, removeExtensionDeep as removeExtensionDeep6 } from "@weapp-core/shared";
-import fs23 from "fs-extra";
+import fs24 from "fs-extra";
 import path34 from "pathe";
 var SUPPORTED_SHARED_STYLE_EXTENSIONS = [
   ".wxss",
@@ -26562,7 +26611,7 @@ function appendDefaultScopedStyleEntries(root, normalizedRoot, service, dedupe,
     for (const ext2 of DEFAULT_SCOPED_EXTENSIONS) {
       const filename = `${base}${ext2}`;
       const absolutePath = path34.resolve(absoluteSubRoot, filename);
-      if (!fs23.existsSync(absolutePath)) {
+      if (!fs24.existsSync(absolutePath)) {
         continue;
       }
       const descriptor = {
@@ -26607,7 +26656,7 @@ function normalizeSubPackageStyleEntries(styles, subPackage, configService) {
       logger_default.warn(`[subpackages] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u89E3\u6790\u5931\u8D25\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
     }
-    if (!fs23.existsSync(absolutePath)) {
+    if (!fs24.existsSync(absolutePath)) {
       logger_default.warn(`[subpackages] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u5BF9\u5E94\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
     }
@@ -26953,7 +27002,7 @@ function createWebServicePlugin(ctx) {
 // src/runtime/wxmlPlugin.ts
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep7 } from "@weapp-core/shared";
-import fs24 from "fs-extra";
+import fs25 from "fs-extra";
 import path35 from "pathe";
 
 // src/wxml/index.ts
@@ -29661,9 +29710,9 @@ function createWxmlService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning wxml");
     }
-    if (await fs24.exists(filepath)) {
+    if (await fs25.exists(filepath)) {
       const dirname5 = path35.dirname(filepath);
-      const wxml = await fs24.readFile(filepath, "utf8");
+      const wxml = await fs25.readFile(filepath, "utf8");
       const shouldRescan = await cache2.isInvalidate(filepath, { content: wxml });
       if (!shouldRescan) {
         const cached = cache2.get(filepath);