weapp-vite 6.18.1 → 6.18.3

package/dist/{createContext-qv1RyqpU.mjs → createContext-D0jhm5Nj.mjs}

@@ -1,6 +1,6 @@
 import { n as applyWeappViteHostMeta } from "./pluginHost--CaeyWpA.mjs";
 import { n as configureLogger, r as logger_default } from "./logger-mt4mSTqV.mjs";
-import { _ as jsExtensions, a as findJsonEntry, b as vueExtensions, c as isJsOrTs, d as touch, g as configExtensions, i as findJsEntry, l as isTemplate, n as changeFileExtension, o as findTemplateEntry, p as inlineAutoRoutesImports, r as findCssEntry, s as findVueEntry, t as extractConfigFromVue, v as supportedCssLangs, y as templateExtensions } from "./file-Dva0fkcv.mjs";
+import { _ as jsExtensions, a as findJsonEntry, b as vueExtensions, c as isJsOrTs, d as touch, g as configExtensions, i as findJsEntry, l as isTemplate, n as changeFileExtension, o as findTemplateEntry, p as inlineAutoRoutesImports, r as findCssEntry, s as findVueEntry, t as extractConfigFromVue, v as supportedCssLangs, y as templateExtensions } from "./file-BFzjMcYM.mjs";
 import { createRequire, isBuiltin } from "node:module";
 import path, { posix } from "pathe";
 import path$1, { normalize, relative, win32 } from "node:path";
@@ -14,12 +14,12 @@ import fs$1, { existsSync, readFileSync } from "node:fs";
 import { compileScript, parse } from "vue/compiler-sfc";
 import { BABEL_TS_MODULE_PARSER_OPTIONS, generate, getVisitorKeys, parse as parse$2, parseJsLike, traverse } from "@weapp-vite/ast/babel";
 import pm from "picomatch";
-import { VUE_COMPONENT_TAG_RE, WE_VU_INTERNAL_REACTIVITY_MODULE_ID, WE_VU_INTERNAL_RUNTIME_MODULE_ID, WE_VU_INTERNAL_TEMPLATE_MODULE_ID, WE_VU_RUNTIME_APIS, buildClassStyleComputedCode, collectVueTemplateTags, compileJsxFile, compileVueFile, compileVueStyleToWxss, createJsonMerger, createPageEntryMatcher, createPageEntryMatcher as createPageEntryMatcher$1, generateScopedId, getClassStyleWxsSource, getMiniProgramTemplatePlatform, getSfcCheckMtime, injectWevuPageFeaturesInJsWithResolver, invalidateFileCache, isAutoImportCandidateTag, isBuiltinComponent, pathExists, readAndParseSfc, readFile as readFile$1, resolveClassStyleWxsLocation, stripJsonMacroCallsFromCode } from "wevu/compiler";
+import { VUE_COMPONENT_TAG_RE, WE_VU_INTERNAL_REACTIVITY_MODULE_ID, WE_VU_INTERNAL_RUNTIME_MODULE_ID, WE_VU_INTERNAL_TEMPLATE_MODULE_ID, WE_VU_RUNTIME_APIS, buildClassStyleComputedCode, collectVueTemplateTags, compileJsxFile, compileVueFile, compileVueStyleToWxss, createJsonMerger, createPageEntryMatcher, createPageEntryMatcher as createPageEntryMatcher$1, generateScopedId, getClassStyleWxsSource, getMiniProgramTemplatePlatform, getSfcCheckMtime, injectWevuPageFeaturesInJsWithResolver, invalidateFileCache, isAutoImportCandidateTag, isBuiltinComponent, pathExists, readAndParseSfc, readFile as readFile$1, refreshVueFileJsonConfig, resolveClassStyleWxsLocation, stripJsonMacroCallsFromCode } from "wevu/compiler";
 import process from "node:process";
 import { parse as parse$1, stringify } from "comment-json";
 import fs$2, { appendFile, copyFile, mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { build, createLogger, createServer, loadConfigFromFile, preprocessCSS, transformWithOxc } from "vite";
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import semverGte from "semver/functions/gte.js";
 import semverSatisfies from "semver/functions/satisfies.js";
@@ -33,7 +33,7 @@ import os from "node:os";
 import { getPackageInfo, getPackageInfoSync, resolveModule } from "local-pkg";
 import { spawn } from "node:child_process";
 import PQueue from "p-queue";
-import { APP_PRELUDE_CHUNK_MARKER, APP_PRELUDE_GUARD_KEY, APP_PRELUDE_REQUIRE_MARKER, REQUEST_GLOBAL_ACTUALS_KEY, REQUEST_GLOBAL_BUNDLE_HOST_REF, REQUEST_GLOBAL_BUNDLE_MARKER, REQUEST_GLOBAL_CHUNK_HOST_REF, REQUEST_GLOBAL_CHUNK_MODULE_REF, REQUEST_GLOBAL_EXPOSE_HELPER, REQUEST_GLOBAL_INSTALLER_HOST_REF, REQUEST_GLOBAL_LAZY_CONSTRUCTOR_HELPER, REQUEST_GLOBAL_LAZY_FUNCTION_HELPER, REQUEST_GLOBAL_LOCAL_BINDINGS_MARKER, REQUEST_GLOBAL_MARK_PLACEHOLDER_HELPER, REQUEST_GLOBAL_PASSIVE_BINDINGS_MARKER, REQUEST_GLOBAL_PASSIVE_BINDINGS_MARKER as REQUEST_GLOBAL_PASSIVE_BINDINGS_MARKER$1, REQUEST_GLOBAL_PLACEHOLDER_KEY, REQUEST_GLOBAL_PRELUDE_GUARD_KEY, REQUEST_GLOBAL_PRELUDE_MARKER, REQUEST_GLOBAL_SYNTHETIC_EXPORT_NAME, REQUEST_GLOBAL_USABLE_CONSTRUCTOR_HELPER, WEAPP_VITE_IMPORT_META_ENV_KEY, WEAPP_VITE_INJECTED_API_IDENTIFIER, WEVU_APP_SHELL_COMPONENT_BASE, WEVU_APP_SHELL_TAG_NAME, WEVU_EXPRESSION_ERROR_IDENTIFIER, WEVU_INTERNAL_KEY_IDENTIFIER, WEVU_LAYOUT_BIND_PREFIX, WEVU_PAGE_LAYOUT_CURRENT_NAME_IDENTIFIER, WEVU_PAGE_LAYOUT_CURRENT_PROPS_IDENTIFIER, WEVU_PAGE_LAYOUT_NAME_KEY, WEVU_PAGE_LAYOUT_NEXT_NAME_IDENTIFIER, WEVU_PAGE_LAYOUT_NEXT_PROPS_IDENTIFIER, WEVU_PAGE_LAYOUT_NONE, WEVU_PAGE_LAYOUT_PROPS_KEY, WEVU_PAGE_LAYOUT_SETTER_KEY, WEVU_SCOPED_SLOT_CREATOR_KEY, WEVU_SLOT_FALLBACK_VIRTUAL_HOST_BASE, WEVU_SLOT_FALLBACK_VIRTUAL_HOST_GLOBAL_PATH, WEVU_SLOT_FALLBACK_VIRTUAL_HOST_TAG_NAME, WEVU_SLOT_NAMES_PROP, WEVU_SLOT_OWNER_ID_ATTR, WEVU_SLOT_OWNER_ID_KEY, WEVU_SLOT_OWNER_ID_PROP, WEVU_SLOT_PROPS_ATTR, WEVU_SLOT_SCOPE_ATTR, WEVU_SLOT_SCOPE_KEY } from "@weapp-core/constants";
+import { APP_PRELUDE_CHUNK_MARKER, APP_PRELUDE_GUARD_KEY, APP_PRELUDE_REQUIRE_MARKER, REQUEST_GLOBAL_ACTUALS_KEY, REQUEST_GLOBAL_BUNDLE_HOST_REF, REQUEST_GLOBAL_BUNDLE_MARKER, REQUEST_GLOBAL_CHUNK_HOST_REF, REQUEST_GLOBAL_CHUNK_MODULE_REF, REQUEST_GLOBAL_EXPOSE_HELPER, REQUEST_GLOBAL_INSTALLER_HOST_REF, REQUEST_GLOBAL_LAZY_CONSTRUCTOR_HELPER, REQUEST_GLOBAL_LAZY_FUNCTION_HELPER, REQUEST_GLOBAL_LOCAL_BINDINGS_MARKER, REQUEST_GLOBAL_MARK_PLACEHOLDER_HELPER, REQUEST_GLOBAL_PASSIVE_BINDINGS_MARKER, REQUEST_GLOBAL_PASSIVE_BINDINGS_MARKER as REQUEST_GLOBAL_PASSIVE_BINDINGS_MARKER$1, REQUEST_GLOBAL_PLACEHOLDER_KEY, REQUEST_GLOBAL_PRELUDE_GUARD_KEY, REQUEST_GLOBAL_PRELUDE_MARKER, REQUEST_GLOBAL_SYNTHETIC_EXPORT_NAME, REQUEST_GLOBAL_USABLE_CONSTRUCTOR_HELPER, WEAPP_VITE_IMPORT_META_ENV_KEY, WEAPP_VITE_INJECTED_API_IDENTIFIER, WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY, WEAPP_VITE_STATEFUL_HMR_CLIENT_KEY, WEAPP_VITE_STATEFUL_HMR_CONTROL_FILE, WEAPP_VITE_STATEFUL_HMR_CONTROL_KEY, WEAPP_VITE_STATEFUL_HMR_PRELOAD_FILE, WEAPP_VITE_STATEFUL_HMR_UPDATE_FILE, WEVU_APP_SHELL_COMPONENT_BASE, WEVU_APP_SHELL_TAG_NAME, WEVU_EXPRESSION_ERROR_IDENTIFIER, WEVU_INTERNAL_KEY_IDENTIFIER, WEVU_LAYOUT_BIND_PREFIX, WEVU_PAGE_LAYOUT_CURRENT_NAME_IDENTIFIER, WEVU_PAGE_LAYOUT_CURRENT_PROPS_IDENTIFIER, WEVU_PAGE_LAYOUT_NAME_KEY, WEVU_PAGE_LAYOUT_NEXT_NAME_IDENTIFIER, WEVU_PAGE_LAYOUT_NEXT_PROPS_IDENTIFIER, WEVU_PAGE_LAYOUT_NONE, WEVU_PAGE_LAYOUT_PROPS_KEY, WEVU_PAGE_LAYOUT_SETTER_KEY, WEVU_SCOPED_SLOT_CREATOR_KEY, WEVU_SLOT_FALLBACK_VIRTUAL_HOST_BASE, WEVU_SLOT_FALLBACK_VIRTUAL_HOST_GLOBAL_PATH, WEVU_SLOT_FALLBACK_VIRTUAL_HOST_TAG_NAME, WEVU_SLOT_NAMES_PROP, WEVU_SLOT_OWNER_ID_ATTR, WEVU_SLOT_OWNER_ID_KEY, WEVU_SLOT_OWNER_ID_PROP, WEVU_SLOT_PROPS_ATTR, WEVU_SLOT_SCOPE_ATTR, WEVU_SLOT_SCOPE_KEY } from "@weapp-core/constants";
 import { Buffer } from "node:buffer";
 import MagicString from "magic-string";
 import babelPresetEnv from "@babel/preset-env";
@@ -8081,6 +8081,7 @@ function getWeappViteConfig() {
 			alipayNpmMode: "node_modules"
 		},
 		hmr: {
+			runtime: "classic",
 			sharedChunks: "auto",
 			touchAppWxss: "auto",
 			logLevel: "default",
@@ -8355,6 +8356,66 @@ function createRuntimeState() {
 	};
 }
 //#endregion
+//#region src/runtime/resetRuntimeState.ts
+function resetRuntimeStateForFreshBuild(runtimeState) {
+	const fresh = createRuntimeState();
+	const autoRoutes = runtimeState.autoRoutes;
+	autoRoutes.routes = fresh.autoRoutes.routes;
+	autoRoutes.serialized = fresh.autoRoutes.serialized;
+	autoRoutes.moduleCode = fresh.autoRoutes.moduleCode;
+	autoRoutes.typedDefinition = fresh.autoRoutes.typedDefinition;
+	autoRoutes.watchFiles.clear();
+	autoRoutes.watchDirs.clear();
+	autoRoutes.dirty = fresh.autoRoutes.dirty;
+	autoRoutes.initialized = fresh.autoRoutes.initialized;
+	autoRoutes.candidates.clear();
+	autoRoutes.needsFullRescan = fresh.autoRoutes.needsFullRescan;
+	autoRoutes.loadingAppConfig = fresh.autoRoutes.loadingAppConfig;
+	const autoImport = runtimeState.autoImport;
+	autoImport.registry.clear();
+	autoImport.resolvedResolverComponents.clear();
+	autoImport.matcher = void 0;
+	autoImport.matcherKey = fresh.autoImport.matcherKey;
+	autoImport.version += 1;
+	autoImport.pendingEntriesByImporter.clear();
+	runtimeState.build.hmr = fresh.build.hmr;
+	const json = runtimeState.json;
+	json.cache.cache.clear();
+	json.cache.mtimeMap.clear();
+	json.cache.signatureMap.clear();
+	json.emittedSource.clear();
+	const asset = runtimeState.asset;
+	asset.emittedBuffer.clear();
+	asset.scopedSlotGenerics.clear();
+	const css = runtimeState.css;
+	css.importerToDependencies.clear();
+	css.dependencyToImporters.clear();
+	css.emittedSource.clear();
+	const wxml = runtimeState.wxml;
+	wxml.depsMap.clear();
+	wxml.importerMap.clear();
+	wxml.tokenMap.clear();
+	wxml.componentsMap.clear();
+	wxml.aggregatedComponentsMap.clear();
+	wxml.templatePathMap.clear();
+	wxml.cache.cache.clear();
+	wxml.cache.mtimeMap.clear();
+	wxml.cache.signatureMap.clear();
+	wxml.emittedCode.clear();
+	const scan = runtimeState.scan;
+	scan.subPackageMap.clear();
+	scan.independentSubPackageMap.clear();
+	scan.warnedMessages.clear();
+	scan.appEntry = void 0;
+	scan.pluginJson = void 0;
+	scan.pluginJsonPath = void 0;
+	scan.isDirty = fresh.scan.isDirty;
+	scan.independentDirtyRoots.clear();
+	const lib = runtimeState.lib;
+	lib.enabled = fresh.lib.enabled;
+	lib.entries.clear();
+}
+//#endregion
 //#region src/plugins/core/lifecycle/emit/constants.ts
 const PRETTY_NODE_MODULES_RE = /node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?(.+)/;
 const REQUEST_GLOBAL_EXPORT_RE = /Object\.defineProperty\(exports,\s*(?:`([^`]+)`|'([^']+)'|"([^"]+)"),\s*\{[\s\S]*?get:function\(\)\{return ([A-Za-z_$][\w$]*)\}\}\)/g;
@@ -9820,6 +9881,1092 @@ function createSharedBuildConfig(configService, scanService) {
 	return { build: { rolldownOptions: { output: createSharedBuildOutput(configService, () => scanService.subPackageMap.keys()) } } };
 }
 //#endregion
+//#region src/runtime/statefulHmr/outputWriter.ts
+/**
+* @description 通过独立的 Vite write 阶段持久化 DevEngine 已生成的文件，不重新解析业务源码。
+*/
+async function writeStatefulHmrOutput(outDir, output) {
+	const virtualEntry = "\0weapp-vite-stateful-hmr-output";
+	await build({
+		configFile: false,
+		logLevel: "silent",
+		build: {
+			emptyOutDir: false,
+			minify: false,
+			outDir,
+			rolldownOptions: { input: virtualEntry },
+			write: true
+		},
+		plugins: [{
+			name: "weapp-vite:stateful-hmr-output-writer",
+			resolveId(id) {
+				return id === virtualEntry ? virtualEntry : void 0;
+			},
+			load(id) {
+				return id === virtualEntry ? "export {}" : void 0;
+			},
+			buildStart() {
+				for (const item of output) this.emitFile({
+					type: "asset",
+					fileName: item.fileName.replaceAll("\\", "/"),
+					source: item.type === "chunk" ? item.code : item.source
+				});
+			},
+			generateBundle(_options, bundle) {
+				for (const [fileName, item] of Object.entries(bundle)) if (item.type === "chunk" && item.facadeModuleId === virtualEntry) delete bundle[fileName];
+			}
+		}],
+		root: path$1.dirname(outDir)
+	});
+}
+//#endregion
+//#region src/runtime/statefulHmr/runtimeSource.ts
+const statefulHmrRolldownRuntimeSource = `
+var BaseDevRuntime = DevRuntime;
+class WeappViteHotContext {
+  callbacks = [];
+  data = {};
+  _internal = { updateStyle() {}, removeStyle() {} };
+  constructor(moduleId) { this.moduleId = moduleId; }
+  accept(...args) {
+    if (args.length === 0) this.callbacks.push({ deps: this.moduleId, callback: undefined });
+    else if (args.length === 1 && typeof args[0] === 'function') this.callbacks.push({ deps: this.moduleId, callback: args[0] });
+    else if (args.length === 1) this.callbacks.push({ deps: args[0], callback: undefined });
+    else this.callbacks.push({ deps: args[0], callback: args[1] });
+  }
+  acceptExports(_exports, callback) { this.accept(callback); }
+  dispose() {}
+  prune() {}
+  invalidate() {}
+  on() {}
+  off() {}
+  send() {}
+}
+class WeappViteDevRuntime extends BaseDevRuntime {
+  contexts = new Map();
+  patchedModules = new Set();
+  applyingPatch = false;
+  currentModuleId = '';
+  registrationModuleId = '';
+  createEsmInitializer = (id, initialize, _deduplicate, result) => () => {
+    if (!initialize) return result;
+    if (!this.applyingPatch && this.patchedModules.has(id)) return result;
+    const callback = initialize;
+    initialize = undefined;
+    const previousId = this.currentModuleId;
+    this.currentModuleId = id;
+    try { result = callback(id); }
+    finally { this.currentModuleId = previousId; }
+    if (this.applyingPatch) this.patchedModules.add(id);
+    return result;
+  };
+  createCjsInitializer = (id, initialize, _deduplicate, module) => () => {
+    if (module) return module.exports;
+    if (!this.applyingPatch && this.patchedModules.has(id)) return this.loadExports(id);
+    module = { exports: {} };
+    const previousId = this.currentModuleId;
+    this.currentModuleId = id;
+    try { initialize(module.exports, module, id); }
+    finally { this.currentModuleId = previousId; }
+    if (this.applyingPatch) this.patchedModules.add(id);
+    return module.exports;
+  };
+  createModuleHotContext(moduleId) {
+    const previous = this.contexts.get(moduleId);
+    const context = new WeappViteHotContext(moduleId);
+    if (previous) {
+      context.callbacks = previous.callbacks;
+      context.data = previous.data;
+    }
+    this.contexts.set(moduleId, context);
+    return context;
+  }
+  registerModule(id, exportsHolder) {
+    this.registrationModuleId = id;
+    return super.registerModule(id, exportsHolder);
+  }
+  beginPatch() { this.applyingPatch = true; }
+  endPatch() { this.applyingPatch = false; }
+  applyUpdates(boundaries) {
+    for (const [boundary, acceptedVia] of boundaries) {
+      const context = this.contexts.get(boundary);
+      if (!context) continue;
+      const callbacks = [...context.callbacks];
+      if (boundary === acceptedVia) context.callbacks = [];
+      for (const { deps, callback } of callbacks) {
+        if (!callback) continue;
+        if (Array.isArray(deps)) {
+          if (deps.includes(acceptedVia)) callback(deps.map((id) => this.loadExports(id)));
+        } else if (deps === acceptedVia) callback(this.loadExports(acceptedVia));
+      }
+    }
+  }
+}
+const runtime = new WeappViteDevRuntime(undefined, 'weapp-vite-stateful');
+globalThis.__rolldown_runtime__ = runtime;
+const bridgeKey = ${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)};
+const definitions = new Map();
+const registered = new Set();
+const instances = new Map();
+const pendingNativeDefinitions = new Map();
+const wevuRefreshes = new Map();
+const wevuRefreshGenerations = new Map();
+const wevuInstanceGenerations = new WeakMap();
+let suppressLifecycles = false;
+const nativeRegistrations = {};
+function getInstances(moduleId) {
+  let values = instances.get(moduleId);
+  if (!values) instances.set(moduleId, values = new Set());
+  return values;
+}
+function refreshWevuInstance(instance, moduleId) {
+  if (!instance || (typeof instance !== 'object' && typeof instance !== 'function')) return;
+  const generation = wevuRefreshGenerations.get(moduleId) || 0;
+  if (generation === 0) return;
+  let generations = wevuInstanceGenerations.get(instance);
+  if (generations?.get(moduleId) === generation) return;
+  const refresh = wevuRefreshes.get(moduleId);
+  if (typeof refresh !== 'function') return;
+  refresh(instance);
+  if (!generations) wevuInstanceGenerations.set(instance, generations = new Map());
+  generations.set(moduleId, generation);
+}
+function proxyFunction(moduleId, path, fallback) {
+  return function (...args) {
+    if (suppressLifecycles && /(?:created|attached|ready|detached|onLoad|onShow|onHide|onUnload)$/.test(path)) return;
+    const definition = definitions.get(moduleId);
+    const segments = path.split('.');
+    let value = definition;
+    for (const segment of segments) value = value && value[segment];
+    return (typeof value === 'function' ? value : fallback)?.apply(this, args);
+  };
+}
+function decorateObject(value, moduleId, prefix = '') {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value;
+  const result = { ...value };
+  for (const [key, child] of Object.entries(value)) {
+    const path = prefix ? prefix + '.' + key : key;
+    if (typeof child === 'function') result[key] = proxyFunction(moduleId, path, child);
+    else if (child && typeof child === 'object' && ['lifetimes', 'methods', 'pageLifetimes'].includes(key)) {
+      result[key] = decorateObject(child, moduleId, path);
+    }
+  }
+  if (!prefix && typeof value.onLoad === 'function') {
+    const onLoad = result.onLoad;
+    result.onLoad = function (...args) {
+      getInstances(moduleId).add(this);
+      return onLoad.apply(this, args);
+    };
+  }
+  if (!prefix && result.lifetimes && typeof result.lifetimes === 'object') {
+    const attached = result.lifetimes.attached;
+    const detached = result.lifetimes.detached;
+    result.lifetimes = { ...result.lifetimes };
+    if (typeof attached === 'function') {
+      result.lifetimes.attached = function (...args) {
+        getInstances(moduleId).add(this);
+        return attached.apply(this, args);
+      };
+    }
+    if (typeof detached === 'function') {
+      result.lifetimes.detached = function (...args) {
+        getInstances(moduleId).delete(this);
+        return detached.apply(this, args);
+      };
+    }
+  }
+  return result;
+}
+function decorateWevuComponent(definition, moduleId) {
+  const result = { ...definition };
+  const methods = { ...(definition.methods || {}) };
+  for (const [name, method] of Object.entries(methods)) {
+    if (typeof method !== 'function') continue;
+    methods[name] = function (...args) {
+      getInstances(moduleId).add(this);
+      refreshWevuInstance(this, moduleId);
+      return method.apply(this, args);
+    };
+  }
+  result.methods = methods;
+  const onLoad = definition.onLoad;
+  const onUnload = definition.onUnload;
+  if (typeof onLoad === 'function') {
+    result.onLoad = function (...args) {
+      getInstances(moduleId).add(this);
+      return onLoad.apply(this, args);
+    };
+  }
+  if (typeof onUnload === 'function') {
+    result.onUnload = function (...args) {
+      getInstances(moduleId).delete(this);
+      return onUnload.apply(this, args);
+    };
+  }
+  const lifetimes = { ...(definition.lifetimes || {}) };
+  const attached = lifetimes.attached;
+  const detached = lifetimes.detached;
+  lifetimes.attached = function (...args) {
+    getInstances(moduleId).add(this);
+    return attached?.apply(this, args);
+  };
+  lifetimes.detached = function (...args) {
+    getInstances(moduleId).delete(this);
+    return detached?.apply(this, args);
+  };
+  return { ...result, lifetimes };
+}
+function registerDefinition(name, definition, nativeRegistration) {
+  const moduleId = runtime.currentModuleId || runtime.registrationModuleId || name;
+  if (!runtime.applyingPatch && runtime.patchedModules.has(moduleId)) return;
+  definitions.set(moduleId, definition);
+  if (registered.has(moduleId)) {
+    return;
+  }
+  if (name === 'Component') {
+    let pending = pendingNativeDefinitions.get(name);
+    if (!pending) pendingNativeDefinitions.set(name, pending = []);
+    pending.push(decorateObject(definition, moduleId));
+    registered.add(moduleId);
+    return;
+  }
+  const original = nativeRegistration || nativeRegistrations[name];
+  if (typeof original !== 'function') throw new Error(name + ' registration API is unavailable');
+  registered.add(moduleId);
+  return original.call(globalThis, decorateObject(definition, moduleId));
+}
+globalThis[bridgeKey] = {
+  App(definition) { return registerDefinition('App', definition); },
+  Page(definition) { return registerDefinition('Page', definition); },
+  Component(definition, nativeRegistration) { return registerDefinition('Component', definition, nativeRegistration); },
+  installNative(name, registration) {
+    if (typeof registration === 'function') nativeRegistrations[name] = registration;
+  },
+  takeNativeDefinitions(name) {
+    const pending = pendingNativeDefinitions.get(name) || [];
+    pendingNativeDefinitions.delete(name);
+    return pending;
+  },
+  isApplying() { return runtime.applyingPatch; },
+  trackWevuComponent(definition, refresh) {
+    const moduleId = runtime.registrationModuleId || runtime.currentModuleId || 'Component';
+    if (!runtime.applyingPatch && runtime.patchedModules.has(moduleId)) return definition;
+    definitions.set(moduleId, definition);
+    if (typeof refresh === 'function') wevuRefreshes.set(moduleId, refresh);
+    if (runtime.applyingPatch) {
+      wevuRefreshGenerations.set(moduleId, (wevuRefreshGenerations.get(moduleId) || 0) + 1);
+      const currentRefresh = wevuRefreshes.get(moduleId);
+      if (typeof currentRefresh === 'function') {
+        for (const instance of [...getInstances(moduleId)]) currentRefresh(instance);
+      }
+      return definition;
+    }
+    return decorateWevuComponent(definition, moduleId);
+  },
+  ready: true,
+  beginUpdate() {
+    suppressLifecycles = true;
+    runtime.beginPatch();
+  },
+  endUpdate() {
+    runtime.endPatch();
+    setTimeout(() => { suppressLifecycles = false; });
+  }
+};
+`;
+function createStatefulHmrControlSource(control) {
+	return `
+globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_CONTROL_KEY)}] = ${JSON.stringify(control)};
+(() => {
+  const control = globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_CONTROL_KEY)}];
+  if (globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_CLIENT_KEY)}]) return;
+  let version = 0;
+  let phase = 'registering';
+  let pendingBatch;
+  let requestGeneration = 0;
+  let activeRequest;
+  let timer;
+  const sessionId = Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
+  const schedule = (delay) => {
+    if (timer) clearTimeout(timer);
+    const expectedPhase = phase;
+    const expectedVersion = version;
+    timer = setTimeout(() => {
+      timer = undefined;
+      if (phase !== expectedPhase || version !== expectedVersion) return;
+      send(phase === 'registering' ? 'register' : 'poll');
+    }, delay);
+  };
+  const send = (action) => {
+    activeRequest?.abort?.();
+    const generation = ++requestGeneration;
+    activeRequest = wx.request({
+      url: control.url,
+      method: 'POST',
+      data: { token: control.token, action, buildId: control.buildId, sessionId, version },
+      timeout: 30000,
+      success(result) {
+        if (generation !== requestGeneration) return;
+        activeRequest = undefined;
+        const type = result?.data?.type;
+        if (action === 'register' && type === 'registered') {
+          phase = 'polling';
+          if (pendingBatch) globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_CLIENT_KEY)}].receiveBatch(pendingBatch.meta, pendingBatch.apply);
+          else send('poll');
+        } else if (type === 'idle' || type === 'changed') send('poll');
+        else if (type === 'batch-published') schedule(2000);
+        else if (type === 'rebuilding') schedule(1000);
+        else schedule(500);
+      },
+      fail() {
+        if (generation !== requestGeneration) return;
+        activeRequest = undefined;
+        schedule(500);
+      }
+    });
+  };
+  const relaunch = () => {
+    const pages = typeof getCurrentPages === 'function' ? getCurrentPages() : [];
+    const page = pages[pages.length - 1];
+    const route = page?.route || page?.__route__;
+    if (!route) return send('poll');
+    const query = Object.entries(page?.options || {})
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => encodeURIComponent(key) + '=' + encodeURIComponent(String(value)))
+      .join('&');
+    wx.reLaunch({ url: '/' + route + (query ? '?' + query : ''), complete: () => send('poll') });
+  };
+  globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_CLIENT_KEY)}] = {
+    getVersion() { return version; },
+    receiveBatch(meta, apply) {
+      if (phase === 'registering') {
+        pendingBatch = { meta, apply };
+        return;
+      }
+      pendingBatch = undefined;
+      if (phase !== 'polling' || meta.buildId !== control.buildId || meta.fromVersion !== version) return send('poll');
+      phase = 'applying';
+      const bridge = globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}];
+      if (!bridge?.ready) {
+        phase = 'polling';
+        return send('rebuild');
+      }
+      bridge.beginUpdate?.();
+      try {
+        apply();
+        version = meta.targetVersion;
+        phase = meta.compatible === false ? 'relaunching' : 'polling';
+      } catch (error) {
+        console.error('[weapp-vite] stateful HMR patch failed', error);
+        phase = 'polling';
+        return send('rebuild');
+      } finally {
+        bridge.endUpdate?.();
+      }
+      if (phase === 'relaunching') relaunch();
+      else send('poll');
+    }
+  };
+  send('register');
+})();
+`;
+}
+//#endregion
+//#region src/runtime/statefulHmr/serverState.ts
+function createStatefulHmrServerState(buildId) {
+	return {
+		buildId,
+		deltas: [],
+		hostVersion: 0,
+		retainedDeltaBytes: 0,
+		retiredSessionIds: []
+	};
+}
+function transitionStatefulHmrServer(state, event) {
+	switch (event.type) {
+		case "delta-added": {
+			const version = state.hostVersion + 1;
+			return unchanged({
+				...state,
+				deltas: [...state.deltas, {
+					code: event.code,
+					version
+				}],
+				hostVersion: version,
+				retainedDeltaBytes: state.retainedDeltaBytes + event.bytes
+			});
+		}
+		case "client-registered": return registerClient(state, event);
+		case "client-reported": return reportClient(state, event);
+		case "batch-publish-failed":
+			if (state.inFlight?.sessionId !== event.sessionId || state.inFlight.targetVersion !== event.targetVersion) return unchanged(state);
+			return unchanged({
+				...state,
+				inFlight: void 0
+			});
+		case "full-build-committed": return unchanged(createStatefulHmrServerState(event.buildId));
+	}
+}
+function registerClient(state, client) {
+	const rejected = rejectClient(state, client);
+	if (rejected) return rejected;
+	if (state.retiredSessionIds.includes(client.sessionId)) return withCommand(state, {
+		type: "ignore-client",
+		reason: "retired-session"
+	});
+	if (state.activeSessionId === client.sessionId) return unchanged(state);
+	const retiredSessionIds = state.activeSessionId ? [.../* @__PURE__ */ new Set([...state.retiredSessionIds, state.activeSessionId])] : state.retiredSessionIds;
+	return unchanged({
+		...state,
+		activeSessionId: client.sessionId,
+		inFlight: void 0,
+		retiredSessionIds
+	});
+}
+function reportClient(state, client) {
+	const rejected = rejectClient(state, client);
+	if (rejected) return rejected;
+	if (state.retiredSessionIds.includes(client.sessionId)) return withCommand(state, {
+		type: "ignore-client",
+		reason: "retired-session"
+	});
+	if (client.sessionId !== state.activeSessionId) return withCommand(state, {
+		type: "ignore-client",
+		reason: "unknown-session"
+	});
+	return synchronizeClient(state, client.version);
+}
+function rejectClient(state, client) {
+	if (client.buildId !== state.buildId) return withCommand(state, {
+		type: "ignore-client",
+		reason: "stale-build"
+	});
+	if (!Number.isInteger(client.version) || client.version < 0) return withCommand(state, {
+		type: "request-full-build",
+		reason: "invalid-client-version"
+	});
+	if (client.version > state.hostVersion) return withCommand(state, {
+		type: "request-full-build",
+		reason: "client-version-ahead"
+	});
+}
+function synchronizeClient(state, clientVersion) {
+	let synchronized = state;
+	if (state.inFlight) {
+		if (clientVersion === state.inFlight.fromVersion) return publishMissingRange(state, clientVersion, state.inFlight.targetVersion);
+		if (clientVersion !== state.inFlight.targetVersion) return withCommand(state, {
+			type: "request-full-build",
+			reason: "invalid-client-version"
+		});
+		synchronized = {
+			...state,
+			inFlight: void 0
+		};
+	}
+	if (clientVersion >= synchronized.hostVersion) return unchanged(synchronized);
+	return publishMissingRange(synchronized, clientVersion, synchronized.hostVersion, true);
+}
+function publishMissingRange(state, fromVersion, targetVersion, trackInFlight = false) {
+	const deltas = state.deltas.filter((delta) => delta.version > fromVersion && delta.version <= targetVersion);
+	if (deltas.length !== targetVersion - fromVersion) return withCommand(state, {
+		type: "request-full-build",
+		reason: "missing-delta-history"
+	});
+	const batch = {
+		buildId: state.buildId,
+		deltas,
+		fromVersion,
+		sessionId: state.activeSessionId,
+		targetVersion
+	};
+	return withCommand(trackInFlight ? {
+		...state,
+		inFlight: {
+			fromVersion,
+			sessionId: batch.sessionId,
+			targetVersion
+		}
+	} : state, {
+		type: "publish-batch",
+		batch
+	});
+}
+function unchanged(state) {
+	return {
+		commands: [],
+		state
+	};
+}
+function withCommand(state, command) {
+	return {
+		commands: [command],
+		state
+	};
+}
+//#endregion
+//#region src/runtime/statefulHmr/transport.ts
+const endpointPath = "/__weapp_vite_stateful_hmr__";
+const pollTimeout = 25e3;
+var StatefulHmrTransport = class {
+	server;
+	publishUpdate;
+	requestFullBuild;
+	state = createStatefulHmrServerState(createId());
+	token = createId();
+	pendingPolls = /* @__PURE__ */ new Map();
+	closed = false;
+	constructor(server, publishUpdate, requestFullBuild) {
+		this.server = server;
+		this.publishUpdate = publishUpdate;
+		this.requestFullBuild = requestFullBuild;
+	}
+	get retainedDeltaBytes() {
+		return this.state.retainedDeltaBytes;
+	}
+	get retainedDeltaCount() {
+		return this.state.hostVersion;
+	}
+	install() {
+		this.server.middlewares.use(endpointPath, this.handleRequest);
+	}
+	close() {
+		this.closed = true;
+		this.respondToAll({ type: "rebuilding" });
+	}
+	addDelta(code) {
+		this.apply({
+			type: "delta-added",
+			bytes: Buffer.byteLength(code),
+			code
+		});
+		this.respondToAll({ type: "changed" });
+	}
+	createBuildId() {
+		return createId();
+	}
+	commitFullBuild(buildId) {
+		this.apply({
+			type: "full-build-committed",
+			buildId
+		});
+		this.respondToAll({ type: "rebuilding" });
+	}
+	isCurrentBuild(buildId) {
+		return this.state.buildId === buildId;
+	}
+	createControl() {
+		const address = this.server.httpServer?.address();
+		const port = address && typeof address !== "string" ? address.port : this.server.config.server.port;
+		return {
+			buildId: this.state.buildId,
+			token: this.token,
+			url: `http://127.0.0.1:${port}${endpointPath}`
+		};
+	}
+	handleRequest = async (request, response) => {
+		if (this.closed || request.method !== "POST") {
+			respond(response, 404, { type: "not-found" });
+			return;
+		}
+		let body;
+		try {
+			body = JSON.parse(await readBody(request));
+		} catch {
+			respond(response, 400, { type: "invalid-request" });
+			return;
+		}
+		if (!isClientReport(body) || body.token !== this.token) {
+			respond(response, 403, { type: "forbidden" });
+			return;
+		}
+		if (body.action === "rebuild") {
+			this.requestFullBuild();
+			respond(response, 202, { type: "rebuilding" });
+			return;
+		}
+		if (body.action === "register") {
+			if (this.apply({
+				type: "client-registered",
+				buildId: body.buildId,
+				sessionId: body.sessionId,
+				version: body.version
+			}).some((command) => command.type === "request-full-build")) this.requestFullBuild();
+			respond(response, 200, { type: "registered" });
+			return;
+		}
+		const commands = this.apply({
+			type: "client-reported",
+			buildId: body.buildId,
+			sessionId: body.sessionId,
+			version: body.version
+		});
+		const publish = commands.find((command) => command.type === "publish-batch");
+		if (publish?.type === "publish-batch") {
+			try {
+				await this.publishUpdate(publish.batch.buildId, renderBatch(publish.batch, createId()));
+				respond(response, 200, {
+					type: "batch-published",
+					targetVersion: publish.batch.targetVersion
+				});
+			} catch {
+				this.apply({
+					type: "batch-publish-failed",
+					sessionId: publish.batch.sessionId,
+					targetVersion: publish.batch.targetVersion
+				});
+				respond(response, 500, { type: "publish-failed" });
+			}
+			return;
+		}
+		if (commands.some((command) => command.type === "request-full-build")) {
+			this.requestFullBuild();
+			respond(response, 202, { type: "rebuilding" });
+			return;
+		}
+		if (commands.some((command) => command.type === "ignore-client")) {
+			respond(response, 409, { type: "rebuilding" });
+			return;
+		}
+		this.holdPoll(body.sessionId, response);
+	};
+	apply(event) {
+		const transition = transitionStatefulHmrServer(this.state, event);
+		this.state = transition.state;
+		return transition.commands;
+	}
+	holdPoll(sessionId, response) {
+		const previous = this.pendingPolls.get(sessionId);
+		if (previous) this.finishPoll(sessionId, previous, { type: "changed" });
+		const pending = {
+			response,
+			timeout: setTimeout(() => this.finishPoll(sessionId, pending, { type: "idle" }), pollTimeout)
+		};
+		this.pendingPolls.set(sessionId, pending);
+		response.on("close", () => this.finishPoll(sessionId, pending));
+	}
+	finishPoll(sessionId, pending, value) {
+		if (this.pendingPolls.get(sessionId) !== pending) return;
+		clearTimeout(pending.timeout);
+		this.pendingPolls.delete(sessionId);
+		if (value) respond(pending.response, 200, value);
+	}
+	respondToAll(value) {
+		for (const [sessionId, pending] of this.pendingPolls) this.finishPoll(sessionId, pending, value);
+	}
+};
+function renderBatch(batch, nonce) {
+	const metadata = {
+		buildId: batch.buildId,
+		compatible: true,
+		fromVersion: batch.fromVersion,
+		targetVersion: batch.targetVersion
+	};
+	const code = batch.deltas.map((delta) => delta.code).join("\n");
+	return `// ${nonce}\nglobalThis.__WEAPP_VITE_STATEFUL_HMR_CLIENT__.receiveBatch(${JSON.stringify(metadata)}, () => {\n${indent(code, 2)}\n});\n`;
+}
+function indent(value, spaces) {
+	const prefix = " ".repeat(spaces);
+	return value.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function isClientReport(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return (candidate.action === "poll" || candidate.action === "rebuild" || candidate.action === "register") && typeof candidate.buildId === "string" && typeof candidate.sessionId === "string" && typeof candidate.token === "string" && typeof candidate.version === "number";
+}
+async function readBody(request) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of request) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += buffer.length;
+		if (size > 64 * 1024) throw new Error("stateful HMR request body is too large");
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+function respond(response, status, body) {
+	if (response.writableEnded) return;
+	response.statusCode = status;
+	response.setHeader("content-type", "application/json");
+	response.end(JSON.stringify(body));
+}
+function createId() {
+	return randomBytes(16).toString("hex");
+}
+//#endregion
+//#region src/runtime/statefulHmr/viteAdapter.ts
+const clientId = "weapp-vite-stateful-hmr";
+var StatefulHmrViteAdapter = class {
+	config;
+	server;
+	callbacks;
+	bundledDev;
+	constructor(config, server, callbacks) {
+		this.config = config;
+		this.server = server;
+		this.callbacks = callbacks;
+	}
+	install() {
+		const bundledDev = this.server.environments.client.bundledDev;
+		if (!bundledDev) throw new Error("stateful-experimental HMR 需要 Vite experimental.bundledDev。");
+		if (typeof bundledDev.getRolldownOptions !== "function" || typeof bundledDev.storeOutputFiles !== "function") throw new TypeError("当前 Vite bundled-development 私有 API 与 weapp-vite 不兼容。");
+		this.bundledDev = bundledDev;
+		this.installOptions(bundledDev);
+		this.installOutput(bundledDev);
+		this.installPatches(bundledDev);
+		this.installListener(bundledDev);
+	}
+	async rebuild() {
+		const engine = this.bundledDev?._devEngine;
+		if (!engine) return;
+		engine.triggerFullBuild();
+		await engine.ensureLatestBuildOutput();
+	}
+	registerBundleModules(output) {
+		const moduleIds = /* @__PURE__ */ new Set();
+		for (const item of output) {
+			if (item.type !== "chunk") continue;
+			for (const match of item.code.matchAll(/registerModule\("([^"]+)"/g)) moduleIds.add(match[1]);
+			for (const id of Object.keys(item.modules ?? {})) {
+				const normalized = toStableModuleId(id, this.config.root);
+				if (!moduleIds.has(normalized)) moduleIds.add(normalized);
+			}
+		}
+		this.registerModules([...moduleIds]);
+		return moduleIds.size;
+	}
+	registerPatchModules(code) {
+		const moduleIds = /* @__PURE__ */ new Set();
+		for (const match of code.matchAll(/create(?:Esm|Cjs)Initializer\("([^"]+)"/g)) moduleIds.add(match[1]);
+		this.registerModules([...moduleIds]);
+	}
+	registerModules(moduleIds) {
+		if (moduleIds.length) this.bundledDev?._devEngine?.registerModules(clientId, moduleIds);
+	}
+	installOptions(bundledDev) {
+		const original = bundledDev.getRolldownOptions.bind(bundledDev);
+		bundledDev.getRolldownOptions = async () => {
+			const options = await original();
+			const output = Array.isArray(options.output) ? options.output[0] ??= {} : options.output ??= {};
+			const configuredOutput = this.config.build.rolldownOptions.output;
+			const desiredOutput = Array.isArray(configuredOutput) ? configuredOutput[0] : configuredOutput;
+			Object.assign(output, desiredOutput);
+			const userBanner = output.banner;
+			const userFooter = output.footer;
+			output.format = "cjs";
+			output.minify = false;
+			output.sourcemap = false;
+			output.banner = async (chunk) => {
+				const existing = typeof userBanner === "function" ? await userBanner(chunk) : userBanner ?? "";
+				return `${existing}${existing ? "\n" : ""}${createStatefulHmrBanner(chunk)}`;
+			};
+			output.footer = async (chunk) => {
+				const statefulFooter = createStatefulHmrFooter(chunk);
+				const existing = typeof userFooter === "function" ? await userFooter(chunk) : userFooter ?? "";
+				return `${statefulFooter}${statefulFooter && existing ? "\n" : ""}${existing}`;
+			};
+			options.experimental ??= {};
+			options.experimental.devMode = {
+				...typeof options.experimental.devMode === "object" ? options.experimental.devMode : {},
+				implement: statefulHmrRolldownRuntimeSource,
+				lazy: false
+			};
+			return options;
+		};
+	}
+	installOutput(bundledDev) {
+		const original = bundledDev.storeOutputFiles.bind(bundledDev);
+		bundledDev.storeOutputFiles = (output) => {
+			original(output);
+			this.callbacks.onOutput(output);
+		};
+	}
+	installPatches(bundledDev) {
+		const original = bundledDev.handleHmrOutput.bind(bundledDev);
+		bundledDev.handleHmrOutput = (client, files, output, info) => {
+			if (output.type === "Noop") return;
+			if (this.callbacks.onPatch(files, output)) original(client, files, output, info);
+		};
+	}
+	installListener(bundledDev) {
+		const original = bundledDev.listen.bind(bundledDev);
+		bundledDev.listen = async () => {
+			await original();
+			bundledDev.clients.setupIfNeeded({ send: (payload) => this.handlePayload(payload) }, clientId);
+			const engine = bundledDev._devEngine;
+			if (!engine) throw new Error("Vite 未初始化微信状态保持 HMR 所需的 DevEngine。");
+			await engine.ensureCurrentBuildFinish();
+			if ((await engine.getBundleState()).lastBuildErrored) throw new Error("微信状态保持 HMR 初次构建失败。");
+			await this.callbacks.waitForInitialBundle();
+		};
+	}
+	handlePayload(payload) {
+		if (!payload || typeof payload !== "object") return;
+		const candidate = payload;
+		if (candidate.type === "error" && typeof candidate.err?.message === "string") this.callbacks.onError(candidate.err.message);
+	}
+};
+function createStatefulHmrBanner(chunk) {
+	if (chunk.fileName === "app.js") return [
+		`require(${JSON.stringify(`./${WEAPP_VITE_STATEFUL_HMR_CONTROL_FILE}`)});`,
+		"require(\"./rolldown-runtime.js\");",
+		`globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}].installNative('App', definition => App(definition));`
+	].join("");
+	if (!chunk.isEntry || !chunk.fileName.endsWith(".js")) return "";
+	const prefix = "../".repeat(chunk.fileName.split("/").length - 1);
+	return [
+		`require(${JSON.stringify(`${prefix}rolldown-runtime.js`)});`,
+		`globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}].installNative('Page', definition => Page(definition));`,
+		`require(${JSON.stringify(`${prefix}${WEAPP_VITE_STATEFUL_HMR_PRELOAD_FILE}`)});`,
+		`require(${JSON.stringify(`${prefix}${WEAPP_VITE_STATEFUL_HMR_UPDATE_FILE}`)});`
+	].join("");
+}
+function createStatefulHmrFooter(chunk) {
+	if (!chunk.isEntry || chunk.fileName === "app.js" || !chunk.fileName.endsWith(".js")) return "";
+	return `for (const definition of globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}].takeNativeDefinitions('Component')) Component(definition);`;
+}
+function toStableModuleId(id, root) {
+	const normalizedId = id.replaceAll("\\", "/");
+	const absolute = path$1.posix.isAbsolute(normalizedId) || /^[A-Z]:\//i.test(normalizedId);
+	if (normalizedId.startsWith("\0") || !absolute) return normalizedId;
+	return path$1.posix.relative(root.replaceAll("\\", "/"), normalizedId);
+}
+//#endregion
+//#region src/runtime/statefulHmr/session.ts
+const maxRetainedDeltaCount = 1e3;
+const maxRetainedDeltaBytes = 16 * 1024 * 1024;
+async function runStatefulHmrDev(ctx, buildOptions, restart) {
+	const configService = ctx.configService;
+	if (configService.platform !== "weapp") throw new Error("weapp.hmr.runtime=\"stateful-experimental\" 目前仅支持微信小程序平台。");
+	let session;
+	const installPlugin = {
+		name: "weapp-vite:stateful-hmr-session",
+		enforce: "post",
+		configureServer(server) {
+			const currentSession = new StatefulHmrSession(ctx, server, restart);
+			session = currentSession;
+			currentSession.install();
+		},
+		transform(code, id) {
+			if (!isStatefulHmrBoundary(id, configService.absoluteSrcRoot) || code.includes("import.meta.hot.accept")) return;
+			return `${id.endsWith(".vue") ? code : redirectNativeComponentRegistration(code)}\nif (import.meta.hot) import.meta.hot.accept();\n`;
+		}
+	};
+	const server = await createServer({
+		...buildOptions,
+		appType: "custom",
+		configFile: false,
+		define: {
+			...buildOptions.define ?? {},
+			App: `globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}].App`,
+			Page: `globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}].Page`
+		},
+		experimental: {
+			...buildOptions.experimental ?? {},
+			bundledDev: true
+		},
+		plugins: [installPlugin, ...buildOptions.plugins ?? []],
+		server: {
+			...buildOptions.server ?? {},
+			host: "127.0.0.1",
+			port: 0
+		},
+		build: {
+			...buildOptions.build ?? {},
+			watch: void 0,
+			write: false
+		}
+	});
+	await server.listen();
+	if (!session) {
+		await server.close();
+		throw new Error("微信状态保持 HMR session 未完成初始化。");
+	}
+	await session.refreshControl();
+	return createWatcherAdapter(server, session);
+}
+var StatefulHmrSession = class {
+	ctx;
+	server;
+	restart;
+	adapter;
+	initialBundle = Promise.withResolvers();
+	transport;
+	outputChain = Promise.resolve();
+	rebuildTimer;
+	restartTimer;
+	constructor(ctx, server, restart) {
+		this.ctx = ctx;
+		this.server = server;
+		this.restart = restart;
+		this.transport = new StatefulHmrTransport(server, async (buildId, source) => {
+			await this.enqueueOutput(async () => {
+				if (!this.transport.isCurrentBuild(buildId)) return;
+				await writeStatefulHmrOutput(this.ctx.configService.outDir, [{
+					type: "asset",
+					fileName: WEAPP_VITE_STATEFUL_HMR_UPDATE_FILE,
+					source
+				}]);
+			});
+		}, () => this.requestFullBuild());
+		this.adapter = new StatefulHmrViteAdapter(server.config, server, {
+			onError: (message) => server.config.logger.error(`[weapp-vite] stateful HMR: ${message}`),
+			onOutput: (output) => this.handleOutput(output),
+			onPatch: (files, output) => this.handlePatch(files, output),
+			waitForInitialBundle: () => this.waitForInitialBundle()
+		});
+	}
+	install() {
+		this.transport.install();
+		this.adapter.install();
+	}
+	async close() {
+		if (this.rebuildTimer) clearTimeout(this.rebuildTimer);
+		if (this.restartTimer) clearTimeout(this.restartTimer);
+		this.transport.close();
+		await this.outputChain;
+	}
+	async refreshControl() {
+		await this.enqueueOutput(async () => {
+			await writeStatefulHmrOutput(this.ctx.configService.outDir, [{
+				type: "asset",
+				fileName: WEAPP_VITE_STATEFUL_HMR_CONTROL_FILE,
+				source: createStatefulHmrControlSource(this.transport.createControl())
+			}]);
+		});
+	}
+	handleOutput(output) {
+		this.enqueueOutput(async () => {
+			const compatibleOutput = await transformOutput(output);
+			const fullBuild = compatibleOutput.some((item) => item.fileName === "app.js");
+			if (fullBuild) {
+				const buildId = this.transport.createBuildId();
+				this.transport.commitFullBuild(buildId);
+				setAsset(compatibleOutput, WEAPP_VITE_STATEFUL_HMR_CONTROL_FILE, createStatefulHmrControlSource({
+					...this.transport.createControl(),
+					buildId
+				}));
+				setAsset(compatibleOutput, WEAPP_VITE_STATEFUL_HMR_PRELOAD_FILE, "void 0;\n");
+				setAsset(compatibleOutput, WEAPP_VITE_STATEFUL_HMR_UPDATE_FILE, "void 0;\n");
+			}
+			await writeStatefulHmrOutput(this.ctx.configService.outDir, compatibleOutput);
+			if (fullBuild) {
+				const moduleCount = this.adapter.registerBundleModules(compatibleOutput);
+				this.server.config.logger.info(`[weapp-vite] 微信状态保持 HMR 已就绪（${moduleCount} modules）`);
+				this.initialBundle.resolve();
+			}
+		});
+	}
+	handlePatch(files, output) {
+		if (!isSafeJavaScriptPatch(files, output, this.ctx.runtimeState.build.hmr.profile.dirtyReasonSummary)) {
+			this.requestServerRestart();
+			return false;
+		}
+		this.adapter.registerPatchModules(output.code);
+		transformJavaScript(output.code, output.filename).then((code) => {
+			if (shouldResetStatefulHmrRetention(this.transport.retainedDeltaCount, this.transport.retainedDeltaBytes, Buffer.byteLength(code))) {
+				this.requestFullBuild();
+				return;
+			}
+			this.transport.addDelta(code);
+		}).catch((error) => {
+			this.server.config.logger.error("[weapp-vite] stateful HMR patch transform failed", { error });
+			this.requestFullBuild();
+		});
+		return true;
+	}
+	requestFullBuild() {
+		if (this.rebuildTimer) return;
+		this.rebuildTimer = setTimeout(() => {
+			this.rebuildTimer = void 0;
+			this.adapter.rebuild().catch((error) => {
+				this.server.config.logger.error("[weapp-vite] stateful HMR full rebuild failed", { error });
+			});
+		}, 100);
+	}
+	requestServerRestart() {
+		if (this.restartTimer) return;
+		this.restartTimer = setTimeout(() => {
+			this.restartTimer = void 0;
+			this.restart().catch((error) => {
+				this.server.config.logger.error("[weapp-vite] stateful HMR server restart failed", { error });
+			});
+		}, 100);
+	}
+	enqueueOutput(task) {
+		this.outputChain = this.outputChain.then(task, task).catch((error) => {
+			this.server.config.logger.error("[weapp-vite] stateful HMR output failed", { error });
+		});
+		return this.outputChain;
+	}
+	async waitForInitialBundle() {
+		await this.initialBundle.promise;
+		await this.outputChain;
+	}
+};
+function createWatcherAdapter(server, session) {
+	return {
+		close: async () => {
+			await session.close();
+			await server.close();
+		},
+		on() {
+			return this;
+		}
+	};
+}
+function isStatefulHmrBoundary(id, srcRoot) {
+	if (id.includes("?")) return false;
+	const cleanId = id.split("?", 1)[0];
+	return cleanId.startsWith(srcRoot.replaceAll("\\", "/")) && /\.(?:[cm]?[jt]sx?|vue)$/.test(cleanId);
+}
+function redirectNativeComponentRegistration(code) {
+	if (!code.includes("Component")) return code;
+	const ast = parseJsLike(code);
+	const magicString = new MagicString(code);
+	let changed = false;
+	traverse(ast, { CallExpression(path) {
+		const callee = path.node.callee;
+		if (callee.type !== "Identifier" || callee.name !== "Component" || path.scope.hasBinding("Component") || callee.start == null || callee.end == null) return;
+		magicString.overwrite(callee.start, callee.end, `globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}].Component`);
+		changed = true;
+	} });
+	return changed ? magicString.toString() : code;
+}
+function isSafeJavaScriptPatch(files, output, dirtyReasonSummary = []) {
+	return output.type === "Patch" && output.hmrBoundaries.length > 0 && files.every((file) => /\.(?:[cm]?[jt]sx?|vue)$/.test(file)) && !dirtyReasonSummary.some((reason) => /^(?:entry-json-only|entry-local-asset|entry-style-only):/.test(reason));
+}
+function shouldResetStatefulHmrRetention(retainedDeltaCount, retainedDeltaBytes, nextDeltaBytes) {
+	return retainedDeltaCount >= maxRetainedDeltaCount || retainedDeltaBytes + nextDeltaBytes >= maxRetainedDeltaBytes;
+}
+async function transformOutput(output) {
+	return await Promise.all(output.map(async (item) => {
+		if (item.type !== "chunk") return item;
+		return {
+			...item,
+			code: await transformJavaScript(item.code, item.fileName)
+		};
+	}));
+}
+async function transformJavaScript(code, filename) {
+	return (await transformWithOxc(code, filename, {
+		assumptions: { setPublicClassFields: true },
+		lang: "js",
+		sourcemap: false,
+		target: "es2018"
+	})).code;
+}
+function setAsset(output, fileName, source) {
+	const index = output.findIndex((item) => item.fileName === fileName);
+	const asset = {
+		type: "asset",
+		fileName,
+		source
+	};
+	if (index >= 0) output[index] = asset;
+	else output.push(asset);
+}
+//#endregion
 //#region src/runtime/watch/options.ts
 function resolvePollingWatchConfig(configService) {
 	const buildWatch = configService.inlineConfig?.build?.watch;
@@ -12632,73 +13779,47 @@ function createBuildService(ctx) {
 		if (!configService.isDev) return false;
 		return requestedConfigRestartBuilds.delete(target);
 	}
-	function resetRuntimeStateForConfigRestart() {
-		const fresh = createRuntimeState();
-		const autoRoutes = ctx.runtimeState.autoRoutes;
-		autoRoutes.routes = fresh.autoRoutes.routes;
-		autoRoutes.serialized = fresh.autoRoutes.serialized;
-		autoRoutes.moduleCode = fresh.autoRoutes.moduleCode;
-		autoRoutes.typedDefinition = fresh.autoRoutes.typedDefinition;
-		autoRoutes.watchFiles.clear();
-		autoRoutes.watchDirs.clear();
-		autoRoutes.dirty = fresh.autoRoutes.dirty;
-		autoRoutes.initialized = fresh.autoRoutes.initialized;
-		autoRoutes.candidates.clear();
-		autoRoutes.needsFullRescan = fresh.autoRoutes.needsFullRescan;
-		autoRoutes.loadingAppConfig = fresh.autoRoutes.loadingAppConfig;
-		const autoImport = ctx.runtimeState.autoImport;
-		autoImport.registry.clear();
-		autoImport.resolvedResolverComponents.clear();
-		autoImport.matcher = void 0;
-		autoImport.matcherKey = fresh.autoImport.matcherKey;
-		autoImport.version += 1;
-		autoImport.pendingEntriesByImporter.clear();
-		ctx.runtimeState.build.hmr = fresh.build.hmr;
-		const json = ctx.runtimeState.json;
-		json.cache.cache.clear();
-		json.cache.mtimeMap.clear();
-		json.cache.signatureMap.clear();
-		json.emittedSource.clear();
-		const asset = ctx.runtimeState.asset;
-		asset.emittedBuffer.clear();
-		asset.scopedSlotGenerics.clear();
-		const css = ctx.runtimeState.css;
-		css.importerToDependencies.clear();
-		css.dependencyToImporters.clear();
-		css.emittedSource.clear();
-		const wxml = ctx.runtimeState.wxml;
-		wxml.depsMap.clear();
-		wxml.importerMap.clear();
-		wxml.tokenMap.clear();
-		wxml.componentsMap.clear();
-		wxml.aggregatedComponentsMap.clear();
-		wxml.templatePathMap.clear();
-		wxml.cache.cache.clear();
-		wxml.cache.mtimeMap.clear();
-		wxml.cache.signatureMap.clear();
-		wxml.emittedCode.clear();
-		const scan = ctx.runtimeState.scan;
-		scan.subPackageMap.clear();
-		scan.independentSubPackageMap.clear();
-		scan.warnedMessages.clear();
-		scan.appEntry = void 0;
-		scan.pluginJson = void 0;
-		scan.pluginJsonPath = void 0;
-		scan.isDirty = fresh.scan.isDirty;
-		scan.independentDirtyRoots.clear();
-		const lib = ctx.runtimeState.lib;
-		lib.enabled = fresh.lib.enabled;
-		lib.entries.clear();
-	}
 	async function runDev(target) {
 		if (process.env.NODE_ENV === void 0) process.env.NODE_ENV = "development";
 		debug$2?.(`[${target}] dev build watcher start`);
 		const { hasWorkersDir, workersDir } = checkWorkersOptions(target, configService, scanService);
-		const buildOptions = appendHmrMetricsPlugin(applyTargetBuildOverride(configService.merge(void 0, createSharedBuildConfig(configService, scanService), resolveTargetBuildOverride(target)), target));
+		const createDevBuildOptions = () => appendHmrMetricsPlugin(applyTargetBuildOverride(configService.merge(void 0, createSharedBuildConfig(configService, scanService), resolveTargetBuildOverride(target)), target));
+		let buildOptions = createDevBuildOptions();
 		buildOptions.build = {
 			...buildOptions.build ?? {},
 			write: true
 		};
+		if (target === "app" && configService.weappViteConfig.hmr?.runtime === "stateful-experimental") {
+			await build({
+				...buildOptions,
+				build: {
+					...buildOptions.build ?? {},
+					watch: void 0
+				}
+			});
+			resetRuntimeStateForFreshBuild(ctx.runtimeState);
+			await scanService.loadAppEntry();
+			scanService.loadSubPackages();
+			buildOptions = createDevBuildOptions();
+			buildOptions.build = {
+				...buildOptions.build ?? {},
+				write: true
+			};
+			const workerPromise = hasWorkersDir && workersDir ? devWorkers(configService, watcherService, workersDir) : Promise.resolve();
+			let statefulWatcher;
+			const [watcher] = await Promise.all([runStatefulHmrDev(ctx, buildOptions, async () => {
+				await statefulWatcher?.close();
+				logger_default.info("检测到非兼容更新，正在重启微信状态保持 HMR 构建...");
+				resetRuntimeStateForFreshBuild(ctx.runtimeState);
+				await scanService.loadAppEntry();
+				scanService.loadSubPackages();
+				await runDev(target);
+				logger_default.success("微信状态保持 HMR 构建已完成完整重载。");
+			}), workerPromise]);
+			statefulWatcher = watcher;
+			watcherService.setRollupWatcher(watcher, "/");
+			return watcher;
+		}
 		const snapshotBuildOptions = {
 			...buildOptions,
 			build: { ...buildOptions.build ?? {} }
@@ -12848,7 +13969,7 @@ function createBuildService(ctx) {
 					if (shouldRestartDevBuild(target)) {
 						await watcher.close();
 						logger_default.info("检测到 Vite 配置变更，正在重启小程序开发构建...");
-						resetRuntimeStateForConfigRestart();
+						resetRuntimeStateForFreshBuild(ctx.runtimeState);
 						await configService.load(configService.loadOptions);
 						try {
 							const supportFiles = await syncProjectSupportFiles(ctx);
@@ -18008,6 +19129,32 @@ async function collectAppEntries(options) {
 	};
 }
 //#endregion
+//#region src/plugins/outputFinalizer/pageLayout.ts
+const nativePageLayoutOutputs = /* @__PURE__ */ new WeakMap();
+function registerNativePageLayoutOutput(options) {
+	const { configService, runtimeState, pageId, templatePath, plan } = options;
+	const { templateExtension } = resolveCompilerOutputExtensions(configService.outputExtensions);
+	const fileName = resolveRelativeOutputFileNameWithExtension(configService, templatePath, templateExtension);
+	const outputs = nativePageLayoutOutputs.get(runtimeState) ?? /* @__PURE__ */ new Map();
+	if (plan) {
+		outputs.set(fileName, {
+			pageId,
+			plan
+		});
+		nativePageLayoutOutputs.set(runtimeState, outputs);
+	} else outputs.delete(fileName);
+}
+function restoreNativePageLayoutOutputs(ctx, bundle) {
+	const outputs = nativePageLayoutOutputs.get(ctx.runtimeState);
+	if (!outputs?.size) return;
+	for (const [fileName, { pageId, plan }] of outputs) {
+		const output = bundle[fileName];
+		if (output?.type !== "asset") continue;
+		const transformed = applyPageLayoutPlanToNativePage({ template: typeof output.source === "string" ? output.source : Buffer.from(output.source).toString("utf8") }, pageId, plan, { platform: ctx.configService.platform });
+		if (transformed.template) output.source = transformed.template;
+	}
+}
+//#endregion
 //#region src/plugins/utils/invalidateEntry/cssGraph.ts
 const importProtocols = /^(?:https?:|data:|blob:|\/)/i;
 const cssImportRE = /@(?:import|wv-keep-import|use|forward)\s+(?:url\()?['"]?([^'")\s]+)['"]?\)?/gi;
@@ -18741,6 +19888,13 @@ async function emitEntryOutput(options) {
 		try {
 			replaceLayoutDependencies(id, []);
 			const layoutPlan = resolvedPageLayoutPlan === void 0 ? await resolvePageLayoutPlan(code, id, configService) : resolvedPageLayoutPlan ?? void 0;
+			registerNativePageLayoutOutput({
+				configService,
+				runtimeState,
+				pageId: id,
+				templatePath,
+				plan: layoutPlan
+			});
 			if (layoutPlan) {
 				const layoutDependencies = /* @__PURE__ */ new Set();
 				for (const file of await expandResolvedPageLayoutFiles(layoutPlan.layouts)) {
@@ -22310,14 +23464,18 @@ function createOutputFinalizerPlugin(ctx) {
 	return {
 		name: "weapp-vite:output-finalizer",
 		enforce: "post",
-		generateBundle(_options, bundle) {
-			const outputBundle = bundle;
-			rewriteWevuInternalRuntimeImports(bundle, wevuRuntimeRewriteOptions);
-			stabilizeWevuRuntimeChunkAccess(bundle);
-			const assetEntries = collectOutputFinalizerAssetEntries(outputBundle);
-			normalizePreprocessorStyleAssetEntries(outputBundle, assetEntries.preprocessorStyleAssets, ctx.configService.outputExtensions?.wxss, (asset) => this.emitFile(asset));
-			normalizeTemplateAssetEntries(ctx, assetEntries.templateAssets);
-			pruneUnchangedDevHmrOutputs(ctx, outputBundle, wevuRuntimeRewriteOptions, { runtimeRewriteDone: true });
+		generateBundle: {
+			order: "post",
+			handler(_options, bundle) {
+				const outputBundle = bundle;
+				rewriteWevuInternalRuntimeImports(bundle, wevuRuntimeRewriteOptions);
+				stabilizeWevuRuntimeChunkAccess(bundle);
+				restoreNativePageLayoutOutputs(ctx, outputBundle);
+				const assetEntries = collectOutputFinalizerAssetEntries(outputBundle);
+				normalizePreprocessorStyleAssetEntries(outputBundle, assetEntries.preprocessorStyleAssets, ctx.configService.outputExtensions?.wxss, (asset) => this.emitFile(asset));
+				normalizeTemplateAssetEntries(ctx, assetEntries.templateAssets);
+				pruneUnchangedDevHmrOutputs(ctx, outputBundle, wevuRuntimeRewriteOptions, { runtimeRewriteDone: true });
+			}
 		}
 	};
 }
@@ -27637,6 +28795,168 @@ function parseUsingComponents(config) {
 	}
 }
 //#endregion
+//#region src/plugins/vue/transform/plugin/transformFile/finalize.ts
+async function finalizeVueTransform(options) {
+	const { ctx, pluginCtx, filename, source, autoRoutesSignature, result, compilationCache, currentStyleIndependentSignature, previousStyleSignature, dirtyEntryId, dirtyVueEntryIds, isCssImporterDirty, isPage, isApp, sourceMap, styleBlocksCache, styleRefreshTokens, scopedSlotModules, emittedScopedSlotChunks, setAppShell, readAndParseSfc, createReadAndParseSfcOptions, measureStage, measureVueHmrStage, reportTiming } = options;
+	const configService = ctx.configService;
+	let currentStyleBlocks = Array.isArray(result.meta?.styleBlocks) ? result.meta.styleBlocks : styleBlocksCache.get(filename);
+	if (!currentStyleBlocks) currentStyleBlocks = await measureStage("preloadSfcStyles", async () => await loadStyleBlocksForStyleOnlyRefresh({
+		filename,
+		source,
+		styleBlocksCache,
+		readAndParseSfc,
+		createReadAndParseSfcOptions,
+		pluginCtx,
+		configService
+	}));
+	if (currentStyleBlocks) styleBlocksCache.set(filename, currentStyleBlocks);
+	if (configService.isDev && dirtyEntryId) {
+		const currentStyleSignature = createSfcStyleBlocksSignature(currentStyleBlocks);
+		const hmrEventId = ctx.runtimeState.build?.hmr?.profile?.eventId;
+		if (hmrEventId != null && (isCssImporterDirty || currentStyleSignature && currentStyleSignature !== previousStyleSignature)) styleRefreshTokens.set(filename, hmrEventId);
+		else styleRefreshTokens.delete(filename);
+		dirtyVueEntryIds?.delete(dirtyEntryId);
+	}
+	const sfcStyleDependencies = syncVueSfcStyleDependencies(ctx, filename, currentStyleBlocks);
+	for (const dependency of sfcStyleDependencies) addNormalizedWatchFile(pluginCtx, dependency);
+	registerScopedSlotHostGenerics(ctx, result.scopedSlotComponents, parseUsingComponents(result.config));
+	await measureVueHmrStage("finalizeCompiledResult", "vueFinalizeCompiledMs", async () => {
+		await finalizeTransformCompiledResult({
+			ctx,
+			pluginCtx,
+			filename,
+			source,
+			autoRoutesSignature,
+			result,
+			compilationCache,
+			styleIndependentSignature: filename.endsWith(".vue") ? currentStyleIndependentSignature ?? resolveVueSfcStyleIndependentSignature(source, filename) : void 0,
+			setAppShell,
+			configService,
+			isPage,
+			isApp,
+			sourceMap,
+			scopedSlotModules,
+			emittedScopedSlotChunks,
+			addWatchFile: addNormalizedWatchFile,
+			emitScopedSlotChunks
+		});
+	});
+	const returnedCode = await measureVueHmrStage("finalizeCode", "vueFinalizeCodeMs", async () => finalizeTransformEntryCode({
+		result,
+		filename,
+		styleBlocks: result.meta?.styleBlocks ?? styleBlocksCache.get(filename),
+		isPage,
+		isApp,
+		isDev: configService.isDev,
+		sourceMap,
+		hmrStyleToken: configService.isDev ? styleRefreshTokens.get(filename) : void 0
+	}));
+	reportTiming(filename, isPage);
+	return returnedCode;
+}
+//#endregion
+//#region src/plugins/vue/transform/plugin/transformFile/jsonOnly.ts
+function isVueJsonOnlyDirtyReasonSummary(dirtyReasonSummary) {
+	return Boolean(dirtyReasonSummary?.length && dirtyReasonSummary.every((item) => item.startsWith("entry-json-only:")));
+}
+async function tryRefreshJsonOnlyVueCompilation(options) {
+	const { cachedResult, compileOptions, dirtyEntryId, dirtyReasonSummary, filename, isDev, scanDirty, source, autoRoutesSignature, cachedAutoRoutesSignature } = options;
+	if (!isDev || scanDirty || !dirtyEntryId || !cachedResult || !filename.endsWith(".vue") || cachedAutoRoutesSignature !== autoRoutesSignature || !isVueJsonOnlyDirtyReasonSummary(dirtyReasonSummary)) return;
+	const refreshed = await refreshVueFileJsonConfig(source, filename, cachedResult, compileOptions);
+	return refreshed ? normalizeVueTransformResult(refreshed) : void 0;
+}
+//#endregion
+//#region src/plugins/vue/transform/plugin/transformFile/reuse.ts
+async function tryReuseVueCompilation(options) {
+	const { ctx, pluginCtx, filename, source, cachedCompilation, previousStyleSignature, autoRoutesSignature, dirtyEntryId, dirtyVueEntryIds, isCssImporterDirty, canAttemptStyleOnlyReuse, sourceMap, isApp, styleBlocksCache, styleRefreshTokens, readAndParseSfc, createReadAndParseSfcOptions, measureStage, measureVueHmrStage, reportTiming } = options;
+	const configService = ctx.configService;
+	if (configService.isDev && cachedCompilation && !ctx.runtimeState.scan.isDirty && cachedCompilation.source === source && cachedCompilation.autoRoutesSignature === autoRoutesSignature) {
+		cachedCompilation.refreshToken = 0;
+		const cachedResult = normalizeVueTransformResult(cachedCompilation.result);
+		let cachedStyleBlocks = cachedResult.meta?.styleBlocks ?? styleBlocksCache.get(filename);
+		let canReturnCachedCompilation = true;
+		if (dirtyEntryId && canAttemptStyleOnlyReuse && filename.endsWith(".vue")) {
+			const refreshedStyleBlocks = await measureStage("loadStyleOnlySfcStyles", async () => await loadStyleBlocksForStyleOnlyRefresh({
+				filename,
+				source,
+				styleBlocksCache,
+				force: true,
+				readAndParseSfc,
+				createReadAndParseSfcOptions,
+				pluginCtx,
+				configService
+			}));
+			if (!refreshStyleOnlyVueTransformResult(cachedResult, filename, refreshedStyleBlocks)) {
+				cachedCompilation.styleIndependentSignature = void 0;
+				canReturnCachedCompilation = false;
+			} else {
+				cachedStyleBlocks = refreshedStyleBlocks;
+				cachedCompilation.result = cachedResult;
+				const currentStyleSignature = createSfcStyleBlocksSignature(cachedStyleBlocks);
+				const hmrEventId = ctx.runtimeState.build?.hmr?.profile?.eventId;
+				if (hmrEventId != null && (isCssImporterDirty || currentStyleSignature && currentStyleSignature !== previousStyleSignature)) styleRefreshTokens.set(filename, hmrEventId);
+				else styleRefreshTokens.delete(filename);
+			}
+		}
+		if (!canReturnCachedCompilation) cachedCompilation.refreshToken = 1;
+		else {
+			const returnedCode = await measureVueHmrStage("finalizeCode", "vueFinalizeCodeMs", async () => finalizeTransformEntryCode({
+				result: cachedResult,
+				filename,
+				styleBlocks: cachedStyleBlocks,
+				isPage: cachedCompilation.isPage,
+				isApp,
+				isDev: configService.isDev,
+				sourceMap,
+				hmrStyleToken: styleRefreshTokens.get(filename)
+			}));
+			if (dirtyEntryId) dirtyVueEntryIds?.delete(dirtyEntryId);
+			reportTiming(filename, cachedCompilation.isPage);
+			return { returnedCode };
+		}
+	}
+	const currentStyleIndependentSignature = configService.isDev && dirtyEntryId && canAttemptStyleOnlyReuse && filename.endsWith(".vue") ? resolveVueSfcStyleIndependentSignature(source, filename) : void 0;
+	if (Boolean(configService.isDev && cachedCompilation && dirtyEntryId && canAttemptStyleOnlyReuse && filename.endsWith(".vue") && !ctx.runtimeState.scan.isDirty && cachedCompilation.autoRoutesSignature === autoRoutesSignature && cachedCompilation.styleIndependentSignature && currentStyleIndependentSignature && cachedCompilation.styleIndependentSignature === currentStyleIndependentSignature && cachedCompilation.source !== source) && cachedCompilation) {
+		const cachedResult = normalizeVueTransformResult(cachedCompilation.result);
+		const styleBlocks = await measureStage("loadStyleOnlySfcStyles", async () => await loadStyleBlocksForStyleOnlyRefresh({
+			filename,
+			source,
+			styleBlocksCache,
+			force: true,
+			readAndParseSfc,
+			createReadAndParseSfcOptions,
+			pluginCtx,
+			configService
+		}));
+		if (!refreshStyleOnlyVueTransformResult(cachedResult, filename, styleBlocks)) cachedCompilation.styleIndependentSignature = void 0;
+		else {
+			cachedCompilation.source = source;
+			cachedCompilation.result = cachedResult;
+			cachedCompilation.styleIndependentSignature = currentStyleIndependentSignature;
+			cachedCompilation.refreshToken = 0;
+			const hmrEventId = ctx.runtimeState.build?.hmr?.profile?.eventId;
+			if (hmrEventId != null && (isCssImporterDirty || styleBlocks?.length)) styleRefreshTokens.set(filename, hmrEventId);
+			const returnedCode = await measureVueHmrStage("finalizeCode", "vueFinalizeCodeMs", async () => finalizeTransformEntryCode({
+				result: cachedResult,
+				filename,
+				styleBlocks,
+				isPage: cachedCompilation.isPage,
+				isApp,
+				isDev: configService.isDev,
+				sourceMap,
+				hmrStyleToken: styleRefreshTokens.get(filename)
+			}));
+			if (dirtyEntryId) dirtyVueEntryIds?.delete(dirtyEntryId);
+			reportTiming(filename, cachedCompilation.isPage);
+			return {
+				currentStyleIndependentSignature,
+				returnedCode
+			};
+		}
+	}
+	return { currentStyleIndependentSignature };
+}
+//#endregion
 //#region src/plugins/vue/transform/plugin/transformFile.ts
 async function transformVueLikeFile(options) {
 	const { ctx, pluginCtx, code, id, compilationCache, setAppShell, pageMatcher, setPageMatcher, scanDirtySynced, setScanDirtySynced, reExportResolutionCache, compileOptionsCache, componentMetaCache, styleBlocksCache, styleRefreshTokens, scopedSlotModules, emittedScopedSlotChunks, classStyleRuntimeWarned, readAndParseSfc, createReadAndParseSfcOptions } = options;
@@ -27695,159 +29015,120 @@ async function transformVueLikeFile(options) {
 		const dirtyEntryId = resolveDirtyVueEntryId(dirtyVueEntryIds, filename);
 		const isCssImporterDirty = isVueCssImporterDirtyReasonSummary(ctx.runtimeState?.build?.hmr?.profile?.dirtyReasonSummary);
 		const canAttemptStyleOnlyReuse = isVueStyleOnlyDirtyReasonSummary(ctx.runtimeState?.build?.hmr?.profile?.dirtyReasonSummary);
-		if (configService.isDev && cachedCompilation && !ctx.runtimeState.scan.isDirty && cachedCompilation.source === transformedSource && cachedCompilation.autoRoutesSignature === autoRoutesSignature) {
-			cachedCompilation.refreshToken = 0;
-			const cachedResult = normalizeVueTransformResult(cachedCompilation.result);
-			let cachedStyleBlocks = cachedResult.meta?.styleBlocks ?? styleBlocksCache.get(filename);
-			let canReturnCachedCompilation = true;
-			if (dirtyEntryId && canAttemptStyleOnlyReuse && filename.endsWith(".vue")) {
-				const refreshedStyleBlocks = await measureStage("loadStyleOnlySfcStyles", async () => await loadStyleBlocksForStyleOnlyRefresh({
-					filename,
-					source: transformedSource,
-					styleBlocksCache,
-					force: true,
-					readAndParseSfc,
-					createReadAndParseSfcOptions,
-					pluginCtx,
-					configService
-				}));
-				if (!refreshStyleOnlyVueTransformResult(cachedResult, filename, refreshedStyleBlocks)) {
-					cachedCompilation.styleIndependentSignature = void 0;
-					canReturnCachedCompilation = false;
-				} else {
-					cachedStyleBlocks = refreshedStyleBlocks;
-					cachedCompilation.result = cachedResult;
-					const currentStyleSignature = createSfcStyleBlocksSignature(cachedStyleBlocks);
-					const hmrEventId = ctx.runtimeState.build?.hmr?.profile?.eventId;
-					if (hmrEventId != null && (isCssImporterDirty || currentStyleSignature && currentStyleSignature !== previousStyleSignature)) styleRefreshTokens.set(filename, hmrEventId);
-					else styleRefreshTokens.delete(filename);
-				}
-			}
-			if (!canReturnCachedCompilation) cachedCompilation.refreshToken = 1;
-			else {
-				const returnedCode = await measureVueHmrStage("finalizeCode", "vueFinalizeCodeMs", async () => finalizeTransformEntryCode({
-					result: cachedResult,
-					filename,
-					styleBlocks: cachedStyleBlocks,
-					isPage: cachedCompilation.isPage,
-					isApp,
-					isDev: configService.isDev,
-					sourceMap,
-					hmrStyleToken: styleRefreshTokens.get(filename)
-				}));
-				if (dirtyEntryId) dirtyVueEntryIds?.delete(dirtyEntryId);
-				reportTiming(filename, cachedCompilation.isPage);
-				return {
-					code: returnedCode.code,
-					map: returnedCode.map
-				};
-			}
-		}
-		const currentStyleIndependentSignature = configService.isDev && dirtyEntryId && canAttemptStyleOnlyReuse && filename.endsWith(".vue") ? resolveVueSfcStyleIndependentSignature(transformedSource, filename) : void 0;
-		if (Boolean(configService.isDev && cachedCompilation && dirtyEntryId && canAttemptStyleOnlyReuse && filename.endsWith(".vue") && !ctx.runtimeState.scan.isDirty && cachedCompilation.autoRoutesSignature === autoRoutesSignature && cachedCompilation.styleIndependentSignature && currentStyleIndependentSignature && cachedCompilation.styleIndependentSignature === currentStyleIndependentSignature && cachedCompilation.source !== transformedSource) && cachedCompilation) {
-			const cachedResult = normalizeVueTransformResult(cachedCompilation.result);
-			const styleBlocks = await measureStage("loadStyleOnlySfcStyles", async () => await loadStyleBlocksForStyleOnlyRefresh({
-				filename,
-				source: transformedSource,
-				styleBlocksCache,
-				force: true,
-				readAndParseSfc,
-				createReadAndParseSfcOptions,
-				pluginCtx,
-				configService
-			}));
-			if (!refreshStyleOnlyVueTransformResult(cachedResult, filename, styleBlocks)) cachedCompilation.styleIndependentSignature = void 0;
-			else {
-				cachedCompilation.source = transformedSource;
-				cachedCompilation.result = cachedResult;
-				cachedCompilation.styleIndependentSignature = currentStyleIndependentSignature;
-				cachedCompilation.refreshToken = 0;
-				const hmrEventId = ctx.runtimeState.build?.hmr?.profile?.eventId;
-				if (hmrEventId != null && (isCssImporterDirty || styleBlocks?.length)) styleRefreshTokens.set(filename, hmrEventId);
-				const returnedCode = await measureVueHmrStage("finalizeCode", "vueFinalizeCodeMs", async () => finalizeTransformEntryCode({
-					result: cachedResult,
-					filename,
-					styleBlocks,
-					isPage: cachedCompilation.isPage,
-					isApp,
-					isDev: configService.isDev,
-					sourceMap,
-					hmrStyleToken: styleRefreshTokens.get(filename)
-				}));
-				if (dirtyEntryId) dirtyVueEntryIds?.delete(dirtyEntryId);
-				reportTiming(filename, cachedCompilation.isPage);
-				return {
-					code: returnedCode.code,
-					map: returnedCode.map
-				};
-			}
-		}
+		const reuseResult = await tryReuseVueCompilation({
+			ctx,
+			pluginCtx,
+			filename,
+			source: transformedSource,
+			cachedCompilation,
+			previousStyleSignature,
+			autoRoutesSignature,
+			dirtyEntryId,
+			dirtyVueEntryIds,
+			isCssImporterDirty,
+			canAttemptStyleOnlyReuse,
+			sourceMap,
+			isApp,
+			styleBlocksCache,
+			styleRefreshTokens,
+			readAndParseSfc,
+			createReadAndParseSfcOptions,
+			measureStage,
+			measureVueHmrStage,
+			reportTiming
+		});
+		if (reuseResult.returnedCode) return {
+			code: reuseResult.returnedCode.code,
+			map: reuseResult.returnedCode.map
+		};
+		const { currentStyleIndependentSignature } = reuseResult;
 		const compileOptions = createCompileVueFileOptions(ctx, pluginCtx, filename, isPage, isApp, configService, {
 			reExportResolutionCache,
 			classStyleRuntimeWarned,
 			compileOptionsCache,
 			componentMetaCache
 		});
-		const result = normalizeVueTransformResult(await measureVueHmrStage("compile", "vueCompileMs", async () => await compileTransformEntryResult({
-			transformedSource,
-			filename,
-			compileOptions,
-			compileVueFile,
-			compileJsxFile
-		})));
-		let currentStyleBlocks = Array.isArray(result.meta?.styleBlocks) ? result.meta.styleBlocks : styleBlocksCache.get(filename);
-		if (!currentStyleBlocks) currentStyleBlocks = await measureStage("preloadSfcStyles", async () => await loadStyleBlocksForStyleOnlyRefresh({
-			filename,
-			source: transformedSource,
-			styleBlocksCache,
-			readAndParseSfc,
-			createReadAndParseSfcOptions,
-			pluginCtx,
-			configService
-		}));
-		if (currentStyleBlocks) styleBlocksCache.set(filename, currentStyleBlocks);
-		if (configService.isDev && dirtyEntryId) {
-			const currentStyleSignature = createSfcStyleBlocksSignature(currentStyleBlocks);
-			const hmrEventId = ctx.runtimeState.build?.hmr?.profile?.eventId;
-			if (hmrEventId != null && (isCssImporterDirty || currentStyleSignature && currentStyleSignature !== previousStyleSignature)) styleRefreshTokens.set(filename, hmrEventId);
-			else styleRefreshTokens.delete(filename);
-			dirtyVueEntryIds?.delete(dirtyEntryId);
-		}
-		const sfcStyleDependencies = syncVueSfcStyleDependencies(ctx, filename, currentStyleBlocks);
-		for (const dependency of sfcStyleDependencies) addNormalizedWatchFile(pluginCtx, dependency);
-		registerScopedSlotHostGenerics(ctx, result.scopedSlotComponents, parseUsingComponents(result.config));
-		await measureVueHmrStage("finalizeCompiledResult", "vueFinalizeCompiledMs", async () => {
-			await finalizeTransformCompiledResult({
+		const jsonOnlyResult = await measureVueHmrStage("refreshJsonConfig", "vueCompileMs", async () => {
+			return await tryRefreshJsonOnlyVueCompilation({
+				cachedResult: cachedCompilation?.result,
+				compileOptions,
+				dirtyEntryId,
+				dirtyReasonSummary: ctx.runtimeState?.build?.hmr?.profile?.dirtyReasonSummary,
+				filename,
+				isDev: configService.isDev,
+				scanDirty: ctx.runtimeState.scan.isDirty,
+				source: transformedSource,
+				autoRoutesSignature,
+				cachedAutoRoutesSignature: cachedCompilation?.autoRoutesSignature
+			});
+		});
+		if (jsonOnlyResult) {
+			const returnedCode = await finalizeVueTransform({
 				ctx,
 				pluginCtx,
 				filename,
 				source: transformedSource,
 				autoRoutesSignature,
-				result,
+				result: jsonOnlyResult,
 				compilationCache,
-				styleIndependentSignature: filename.endsWith(".vue") ? currentStyleIndependentSignature ?? resolveVueSfcStyleIndependentSignature(transformedSource, filename) : void 0,
-				setAppShell,
-				configService,
+				currentStyleIndependentSignature: cachedCompilation?.styleIndependentSignature,
+				previousStyleSignature,
+				dirtyEntryId,
+				dirtyVueEntryIds,
+				isCssImporterDirty,
 				isPage,
 				isApp,
 				sourceMap,
+				styleBlocksCache,
+				styleRefreshTokens,
 				scopedSlotModules,
 				emittedScopedSlotChunks,
-				addWatchFile: addNormalizedWatchFile,
-				emitScopedSlotChunks
+				setAppShell,
+				readAndParseSfc,
+				createReadAndParseSfcOptions,
+				measureStage,
+				measureVueHmrStage,
+				reportTiming
 			});
-		});
-		const returnedCode = await measureVueHmrStage("finalizeCode", "vueFinalizeCodeMs", async () => finalizeTransformEntryCode({
-			result,
+			return {
+				code: returnedCode.code,
+				map: returnedCode.map
+			};
+		}
+		const result = normalizeVueTransformResult(await measureVueHmrStage("compile", "vueCompileMs", async () => await compileTransformEntryResult({
+			transformedSource,
+			filename,
+			compileOptions,
+			compileVueFile,
+			compileJsxFile
+		})));
+		const returnedCode = await finalizeVueTransform({
+			ctx,
+			pluginCtx,
 			filename,
-			styleBlocks: result.meta?.styleBlocks ?? styleBlocksCache.get(filename),
+			source: transformedSource,
+			autoRoutesSignature,
+			result,
+			compilationCache,
+			currentStyleIndependentSignature,
+			previousStyleSignature,
+			dirtyEntryId,
+			dirtyVueEntryIds,
+			isCssImporterDirty,
 			isPage,
 			isApp,
-			isDev: configService.isDev,
 			sourceMap,
-			hmrStyleToken: configService.isDev ? styleRefreshTokens.get(filename) : void 0
-		}));
-		reportTiming(filename, isPage);
+			styleBlocksCache,
+			styleRefreshTokens,
+			scopedSlotModules,
+			emittedScopedSlotChunks,
+			setAppShell,
+			readAndParseSfc,
+			createReadAndParseSfcOptions,
+			measureStage,
+			measureVueHmrStage,
+			reportTiming
+		});
 		return {
 			code: returnedCode.code,
 			map: returnedCode.map
@@ -29282,7 +30563,7 @@ async function loadAppEntry(ctx, scanState) {
 	const { path: appEntryPath } = appEntry;
 	let configFromVue;
 	if (!appConfigFile && vueAppPath) {
-		const { extractConfigFromVue } = await import("./file-DhBNEU2N.mjs");
+		const { extractConfigFromVue } = await import("./file-DYC-Rc4v.mjs");
 		configFromVue = await extractConfigFromVue(vueAppPath);
 		if (configFromVue) appConfigFile = vueAppPath;
 	}