@weapp-vite/miniprogram-automator 1.2.23 → 1.4.0

package/dist/{launch-CSjvON-f.mjs → launch-ElaGbFxh.mjs}

@@ -8,7 +8,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -58,6 +58,41 @@ function createAppInstance(definition) {
 	return instance;
 }
 //#endregion
+//#region ../../mpcore/packages/simulator/src/host/attachmentBindingUpdates.ts
+const bindingUpdates = /* @__PURE__ */ new WeakMap();
+const instanceScopes = /* @__PURE__ */ new WeakMap();
+/** 实例经渲染上下文归属页面，不扩展公开 renderer context 的参数契约。 */
+function bindAttachmentBindingScope(instance, scope) {
+	instanceScopes.set(instance, instanceScopes.get(scope) ?? scope);
+}
+/** 仅在挂载回调内同步逻辑绑定，不接管视图提交和 setData 回调。 */
+function runWithAttachmentBindingUpdates(scope, update, callback, value) {
+	const previous = bindingUpdates.get(scope);
+	const state = previous ?? {
+		revision: 0,
+		update
+	};
+	const previousUpdate = state.update;
+	state.update = update;
+	bindingUpdates.set(scope, state);
+	try {
+		return callback(value);
+	} finally {
+		if (previous) state.update = previousUpdate;
+		else bindingUpdates.delete(scope);
+	}
+}
+function getAttachmentBindingRevision(instance) {
+	return bindingUpdates.get(instanceScopes.get(instance) ?? instance);
+}
+function synchronizeAttachmentBindings(instance) {
+	const state = bindingUpdates.get(instanceScopes.get(instance) ?? instance);
+	if (state) {
+		state.revision++;
+		state.update();
+	}
+}
+//#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/componentInstance/shared.ts
 const ARRAY_INDEX_PATH_RE$1 = /\[(\d+)\]/g;
 const ARRAY_INDEX_SEGMENT_RE$1 = /^\d+$/;
@@ -128,11 +163,14 @@ function runPropertyObservers(definition, instance, changedKeys, previousPropert
 	const changedRoots = new Set(changedKeys.map((key) => parseDataPath$1(key)[0]));
 	for (const changedKey of Object.keys(propOptions)) {
 		if (!changedRoots.has(changedKey)) continue;
+		const value = instance.properties[changedKey];
+		if ((value === null || typeof value !== "object") && Object.hasOwn(previousProperties, changedKey) && Object.is(value, previousProperties[changedKey])) continue;
 		const option = propOptions[changedKey];
 		if (!option || typeof option !== "object" || Array.isArray(option)) continue;
 		const observer = typeof option.observer === "string" ? instance[option.observer] : option.observer;
 		if (typeof observer !== "function") continue;
-		observer.call(instance, instance.properties[changedKey], previousProperties[changedKey]);
+		const changedPath = parseDataPath$1(changedKeys.find((key) => parseDataPath$1(key)[0] === changedKey)).map((segment) => isArrayIndexSegment$1(segment) ? Number(segment) : segment);
+		observer.call(instance, value, previousProperties[changedKey], changedPath);
 	}
 }
 function normalizeObserverPattern(pattern) {
@@ -343,7 +381,6 @@ function resolveInitialProperties(definition, properties) {
 		if (option && typeof option === "object" && !Array.isArray(option) && "value" in option) resolved[key] = resolvePropertyDefaultValue(option, definition);
 		else resolved[key] = cloneValue$1(resolveDefaultValueByType(normalizePropertyType(option)));
 	}
-	for (const [key, value] of Object.entries(properties)) if (!(key in resolved)) resolved[key] = value;
 	return resolved;
 }
 //#endregion
@@ -743,7 +780,7 @@ const basename = function(p, extension) {
 	}
 	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 };
-const parse$2 = function(p) {
+const parse$3 = function(p) {
 	const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
 	const base = basename(p);
 	const extension = extname(base);
@@ -769,7 +806,7 @@ const _path = {
 	matchesGlob,
 	normalize,
 	normalizeString,
-	parse: parse$2,
+	parse: parse$3,
 	relative,
 	resolve,
 	sep: "/",
@@ -804,11 +841,11 @@ const opposite = {
 function definitions(instance) {
 	return Object.entries(instance.__definition__?.relations ?? {});
 }
-function includesBehavior(behaviors, target) {
-	return Array.isArray(behaviors) && behaviors.some((behavior) => behavior === target || behavior && typeof behavior === "object" && includesBehavior(behavior.behaviors, target));
+function includesBehavior$1(behaviors, target) {
+	return Array.isArray(behaviors) && behaviors.some((behavior) => behavior === target || behavior && typeof behavior === "object" && includesBehavior$1(behavior.behaviors, target));
 }
 function matches(source, key, relation, target) {
-	if (relation.target) return includesBehavior(target.__definition__?.behaviors, relation.target);
+	if (relation.target) return includesBehavior$1(target.__definition__?.behaviors, relation.target);
 	const targetPath = key.startsWith("/") ? key.slice(1) : posix.join(posix.dirname(String(source.is)), key);
 	return posix.normalize(targetPath) === target.is;
 }
@@ -882,29 +919,24 @@ function detachComponentRelations(instances) {
 //#region ../../mpcore/packages/simulator/src/runtime/componentInstance/index.ts
 function createComponentInstance(options) {
 	const definition = normalizeComponentDefinition(options.definition);
-	const inputProperties = resolveInitialProperties(definition, options.properties ?? {});
 	const data = {
 		...resolveInitialData$1(definition),
-		...Object.fromEntries(Object.keys(definition.properties ?? {}).map((key) => [key, inputProperties[key]]))
+		...resolveInitialProperties(definition, options.properties ?? {})
 	};
 	const instance = {
 		__definition__: definition,
 		data,
 		__propertySnapshots__: {},
-		properties: {
-			...data,
-			...inputProperties
-		},
+		properties: data,
 		getRelationNodes(key) {
 			return getComponentRelationNodes(instance, key);
 		},
 		setData(patch, callback) {
 			const changedKeys = Object.keys(patch);
-			const dataKeys = [...new Set(changedKeys.map((key) => parseDataPath$1(key)[0]))];
-			const propertyKeys = dataKeys.filter((key) => Object.hasOwn(definition.properties ?? {}, key));
+			const propertyKeys = [...new Set(changedKeys.map((key) => parseDataPath$1(key)[0]))].filter((key) => Object.hasOwn(definition.properties ?? {}, key));
 			const previousProperties = Object.fromEntries(propertyKeys.map((key) => [key, cloneValue$1(instance.properties[key])]));
 			for (const [key, value] of Object.entries(patch)) assignByPath$1(instance.data, key, value);
-			for (const key of dataKeys) instance.properties[key] = instance.data[key];
+			synchronizeAttachmentBindings(instance);
 			runComponentObservers(definition, instance, changedKeys, previousProperties);
 			if (options.requestRender) options.requestRender(callback);
 			else callback?.();
@@ -946,8 +978,11 @@ const componentPageInstances = /* @__PURE__ */ new WeakSet();
 function isComponentPageAttaching(instance) {
 	return attachingInstances.has(instance);
 }
-function registerComponentPageAttachment(definition, attach) {
-	definitionAttachments.set(definition, attach);
+function registerComponentPageAttachment(definition, created, attached) {
+	definitionAttachments.set(definition, {
+		created,
+		attached
+	});
 }
 function bindComponentPageAttachment(instance, definition) {
 	const attach = definitionAttachments.get(definition);
@@ -958,13 +993,14 @@ function bindComponentPageAttachment(instance, definition) {
 		if (typeof options?.styleIsolation === "string") instanceStyleIsolation.set(instance, options.styleIsolation);
 	}
 }
-function attachComponentPage(instance) {
+function attachComponentPage(instance, updateBindings) {
 	const attach = instanceAttachments.get(instance);
 	if (!attach) return false;
 	instanceAttachments.delete(instance);
 	attachingInstances.add(instance);
 	try {
-		attach.call(instance);
+		attach.created(instance);
+		runWithAttachmentBindingUpdates(instance, updateBindings, attach.attached, instance);
 	} finally {
 		attachingInstances.delete(instance);
 	}
@@ -1114,6 +1150,7 @@ function createPageInstance(route, definition, options = {}, pageState = {}) {
 				const rootKey = parseDataPath(key)[0];
 				if (rootKey) instance.properties[rootKey] = instance.data[rootKey];
 			}
+			synchronizeAttachmentBindings(instance);
 			if (pageState.requestRender) pageState.requestRender(callback);
 			else callback?.();
 		}
@@ -1126,6 +1163,287 @@ function createPageInstance(route, definition, options = {}, pageState = {}) {
 	return instance;
 }
 //#endregion
+//#region ../../mpcore/packages/simulator/src/view/eventBindingParser.ts
+const LEGACY_EVENT_NAME_RE = /^\w+$/;
+const EVENT_BINDING_PREFIXES = [
+	{
+		prefix: "capture-bind:",
+		priority: 0,
+		stopAfter: false,
+		phase: "capture"
+	},
+	{
+		prefix: "capture-catch:",
+		priority: 0,
+		stopAfter: true,
+		phase: "capture"
+	},
+	{
+		prefix: "capture-bind",
+		priority: 1,
+		stopAfter: false,
+		phase: "capture"
+	},
+	{
+		prefix: "capture-catch",
+		priority: 1,
+		stopAfter: true,
+		phase: "capture"
+	},
+	{
+		prefix: "bind:",
+		priority: 0,
+		stopAfter: false,
+		phase: "bubble"
+	},
+	{
+		prefix: "catch:",
+		priority: 0,
+		stopAfter: true,
+		phase: "bubble"
+	},
+	{
+		prefix: "bind",
+		priority: 1,
+		stopAfter: false,
+		phase: "bubble"
+	},
+	{
+		prefix: "catch",
+		priority: 1,
+		stopAfter: true,
+		phase: "bubble"
+	}
+];
+function parseEventBinding(attributeName, method) {
+	const definition = EVENT_BINDING_PREFIXES.find((item) => attributeName.startsWith(item.prefix));
+	if (!definition) return null;
+	const eventName = attributeName.slice(definition.prefix.length);
+	if (!eventName || !definition.prefix.endsWith(":") && !LEGACY_EVENT_NAME_RE.test(eventName)) return null;
+	return {
+		eventName,
+		method,
+		phase: definition.phase,
+		priority: definition.priority,
+		stopAfter: definition.stopAfter
+	};
+}
+function collectEventBindings(attributes = {}, includeCapture = true) {
+	const eventBindings = /* @__PURE__ */ new Map();
+	let captureEventBindings;
+	const priorities = /* @__PURE__ */ new Map();
+	for (const [attributeName, method] of Object.entries(attributes)) {
+		const candidate = parseEventBinding(attributeName, method);
+		if (!candidate || !includeCapture && candidate.phase === "capture") continue;
+		const eventPriorities = priorities.get(candidate.eventName) ?? {};
+		if (candidate.priority < (eventPriorities[candidate.phase] ?? -1)) continue;
+		(candidate.phase === "bubble" ? eventBindings : captureEventBindings ??= /* @__PURE__ */ new Map()).set(candidate.eventName, {
+			method: candidate.method,
+			stopAfter: candidate.stopAfter
+		});
+		eventPriorities[candidate.phase] = candidate.priority;
+		priorities.set(candidate.eventName, eventPriorities);
+	}
+	return {
+		eventBindings,
+		captureEventBindings
+	};
+}
+/** 单事件查询只保留命中的绑定，原生交互不构造整张事件表。 */
+function resolveEventBindingPhases(attributes, eventName, includeCapture = true) {
+	if (!attributes) return null;
+	let bindings = null;
+	let bubblePriority = -1;
+	let capturePriority = -1;
+	for (const [attributeName, method] of Object.entries(attributes)) {
+		const candidate = parseEventBinding(attributeName, method);
+		if (!candidate || candidate.eventName !== eventName || !includeCapture && candidate.phase === "capture") continue;
+		const priority = candidate.phase === "bubble" ? bubblePriority : capturePriority;
+		if (candidate.priority < priority) continue;
+		bindings ??= {};
+		bindings[candidate.phase] = {
+			method: candidate.method,
+			stopAfter: candidate.stopAfter
+		};
+		if (candidate.phase === "bubble") bubblePriority = candidate.priority;
+		else capturePriority = candidate.priority;
+	}
+	return bindings;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/nodeDataset.ts
+const DATASET_NAME_RE = /-([a-z])/g;
+function isDatasetAttribute(attributeName) {
+	return attributeName.startsWith("data-") && !attributeName.startsWith("data-sim-");
+}
+function toDatasetKey(attributeName) {
+	return attributeName.slice(5).replace(DATASET_NAME_RE, (_match, char) => char.toUpperCase());
+}
+function collectNodeDataset(node) {
+	if (node.dataset) return { ...node.dataset };
+	const dataset = {};
+	for (const [key, value] of Object.entries(node.attribs ?? {})) if (isDatasetAttribute(key)) dataset[toDatasetKey(key)] = value;
+	return dataset;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/componentEvent.ts
+const eventNodes = /* @__PURE__ */ new WeakMap();
+/** 原生默认行为读取声明所有者与原始属性，避免组件根折叠覆盖宿主边界。 */
+function getNativeNodeOwner(node) {
+	const entry = eventNodes.get(node);
+	return entry ? {
+		scopeId: entry.scope.getScopeId(),
+		target: entry.target
+	} : void 0;
+}
+/** 原生冒泡包含折叠的宿主绑定；catch 只截断其后的绑定和祖先。 */
+function visitNativeNodeEventBindings(node, eventName, visit) {
+	const collect = (entry) => {
+		const binding = entry.bindings ? entry.bindings.eventBindings?.get(eventName) : resolveEventBindingPhases(entry.target.attribs, eventName, false)?.bubble;
+		if (binding) visit(entry.scope.getScopeId(), entry.target, binding);
+		return binding?.stopAfter ?? false;
+	};
+	const entry = eventNodes.get(node);
+	if (!entry) {
+		const binding = resolveEventBindingPhases(node.attribs, eventName, false)?.bubble;
+		if (binding) visit(node.attribs?.["data-sim-scope"] ?? null, node, binding);
+		return binding?.stopAfter ?? false;
+	}
+	if (collect(entry)) return true;
+	for (const host of entry.hosts ?? []) if (collect(eventNodes.get(host))) return true;
+	return false;
+}
+/** 在构造子树之前建立父链，created/observer 中的事件也能访问声明树。 */
+function registerComponentEventNode(node, scope, parent) {
+	node.parent = parent ?? null;
+	eventNodes.set(node, {
+		scope,
+		target: node
+	});
+}
+/** 宿主与作用域共享同一份分阶段绑定，eventBindings 仍是原有的冒泡存储。 */
+function bindComponentEventHost(node) {
+	const bindings = collectEventBindings(node.attribs);
+	eventNodes.get(node).bindings = bindings;
+	return bindings;
+}
+/** 渲染会把宿主折叠进模板根；事件仍保留两层独立的绑定和声明所有者。 */
+function mergeComponentEventRoot(root, host) {
+	const entry = eventNodes.get(root);
+	if (entry.target === root) entry.target = {
+		attribs: root.attribs,
+		dataset: root.dataset
+	};
+	entry.hosts ??= [];
+	entry.hosts.push(host);
+	root.parent = host.parent;
+}
+/** 按渲染完成后的实际宿主父链排序；输入只包含本轮存活的组件作用域。 */
+function orderComponentAttachmentScopes(scopeIds, componentScopes) {
+	const hostScopes = /* @__PURE__ */ new Map();
+	for (const scopeId of scopeIds) hostScopes.set(componentScopes.get(scopeId).hostNode, scopeId);
+	const ordered = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (!node || visited.has(node)) return;
+		visited.add(node);
+		visit(node.parent);
+		const hosts = eventNodes.get(node)?.hosts;
+		if (hosts) for (let index = hosts.length - 1; index >= 0; index--) visit(hosts[index]);
+		const scopeId = hostScopes.get(node);
+		if (scopeId !== void 0) ordered.push(scopeId);
+	};
+	for (const host of hostScopes.keys()) visit(host);
+	return ordered;
+}
+function buildComponentTrigger(componentScopeId, context) {
+	return (instance, eventName, detail, triggerOptions) => {
+		const originScope = context.componentScopes.get(componentScopeId);
+		const origin = originScope?.hostNode;
+		if (!originScope || !origin) return;
+		const bubbles = triggerOptions?.bubbles ?? false;
+		const capturePhase = triggerOptions?.capturePhase ?? false;
+		const composed = triggerOptions?.composed ?? false;
+		const target = {
+			dataset: originScope.dataset ?? collectNodeDataset(origin),
+			id: originScope.hostId ?? ""
+		};
+		const mark = instance.__lastInteractionEvent__?.mark;
+		const listeners = [];
+		const collect = (entry, isOrigin) => {
+			if (!composed && entry.scope.getScopeId() !== originScope.listenerScopeId) return false;
+			const bindings = entry.bindings ? {
+				bubble: entry.bindings.eventBindings?.get(eventName),
+				capture: entry.bindings.captureEventBindings?.get(eventName)
+			} : resolveEventBindingPhases(entry.target.attribs, eventName);
+			if (bindings?.bubble || bindings?.capture) listeners.push({
+				scope: entry.scope,
+				bindings,
+				currentTarget: isOrigin ? target : {
+					dataset: collectNodeDataset(entry.target),
+					id: entry.target.attribs?.id ?? ""
+				},
+				origin: isOrigin
+			});
+			return true;
+		};
+		let current = origin;
+		while (current) {
+			const entry = eventNodes.get(current);
+			if (entry) {
+				if (!collect(entry, current === origin)) break;
+				let crossedBoundary = false;
+				for (const host of entry.hosts ?? []) if (!collect(eventNodes.get(host), false)) {
+					crossedBoundary = true;
+					break;
+				}
+				if (crossedBoundary) break;
+			}
+			if (!bubbles && !capturePhase) break;
+			current = current.parent;
+		}
+		const handlers = [];
+		let stopped = false;
+		if (capturePhase) for (let index = listeners.length - 1; index >= 0; index--) {
+			const listener = listeners[index];
+			const binding = listener.bindings.capture;
+			if (binding) {
+				handlers.push({
+					scope: listener.scope,
+					binding,
+					currentTarget: listener.currentTarget
+				});
+				if (binding.stopAfter) {
+					stopped = true;
+					break;
+				}
+			}
+		}
+		if (!stopped) for (const listener of listeners) {
+			if (!bubbles && !listener.origin) continue;
+			const binding = listener.bindings.bubble;
+			if (binding) {
+				handlers.push({
+					scope: listener.scope,
+					binding,
+					currentTarget: listener.currentTarget
+				});
+				if (binding.stopAfter) break;
+			}
+		}
+		for (const { scope, binding, currentTarget } of handlers) scope.getMethod(binding.method)?.({
+			bubbles,
+			capturePhase,
+			composed,
+			currentTarget,
+			detail,
+			mark,
+			target,
+			type: eventName
+		});
+	};
+}
+//#endregion
 //#region ../../mpcore/packages/simulator/src/view/conditionalChildren.ts
 function selectConditionalChildren(children, evaluate) {
 	const selected = [];
@@ -1181,11 +1499,77 @@ function customTabBarHostScope() {
 	};
 }
 //#endregion
+//#region ../../mpcore/packages/simulator/src/view/inspectionTree.ts
+const inspectionChildren = /* @__PURE__ */ new WeakMap();
+const inspectionParents = /* @__PURE__ */ new WeakMap();
+const emptyChildren = [];
+function getInspectionChildren(node) {
+	return inspectionChildren.get(node) ?? node.children ?? emptyChildren;
+}
+function getInspectionParent(node) {
+	return inspectionParents.get(node) ?? node.parent ?? null;
+}
+function collectRenderedNodes(node, nodes) {
+	if (nodes.has(node)) return;
+	nodes.add(node);
+	for (const child of node.children ?? emptyChildren) collectRenderedNodes(child, nodes);
+}
+/** 原生检查器保留未投影声明；可见 DOM、WXML 和事件父链不因此增加节点。 */
+function registerInspectionTrees(root, pass, scopes) {
+	if (!pass.hasUnprojectedSlots) return;
+	const rendered = /* @__PURE__ */ new Set();
+	collectRenderedNodes(root, rendered);
+	const candidates = /* @__PURE__ */ new Map();
+	for (const [entries, group] of pass.slotDeclarations) {
+		if (scopes.get(group.scopeId)?.hostNode !== group.parent) continue;
+		const host = pass.componentRoots.get(group.scopeId);
+		if (!host) continue;
+		for (const entry of entries) for (const node of pass.renderedSlots.get(entry) ?? emptyChildren) candidates.set(node, host);
+	}
+	const nested = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const indexChildren = (node) => {
+		if (visited.has(node)) return;
+		visited.add(node);
+		for (const child of node.children ?? emptyChildren) {
+			nested.add(child);
+			if (!rendered.has(child)) inspectionParents.set(child, node);
+			indexChildren(child);
+		}
+	};
+	for (const node of candidates.keys()) indexChildren(node);
+	for (const [node, host] of candidates) {
+		if (rendered.has(node) || nested.has(node) || node === host) continue;
+		let children = inspectionChildren.get(host);
+		if (!children) {
+			children = [...host.children ?? emptyChildren];
+			inspectionChildren.set(host, children);
+		}
+		children.push(node);
+		inspectionParents.set(node, host);
+	}
+}
+//#endregion
 //#region ../../mpcore/packages/simulator/src/view/loopEntries.ts
+const LOOP_SCOPE_ESCAPE_RE = /[^\w-]/g;
+function escapeScopeCodeUnit(character) {
+	return `~${character.charCodeAt(0).toString(16).padStart(4, "0")}`;
+}
+function encodeLoopCoordinate(value) {
+	return value.replace(LOOP_SCOPE_ESCAPE_RE, escapeScopeCodeUnit);
+}
 function resolveLoopEntries(value) {
 	if (Array.isArray(value)) return value.map((item, index) => [index, item]);
 	return value !== null && typeof value === "object" ? Object.entries(value) : [];
 }
+function resolveLoopInstanceSuffix(item, index, key, occurrences) {
+	if (!key || !occurrences) return `:for-${encodeLoopCoordinate(String(index))}`;
+	const value = key === "*this" ? item : item?.[key];
+	const normalized = encodeLoopCoordinate(String(value ?? ""));
+	const occurrence = occurrences.get(normalized) ?? 0;
+	occurrences.set(normalized, occurrence + 1);
+	return `:key-${normalized}${occurrence ? `:duplicate-${occurrence}` : ""}`;
+}
 //#endregion
 //#region ../../mpcore/packages/simulator/src/view/renderedTree.ts
 /** 在循环展开和组件替换完成后，让父节点关系指向本次渲染树。 */
@@ -1194,7 +1578,45 @@ function linkRenderedParents(root, parent = null) {
 	for (const child of root.children ?? []) linkRenderedParents(child, root);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+parser@8.0.6/node_modules/@babel/parser/lib/index.js
+//#region ../../mpcore/packages/simulator/src/view/renderPass.ts
+const initializedPages = /* @__PURE__ */ new WeakMap();
+function createRenderPass(propertyUpdate = false, parent) {
+	return {
+		seenComponentScopes: /* @__PURE__ */ new Set(),
+		componentRoots: /* @__PURE__ */ new Map(),
+		slotDeclarations: /* @__PURE__ */ new Map(),
+		renderedSlots: /* @__PURE__ */ new Map(),
+		hasUnprojectedSlots: false,
+		propertyUpdate,
+		bindingUpdate: parent?.bindingUpdate,
+		bindingRevision: parent?.bindingUpdate?.revision ?? 0
+	};
+}
+function createPageRenderPass(page, cache) {
+	const pass = createRenderPass(initializedPages.get(cache)?.has(page) ?? false);
+	pass.bindingUpdate = getAttachmentBindingRevision(page);
+	pass.bindingRevision = pass.bindingUpdate?.revision ?? 0;
+	return pass;
+}
+function isRenderPassStale(pass) {
+	return pass.bindingUpdate !== void 0 && pass.bindingUpdate.revision !== pass.bindingRevision;
+}
+function markPageTreeConstructed(page, cache) {
+	let pages = initializedPages.get(cache);
+	if (!pages) {
+		pages = /* @__PURE__ */ new WeakSet();
+		initializedPages.set(cache, pages);
+	}
+	pages.add(page);
+}
+function registerSlotDeclarations(pass, slots, parent, scopeId) {
+	for (const entries of slots.values()) if (!pass.slotDeclarations.has(entries)) pass.slotDeclarations.set(entries, {
+		parent,
+		scopeId
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@babel+parser@8.0.7/node_modules/@babel/parser/lib/index.js
 var Position = class {
 	constructor(line, col, index) {
 		this.line = void 0;
@@ -9263,7 +9685,11 @@ var StatementParser = class extends ExpressionParser {
 		if (isDeclaration) node.id = this.parseFunctionId(requireId);
 		this.scope.enter(514);
 		this.prodParam.enter(functionFlags(isAsync, node.generator));
-		if (!isDeclaration) node.id = this.parseFunctionId();
+		if (!isDeclaration && tokenIsIdentifier(this.state.type)) {
+			this.expressionScope.enter(newExpressionScope());
+			node.id = this.parseFunctionId();
+			this.expressionScope.exit();
+		}
 		this.parseFunctionParams(node, false);
 		this.parseFunctionBodyAndFinish(node, isDeclaration ? "FunctionDeclaration" : "FunctionExpression");
 		this.prodParam.exit();
@@ -12596,6 +13022,29 @@ var Parser$1 = class extends StatementParser {
 		return result;
 	}
 };
+function parse$2(input, options) {
+	if (options?.sourceType === "unambiguous") {
+		options = { ...options };
+		try {
+			options.sourceType = "module";
+			const parser = getParser(options, input);
+			const ast = parser.parse();
+			if (parser.sawUnambiguousESM) return ast;
+			if (parser.ambiguousScriptDifferentAst) try {
+				options.sourceType = "script";
+				return getParser(options, input).parse();
+			} catch {}
+			else ast.program.sourceType = "script";
+			return ast;
+		} catch (moduleError) {
+			try {
+				options.sourceType = "script";
+				return getParser(options, input).parse();
+			} catch {}
+			throw moduleError;
+		}
+	} else return getParser(options, input).parse();
+}
 function parseExpression(input, options) {
 	const parser = getParser(options, input);
 	if (parser.options.strictMode) parser.state.strict = true;
@@ -12913,7 +13362,8 @@ function isComponentAttached(instance) {
 	return attachmentStates.get(instance) === "attached";
 }
 function hasPendingComponentAttachments(instances) {
-	return [...instances].some((instance) => attachmentStates.get(instance) === "attaching");
+	for (const instance of instances) if (attachmentStates.get(instance) === "attaching") return true;
+	return false;
 }
 function flushComponentReady(instances, ready) {
 	const all = [...instances];
@@ -12923,19 +13373,71 @@ function flushComponentReady(instances, ready) {
 	for (const instance of pending) ready(instance);
 	return pending.length > 0;
 }
-function flushComponentAttachments(instances, attach) {
-	const pending = [...instances].filter((instance) => !attachmentStates.has(instance));
-	for (const instance of pending) attachmentStates.set(instance, "attaching");
+function flushComponentAttachments(componentCache, scopeIds, attach) {
+	const pending = /* @__PURE__ */ new Map();
+	for (const scopeId of scopeIds) {
+		const instance = componentCache.get(scopeId);
+		if (!instance) continue;
+		const state = attachmentStates.get(instance);
+		if (state === "attaching") return false;
+		if (!state) pending.set(scopeId, instance);
+	}
+	for (const instance of pending.values()) attachmentStates.set(instance, "attaching");
 	try {
-		for (const instance of pending) try {
-			attach(instance);
-		} finally {
-			attachmentStates.set(instance, "attached");
+		for (const [scopeId, instance] of pending) {
+			if (componentCache.get(scopeId) !== instance) return "restart";
+			let restart;
+			try {
+				restart = attach(instance);
+			} finally {
+				attachmentStates.set(instance, "attached");
+			}
+			if (restart) return "restart";
 		}
 	} finally {
-		for (const instance of pending) if (attachmentStates.get(instance) === "attaching") attachmentStates.delete(instance);
+		for (const instance of pending.values()) if (attachmentStates.get(instance) === "attaching") attachmentStates.delete(instance);
 	}
-	return pending.length > 0;
+	return pending.size > 0 ? "attached" : false;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/runtime/componentInstance/construction.ts
+const constructionStates = /* @__PURE__ */ new WeakMap();
+const constructingInstances = /* @__PURE__ */ new WeakSet();
+function isComponentConstructing(instance) {
+	return instance !== void 0 && constructingInstances.has(instance);
+}
+function hasPendingComponentConstruction(componentCache) {
+	return constructionStates.has(componentCache);
+}
+function beginComponentConstruction(componentCache, scopeId, instance) {
+	let state = constructionStates.get(componentCache);
+	if (!state) {
+		state = {
+			depth: 0,
+			created: /* @__PURE__ */ new Map()
+		};
+		constructionStates.set(componentCache, state);
+	}
+	state.depth++;
+	state.created.set(scopeId, instance);
+	constructingInstances.add(instance);
+}
+function discardComponentConstruction(componentCache, componentScopes, scopeId) {
+	const state = constructionStates.get(componentCache);
+	const prefix = `${scopeId}/`;
+	for (const [createdScopeId, instance] of state.created) {
+		if (createdScopeId !== scopeId && !createdScopeId.startsWith(prefix)) continue;
+		if (componentCache.get(createdScopeId) === instance) {
+			componentCache.delete(createdScopeId);
+			componentScopes.delete(createdScopeId);
+		}
+		state.created.delete(createdScopeId);
+	}
+}
+function finishComponentConstruction(componentCache, instance) {
+	constructingInstances.delete(instance);
+	const state = constructionStates.get(componentCache);
+	if (--state.depth === 0) constructionStates.delete(componentCache);
 }
 //#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/componentInstance/discardedReady.ts
@@ -12958,6 +13460,61 @@ function flushDiscardedComponentReady(cache, pageScopeId, ready) {
 	if (!pending.size) discardedReady.delete(cache);
 }
 //#endregion
+//#region ../../mpcore/packages/simulator/src/runtime/componentInstance/propertyBindings.ts
+const consumedPageChanges = /* @__PURE__ */ new WeakMap();
+function syncComponentProperties(instance, definition, nextProperties, bindingExpressions, changedPageKeys, beforeObservers) {
+	const freshPageChanges = changedPageKeys.length > 0 && consumedPageChanges.get(instance) !== changedPageKeys;
+	if (freshPageChanges) consumedPageChanges.set(instance, changedPageKeys);
+	const changedRootKeys = [];
+	const previousProperties = {};
+	for (const [key, value] of Object.entries(nextProperties)) {
+		if (!Object.hasOwn(definition.properties ?? {}, key)) continue;
+		const nextValue = normalizeComponentPropertyValue(definition, key, value);
+		const bindingExpression = bindingExpressions[key];
+		const bindingAffected = freshPageChanges && !!bindingExpression && changedPageKeys.some((changedKey) => {
+			return changedKey === bindingExpression || changedKey.startsWith(`${bindingExpression}.`) || changedKey.startsWith(`${bindingExpression}[`);
+		});
+		const previousSnapshot = instance.__propertySnapshots?.[key];
+		if (hasComponentPropertyValueChanged(instance.properties[key], previousSnapshot, nextValue, bindingAffected)) {
+			previousProperties[key] = instance.properties[key];
+			const deliveredValue = cloneValue$1(nextValue);
+			instance.properties[key] = deliveredValue;
+			changedRootKeys.push(key);
+		}
+		instance.__propertySnapshots ??= {};
+		instance.__propertySnapshots[key] = cloneValue$1(nextValue);
+	}
+	if (changedRootKeys.length === 0) return;
+	beforeObservers?.(instance, "properties");
+	runComponentObservers(definition, instance, changedRootKeys, previousProperties);
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/runtime/componentInstance/reconcileRemoved.ts
+/** 用户卸载钩子失败也要完成关系与缓存收尾，避免下一次渲染重复卸载同一实例。 */
+function reconcileRemovedComponents(cache, scopes, activeScopeIds, pageScopeId) {
+	const removed = [...cache].filter(([scopeId]) => scopeId.startsWith(`${pageScopeId}/`) && !activeScopeIds.has(scopeId));
+	let failure;
+	for (const [scopeId, instance] of removed) try {
+		if (isComponentAttached(instance)) runComponentLifecycle(instance, "detached");
+		else scheduleDiscardedComponentReady(cache, scopeId, instance);
+	} catch (error) {
+		failure ??= { error };
+	}
+	let relationsChanged = false;
+	try {
+		relationsChanged = syncComponentRelations(cache, activeScopeIds, pageScopeId);
+	} catch (error) {
+		failure ??= { error };
+	} finally {
+		for (const [scopeId] of removed) {
+			cache.delete(scopeId);
+			scopes.delete(scopeId);
+		}
+	}
+	if (failure) throw failure.error;
+	return relationsChanged;
+}
+//#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/pageLifecycle.ts
 const loadingPages = /* @__PURE__ */ new WeakSet();
 function isPageBeforeReady(page) {
@@ -13047,97 +13604,9 @@ function createPluginArtifactSource(fallback, miniprogramRootPath, plugins) {
 	};
 }
 //#endregion
-//#region ../../mpcore/packages/simulator/src/view/nodeDataset.ts
-const DATASET_NAME_RE = /-([a-z])/g;
-function isDatasetAttribute(attributeName) {
-	return attributeName.startsWith("data-") && !attributeName.startsWith("data-sim-");
-}
-function toDatasetKey(attributeName) {
-	return attributeName.slice(5).replace(DATASET_NAME_RE, (_match, char) => char.toUpperCase());
-}
-function collectNodeDataset(node) {
-	if (node.dataset) return { ...node.dataset };
-	const dataset = {};
-	for (const [key, value] of Object.entries(node.attribs ?? {})) if (isDatasetAttribute(key)) dataset[toDatasetKey(key)] = value;
-	return dataset;
-}
-//#endregion
-//#region ../../mpcore/packages/simulator/src/view/eventBinding.ts
-const LEGACY_EVENT_NAME_RE = /^\w+$/;
-const EVENT_BINDING_PREFIXES = [
-	{
-		prefix: "bind:",
-		priority: 0,
-		stopAfter: false
-	},
-	{
-		prefix: "catch:",
-		priority: 0,
-		stopAfter: true
-	},
-	{
-		prefix: "bind",
-		priority: 1,
-		stopAfter: false
-	},
-	{
-		prefix: "catch",
-		priority: 1,
-		stopAfter: true
-	}
-];
-function parseEventBinding(attributeName, method) {
-	const definition = EVENT_BINDING_PREFIXES.find((item) => attributeName.startsWith(item.prefix));
-	if (!definition) return null;
-	const eventName = attributeName.slice(definition.prefix.length);
-	if (!eventName || !definition.prefix.endsWith(":") && !LEGACY_EVENT_NAME_RE.test(eventName)) return null;
-	return {
-		eventName,
-		method,
-		priority: definition.priority,
-		stopAfter: definition.stopAfter
-	};
-}
-function collectMiniProgramEventBindings(attributes = {}) {
-	const bindings = /* @__PURE__ */ new Map();
-	const priorities = /* @__PURE__ */ new Map();
-	for (const [attributeName, method] of Object.entries(attributes)) {
-		const candidate = parseEventBinding(attributeName, method);
-		if (!candidate || candidate.priority < (priorities.get(candidate.eventName) ?? -1)) continue;
-		bindings.set(candidate.eventName, {
-			method: candidate.method,
-			stopAfter: candidate.stopAfter
-		});
-		priorities.set(candidate.eventName, candidate.priority);
-	}
-	return bindings;
-}
-function resolveMiniProgramEventBinding(attributes, eventName) {
-	return collectMiniProgramEventBindings(attributes).get(eventName) ?? null;
-}
-/** 冒泡时保留原始 target，currentTarget 则属于当前执行绑定的节点。 */
-function createMiniProgramEventPayload(node, eventName, event, origin = node) {
-	const dataset = collectNodeDataset(node);
-	const nodeId = node.attribs?.id ?? "";
-	const isOrigin = node === origin;
-	return {
-		bubbles: false,
-		capturePhase: false,
-		composed: false,
-		currentTarget: {
-			dataset: isOrigin ? event.currentTarget?.dataset ?? event.dataset ?? dataset : dataset,
-			id: isOrigin ? event.currentTarget?.id ?? event.id ?? nodeId : nodeId
-		},
-		detail: event.detail,
-		mark: event.mark,
-		target: {
-			dataset: event.target?.dataset ?? event.dataset ?? (isOrigin ? dataset : collectNodeDataset(origin)),
-			id: event.target?.id ?? event.id ?? origin.attribs?.id ?? ""
-		},
-		timeStamp: Date.now(),
-		type: eventName
-	};
-}
+//#region ../../@weapp-core/constants/dist/index.js
+/** 无头测试后端不支持所请求的自动化协议。 */
+const HEADLESS_PROTOCOL_UNSUPPORTED = "HEADLESS_PROTOCOL_UNSUPPORTED";
 const WEVU_NATIVE_INSTANCE_KEY = "__wevuNativeInstance";
 /** 宿主值为 1 时，实现带 routeEventId 的路由阶段契约；不代表微信 SDK 版本。 */
 const WEVU_ROUTE_EVENT_CONTRACT_KEY = "__wevuRouteEventContract";
@@ -13251,66 +13720,155 @@ function resolveMiniProgramComponent(ownerFilePath, request, miniprogramRootPath
 	return npmPath ? relative(miniprogramRootPath, npmPath).slice(0, -3) : localPath;
 }
 //#endregion
-//#region ../../mpcore/packages/simulator/src/view/templateImports.ts
-function createImportedTemplateState(root, filePath, loadImport, loadWxs) {
-	const documents = /* @__PURE__ */ new Map();
-	const definitionScopes = /* @__PURE__ */ new Map();
-	const definitionWxsScopes = /* @__PURE__ */ new Map();
-	const collect = (node, owner) => {
-		const existing = documents.get(owner);
-		if (existing) return existing;
-		const state = createTemplateRenderState(node);
-		const wxsModules = Object.create(null);
-		const ownDefinitions = new Map(state.definitions);
-		const document = {
-			state,
-			exports: ownDefinitions
-		};
-		documents.set(owner, document);
-		const visit = (child) => {
-			if (child.name === "wxs" && loadWxs) {
-				const name = child.attribs?.module;
-				if (!name || !/^[a-z_$][\w$]*$/i.test(name) || [
-					"__proto__",
-					"constructor",
-					"prototype"
-				].includes(name)) throw new Error(`Invalid WXS module name in ${owner}: ${String(name)}`);
-				if (Object.hasOwn(wxsModules, name)) throw new Error(`Duplicate WXS module in ${owner}: ${name}`);
-				wxsModules[name] = loadWxs(owner, child);
-				return;
-			}
-			if (child.name === "import" && child.attribs?.src) {
-				const source = child.attribs.src;
-				const imported = loadImport(owner, source.endsWith(".wxml") ? source : `${source}.wxml`);
-				const importedDocument = collect(imported.root, imported.filePath);
-				for (const [name, definition] of importedDocument.exports) state.definitions.set(name, definition);
-			}
-			for (const nested of child.children ?? []) visit(nested);
-		};
-		visit(node);
-		if (Object.keys(wxsModules).length) state.wxsModules = wxsModules;
-		for (const [name, definition] of ownDefinitions) {
-			state.definitions.set(name, definition);
-			definitionScopes.set(definition, state.definitions);
-			if (state.wxsModules) definitionWxsScopes.set(definition, state.wxsModules);
-		}
-		state.definitionScopes = definitionScopes;
-		state.definitionWxsScopes = definitionWxsScopes;
-		return document;
+//#region ../../mpcore/packages/simulator/src/view/nodeEvents.ts
+/** 正确字段优先；复制触点，避免处理器修改调用者持有的数据。 */
+function readTouchEventPayload(event) {
+	const changedTouches = event.changedTouches ?? event.changeTouches;
+	return {
+		...event.touches === void 0 ? {} : { touches: event.touches.map((touch) => ({ ...touch })) },
+		...changedTouches === void 0 ? {} : { changedTouches: changedTouches.map((touch) => ({ ...touch })) }
 	};
-	return collect(root, filePath).state;
 }
 //#endregion
-//#region ../../mpcore/packages/simulator/src/view/templateText.ts
-function interpolateTemplateText(input, data, emptyNull = false) {
-	let output = "";
-	let offset = 0;
-	for (const range of templateInterpolations(input)) {
-		const value = resolveTemplateExpression(data, range.expression);
-		output += input.slice(offset, range.start) + (value === void 0 || emptyNull && value === null ? "" : String(value));
-		offset = range.end;
+//#region ../../mpcore/packages/simulator/src/view/eventBinding.ts
+function resolveMiniProgramEventBinding(attributes, eventName) {
+	return resolveEventBindingPhases(attributes, eventName, false)?.bubble ?? null;
+}
+/** 冒泡时保留原始 target，currentTarget 则属于当前执行绑定的节点。 */
+function createMiniProgramEventPayload(node, eventName, event, origin = node) {
+	const dataset = collectNodeDataset(node);
+	const nodeId = node.attribs?.id ?? "";
+	const isOrigin = node === origin;
+	return {
+		...readTouchEventPayload(event),
+		bubbles: false,
+		capturePhase: false,
+		composed: false,
+		currentTarget: {
+			dataset: isOrigin ? event.currentTarget?.dataset ?? event.dataset ?? dataset : dataset,
+			id: isOrigin ? event.currentTarget?.id ?? event.id ?? nodeId : nodeId
+		},
+		detail: event.detail,
+		mark: event.mark,
+		target: {
+			dataset: event.target?.dataset ?? event.dataset ?? (isOrigin ? dataset : collectNodeDataset(origin)),
+			id: event.target?.id ?? event.id ?? origin.attribs?.id ?? ""
+		},
+		timeStamp: Date.now(),
+		type: eventName
+	};
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/nativeForm.ts
+const pickerValues = /* @__PURE__ */ new WeakMap();
+/** 保存 picker 的原始数组属性，不能从渲染后的逗号字符串反推选项值。 */
+function setNativePickerValue(node, value) {
+	if (node.name === "picker") pickerValues.set(node, value);
+}
+function includesBehavior(definition, name, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(definition)) return false;
+	visited.add(definition);
+	return Array.isArray(definition.behaviors) && definition.behaviors.some((behavior) => behavior === name || behavior !== null && typeof behavior === "object" && includesBehavior(behavior, name, visited));
+}
+function nativeOwner(node) {
+	return getNativeNodeOwner(node) ?? {
+		scopeId: node.attribs?.["data-sim-scope"] ?? null,
+		target: node
+	};
+}
+function participatingScopes(formScope, pageScope, resolveComponent) {
+	const scopes = /* @__PURE__ */ new Set([null, pageScope]);
+	let current = formScope;
+	while (current && !scopes.has(current)) {
+		scopes.add(current);
+		current = resolveComponent?.(current)?.ownerScopeId ?? null;
 	}
-	return output + input.slice(offset);
+	return scopes;
+}
+function participates(scopeId, formScopes, behavior, resolveComponent) {
+	const visited = /* @__PURE__ */ new Set();
+	while (!formScopes.has(scopeId)) {
+		if (!scopeId || visited.has(scopeId)) return false;
+		visited.add(scopeId);
+		const component = resolveComponent?.(scopeId);
+		if (!component || !includesBehavior(component.definition, behavior)) return false;
+		scopeId = component.ownerScopeId;
+	}
+	return true;
+}
+function checked(attributes, name) {
+	const value = attributes?.[name];
+	return value !== void 0 && value !== "false" && value !== "0";
+}
+function choiceValues(group, pageScope, resolveComponent) {
+	const values = [];
+	const scopes = participatingScopes(nativeOwner(group).scopeId, pageScope, resolveComponent);
+	const choice = group.name === "radio-group" ? "radio" : "checkbox";
+	const visit = (node) => {
+		if (node.name === "form" || node.name === "radio-group" || node.name === "checkbox-group") return;
+		if (node.name === choice) {
+			const owner = nativeOwner(node);
+			if (checked(owner.target.attribs, "checked") && participates(owner.scopeId, scopes, "wx://form-field-group", resolveComponent)) values.push(owner.target.attribs?.value ?? "");
+		}
+		for (const child of node.children ?? []) visit(child);
+	};
+	for (const child of group.children ?? []) visit(child);
+	return values;
+}
+function collectFormValues(form, scopes, pageScope, resolveComponent) {
+	const values = Object.create(null);
+	const visit = (node) => {
+		if (node.name === "form") return;
+		const owner = nativeOwner(node);
+		const attributes = owner.target.attribs;
+		const name = attributes?.name;
+		if (attributes && name && participates(owner.scopeId, scopes, "wx://form-field-group", resolveComponent)) switch (node.name) {
+			case "input":
+			case "textarea":
+				values[name] = attributes.value ?? "";
+				break;
+			case "switch":
+				values[name] = checked(attributes, "checked");
+				break;
+			case "slider":
+				values[name] = Number(attributes.value ?? 0);
+				break;
+			case "picker": {
+				const mode = attributes.mode ?? "selector";
+				if (mode === "multiSelector" || mode === "region") {
+					const value = pickerValues.get(node);
+					values[name] = Array.isArray(value) ? value.slice() : [];
+				} else values[name] = mode === "selector" ? Number(attributes.value ?? 0) : attributes.value ?? "";
+				break;
+			}
+			case "radio-group":
+				values[name] = choiceValues(node, pageScope, resolveComponent)[0] ?? "";
+				break;
+			case "checkbox-group": values[name] = choiceValues(node, pageScope, resolveComponent);
+		}
+		for (const child of node.children ?? []) visit(child);
+	};
+	for (const child of form.children ?? []) visit(child);
+	return values;
+}
+/** 先固定提交目标、字段值和方法所有者，再允许 tap 回调改变组件树。 */
+function prepareNativeFormSubmit(button, pageScope, event, resolveMethod, resolveComponent) {
+	const owner = nativeOwner(button);
+	if (owner.target.attribs?.["form-type"] !== "submit" || checked(owner.target.attribs, "disabled")) return;
+	let form = button.parent;
+	while (form && form.name !== "form") form = form.parent;
+	if (!form) return;
+	const formOwner = nativeOwner(form);
+	const scopes = participatingScopes(formOwner.scopeId, pageScope, resolveComponent);
+	if (!participates(owner.scopeId, scopes, "wx://form-field-button", resolveComponent)) return;
+	const binding = resolveMiniProgramEventBinding(formOwner.target.attribs, "submit");
+	return {
+		call: binding?.method ? resolveMethod(formOwner.scopeId, binding.method) : void 0,
+		event: createMiniProgramEventPayload(formOwner.target, "submit", {
+			detail: { value: collectFormValues(form, scopes, pageScope, resolveComponent) },
+			mark: event.mark
+		})
+	};
 }
 //#endregion
 //#region ../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/decode-codepoint.js
@@ -16359,7 +16917,7 @@ const attributeEscapeRegex = /["&\u{A0}]/gu;
 * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
 * @param data String to escape.
 */
-function escapeAttribute$3(data) {
+function escapeAttribute$2(data) {
 	return escapeWithRegex(attributeEscapeRegex, data);
 }
 const textEscapeRegex = /[&<>\u{A0}]/gu;
@@ -16471,7 +17029,7 @@ function replaceQuotes(value) {
 */
 function formatAttributes(attributes, options, xmlMode) {
 	if (!attributes) return "";
-	const encode = (options.encodeEntities ?? options.decodeEntities) === false ? replaceQuotes : xmlMode || options.encodeEntities !== "utf8" ? encodeXML : escapeAttribute$3;
+	const encode = (options.encodeEntities ?? options.decodeEntities) === false ? replaceQuotes : xmlMode || options.encodeEntities !== "utf8" ? encodeXML : escapeAttribute$2;
 	const isForeign = xmlMode === "foreign";
 	const showEmpty = !!(options.emptyAttrs ?? xmlMode);
 	let result = "";
@@ -17086,6 +17644,344 @@ function parseDocument(data, options) {
 	return handler.root;
 }
 //#endregion
+//#region ../../@weapp-core/shared/dist/rich-text.js
+const ALLOWED_TAGS = /* @__PURE__ */ new Set([
+	"a",
+	"abbr",
+	"address",
+	"article",
+	"aside",
+	"b",
+	"bdi",
+	"bdo",
+	"big",
+	"blockquote",
+	"br",
+	"caption",
+	"center",
+	"cite",
+	"code",
+	"col",
+	"colgroup",
+	"dd",
+	"del",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"fieldset",
+	"font",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"i",
+	"img",
+	"ins",
+	"label",
+	"legend",
+	"li",
+	"mark",
+	"ol",
+	"p",
+	"pre",
+	"q",
+	"rt",
+	"ruby",
+	"s",
+	"section",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"tr",
+	"tt",
+	"u",
+	"ul"
+]);
+const ALLOWED_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"abbr",
+	"align",
+	"alt",
+	"axis",
+	"bgcolor",
+	"border",
+	"cellpadding",
+	"cellspacing",
+	"class",
+	"colspan",
+	"dir",
+	"height",
+	"href",
+	"id",
+	"lang",
+	"rowspan",
+	"scope",
+	"span",
+	"start",
+	"style",
+	"summary",
+	"target",
+	"title",
+	"type",
+	"valign",
+	"width"
+]);
+const URL_ATTRIBUTES = /* @__PURE__ */ new Set(["href", "src"]);
+const ALLOWED_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
+	"background",
+	"background-color",
+	"border",
+	"border-bottom",
+	"border-color",
+	"border-left",
+	"border-radius",
+	"border-right",
+	"border-style",
+	"border-top",
+	"border-width",
+	"color",
+	"display",
+	"font-family",
+	"font-size",
+	"font-style",
+	"font-weight",
+	"height",
+	"letter-spacing",
+	"line-height",
+	"margin",
+	"margin-bottom",
+	"margin-left",
+	"margin-right",
+	"margin-top",
+	"max-height",
+	"max-width",
+	"min-height",
+	"min-width",
+	"opacity",
+	"overflow",
+	"padding",
+	"padding-bottom",
+	"padding-left",
+	"padding-right",
+	"padding-top",
+	"text-align",
+	"text-decoration",
+	"text-indent",
+	"text-overflow",
+	"text-transform",
+	"vertical-align",
+	"white-space",
+	"width",
+	"word-break",
+	"word-wrap"
+]);
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isSafeUrl(value, attribute) {
+	const normalized = Array.from(value).filter((character) => character.charCodeAt(0) > 32).join("").toLowerCase();
+	if (!normalized || normalized.startsWith("#") || normalized.startsWith("/") || normalized.startsWith("./") || normalized.startsWith("../")) return true;
+	if (/^(?:https?:|mailto:|tel:)/.test(normalized)) return true;
+	return attribute === "src" && /^data:image\/(?:gif|jpe?g|png|webp);base64,/.test(normalized);
+}
+function isSafeStyleValue(value) {
+	const normalized = value.toLowerCase().replace(/\s+/g, "");
+	return !normalized.includes("url(") && !normalized.includes("expression(") && !normalized.includes("javascript:") && !normalized.includes("behavior:") && !normalized.includes("-moz-binding");
+}
+function sanitizeRichTextStyle(value) {
+	const source = isRecord(value) ? Object.entries(value).map(([property, propertyValue]) => `${property}:${String(propertyValue)}`).join(";") : String(value ?? "");
+	const declarations = [];
+	for (const declaration of source.split(";")) {
+		const separator = declaration.indexOf(":");
+		if (separator <= 0) continue;
+		const property = declaration.slice(0, separator).trim().toLowerCase();
+		const propertyValue = declaration.slice(separator + 1).trim();
+		if (ALLOWED_STYLE_PROPERTIES.has(property) && propertyValue && isSafeStyleValue(propertyValue)) declarations.push(`${property}: ${propertyValue}`);
+	}
+	return declarations.join("; ");
+}
+function sanitizeRichTextAttributes(value, tagName) {
+	if (!isRecord(value)) return {};
+	const attributes = {};
+	for (const [rawName, rawValue] of Object.entries(value)) {
+		const name = rawName.trim().toLowerCase();
+		if (name.startsWith("on") || name === "srcdoc") continue;
+		if (!ALLOWED_ATTRIBUTES.has(name) && name !== "src" && !name.startsWith("aria-") && !name.startsWith("data-")) continue;
+		if (name === "src" && tagName !== "img") continue;
+		const serialized = name === "style" ? sanitizeRichTextStyle(rawValue) : String(rawValue ?? "");
+		if (!serialized || URL_ATTRIBUTES.has(name) && !isSafeUrl(serialized, name)) continue;
+		attributes[name] = serialized;
+	}
+	if (tagName === "a") attributes.rel = "noopener noreferrer";
+	return attributes;
+}
+function convertSourceNode(value) {
+	if (!isRecord(value)) return [];
+	if (value.type === "text" || !value.name && typeof value.text === "string") return [{
+		type: "text",
+		text: String(value.text ?? "")
+	}];
+	const children = Array.isArray(value.children) ? value.children.flatMap(convertSourceNode) : [];
+	const name = String(value.name ?? "").toLowerCase();
+	if (!ALLOWED_TAGS.has(name)) return children;
+	return [{
+		type: "element",
+		name,
+		attrs: sanitizeRichTextAttributes(value.attrs, name),
+		children
+	}];
+}
+function convertParsedNode(node) {
+	if (node.type === "text") return [{
+		type: "text",
+		text: node.data
+	}];
+	if (node.type !== "tag") return [];
+	const element = node;
+	const children = element.children.flatMap(convertParsedNode);
+	const name = element.name.toLowerCase();
+	if (!ALLOWED_TAGS.has(name)) return children;
+	return [{
+		type: "element",
+		name,
+		attrs: sanitizeRichTextAttributes(element.attribs, name),
+		children
+	}];
+}
+function normalizeRichTextNodes(value) {
+	if (typeof value === "string") return parseDocument(value, {
+		decodeEntities: true,
+		lowerCaseAttributeNames: true,
+		lowerCaseTags: true
+	}).children.flatMap(convertParsedNode);
+	return (Array.isArray(value) ? value : [value]).flatMap(convertSourceNode);
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/richText.ts
+function materializeNode(node) {
+	if (node.type === "text") return {
+		type: "text",
+		data: node.text
+	};
+	for (const name of Object.keys(node.attrs)) if (name.startsWith("data-sim-")) delete node.attrs[name];
+	return {
+		type: "tag",
+		name: node.name,
+		attribs: node.attrs,
+		children: node.children.map(materializeNode)
+	};
+}
+/** 富文本直接成为已渲染节点，不能再进入 WXML 表达式或组件处理流程。 */
+function renderRichTextNodes(value) {
+	return normalizeRichTextNodes(value).map(materializeNode);
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/templateIncludes.ts
+/** 展开 include 的可渲染内容，并保留嵌套引用的来源文件。 */
+function expandTemplateIncludes(root, filePath, loadTemplate) {
+	const owners = /* @__PURE__ */ new WeakMap();
+	const expand = (node, owner, stack, included = false) => {
+		if (included && (isTemplateDefinition(node) || node.name === "wxs")) return;
+		owners.set(node, owner);
+		if (node.name === "include" && node.attribs?.src) {
+			const source = node.attribs.src;
+			const loaded = loadTemplate(owner, source.endsWith(".wxml") ? source : `${source}.wxml`);
+			if (stack.includes(loaded.filePath)) throw new Error("Circular WXML include is not supported");
+			const { src: _src, ...attributes } = node.attribs;
+			node.name = "block";
+			node.attribs = attributes;
+			node.children = (loaded.root.children ?? []).flatMap((child) => {
+				const expanded = expand(child, loaded.filePath, [...stack, loaded.filePath], true);
+				return expanded ? [expanded] : [];
+			});
+			return node;
+		}
+		node.children = node.children?.flatMap((child) => {
+			const expanded = expand(child, owner, stack, included);
+			return expanded ? [expanded] : [];
+		});
+		return node;
+	};
+	expand(root, filePath, [filePath]);
+	return owners;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/templateImports.ts
+function createImportedTemplateState(root, filePath, loadImport, loadWxs) {
+	const documents = /* @__PURE__ */ new Map();
+	const definitionScopes = /* @__PURE__ */ new Map();
+	const definitionWxsScopes = /* @__PURE__ */ new Map();
+	const collect = (node, owner) => {
+		const existing = documents.get(owner);
+		if (existing) return existing;
+		const owners = expandTemplateIncludes(node, owner, loadImport);
+		const state = createTemplateRenderState(node);
+		const wxsModules = Object.create(null);
+		const ownDefinitions = new Map(state.definitions);
+		const document = {
+			state,
+			exports: ownDefinitions
+		};
+		documents.set(owner, document);
+		const visit = (child) => {
+			const sourceOwner = owners.get(child) ?? owner;
+			if (child.name === "wxs" && loadWxs) {
+				const name = child.attribs?.module;
+				if (!name || !/^[a-z_$][\w$]*$/i.test(name) || [
+					"__proto__",
+					"constructor",
+					"prototype"
+				].includes(name)) throw new Error(`Invalid WXS module name in ${owner}: ${String(name)}`);
+				if (Object.hasOwn(wxsModules, name)) throw new Error(`Duplicate WXS module in ${owner}: ${name}`);
+				wxsModules[name] = loadWxs(sourceOwner, child);
+				return;
+			}
+			if (child.name === "import" && child.attribs?.src) {
+				const source = child.attribs.src;
+				const imported = loadImport(sourceOwner, source.endsWith(".wxml") ? source : `${source}.wxml`);
+				const importedDocument = collect(imported.root, imported.filePath);
+				for (const [name, definition] of importedDocument.exports) state.definitions.set(name, definition);
+			}
+			for (const nested of child.children ?? []) visit(nested);
+		};
+		visit(node);
+		if (Object.keys(wxsModules).length) state.wxsModules = wxsModules;
+		for (const [name, definition] of ownDefinitions) {
+			state.definitions.set(name, definition);
+			definitionScopes.set(definition, state.definitions);
+			if (state.wxsModules) definitionWxsScopes.set(definition, state.wxsModules);
+		}
+		state.definitionScopes = definitionScopes;
+		state.definitionWxsScopes = definitionWxsScopes;
+		return document;
+	};
+	return collect(root, filePath).state;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/templateText.ts
+function interpolateTemplateText(input, data, emptyNull = false) {
+	let output = "";
+	let offset = 0;
+	for (const range of templateInterpolations(input)) {
+		const value = resolveTemplateExpression(data, range.expression);
+		output += input.slice(offset, range.start) + (value === void 0 || emptyNull && value === null ? "" : String(value));
+		offset = range.end;
+	}
+	return output + input.slice(offset);
+}
+//#endregion
 //#region ../../mpcore/packages/simulator/src/view/templateAttributes.ts
 function decodeAttribute(raw, quote) {
 	const source = raw.replaceAll(`\\${quote}`, quote);
@@ -17140,17 +18036,18 @@ function maskTemplateAttributes(source) {
 const INLINE_WXS_RE = /<wxs\b([^>]*)(?<!\/)>([\s\S]*?)<\/wxs\s*>/g;
 function parseWxsTemplateDocument(templateSource) {
 	const scripts = [];
-	const masked = maskTemplateAttributes(templateSource.replace(INLINE_WXS_RE, (_match, attributes, script) => {
+	const source = templateSource.replace(INLINE_WXS_RE, (_match, attributes, script) => {
 		return `<wxs data-sim-wxs="${scripts.push(script) - 1}"${attributes}>wxs-source</wxs>`;
-	}));
+	});
+	const masked = maskTemplateAttributes(source);
 	const document = parseDocument(`<page>${masked.source}</page>`, {
-		xmlMode: false,
+		xmlMode: true,
 		decodeEntities: false,
 		lowerCaseAttributeNames: false,
 		lowerCaseTags: false,
 		recognizeSelfClosing: true
 	});
-	if (!scripts.length && !masked.attributes.size) return document;
+	if (!scripts.length && !masked.attributes.size && !/[\r\n]/.test(source)) return document;
 	const hasAttributes = masked.attributes.size > 0;
 	const restore = (node) => {
 		if (hasAttributes && node.attribs) {
@@ -17159,7 +18056,9 @@ function parseWxsTemplateDocument(templateSource) {
 		if (node.name === "wxs" && Object.hasOwn(node.attribs ?? {}, "data-sim-wxs")) {
 			node.children[0].data = scripts[Number(node.attribs["data-sim-wxs"])];
 			delete node.attribs["data-sim-wxs"];
+			return;
 		}
+		if (node.children) node.children = node.children.filter((child) => child.type !== "text" || !/^[\t\r\n ]+$/.test(child.data ?? "") || !/[\r\n]/.test(child.data ?? ""));
 		for (const child of node.children ?? []) restore(child);
 	};
 	restore(document);
@@ -17200,7 +18099,7 @@ function collectDataset(node, source) {
 function escapeText$2(text) {
 	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
-function escapeAttribute$2(value) {
+function escapeAttribute$1(value) {
 	return escapeText$2(value).replaceAll("\"", "&quot;");
 }
 function cloneNode(node) {
@@ -17245,7 +18144,7 @@ function serializeDomNode$1(node) {
 	if (node.type === "root") return (node.children ?? []).map(serializeDomNode$1).join("");
 	const tagName = node.name ?? "";
 	if (!tagName) return (node.children ?? []).map(serializeDomNode$1).join("");
-	return `<${tagName}${Object.entries(node.attribs ?? {}).map(([key, value]) => ` ${key}="${escapeAttribute$2(value)}"`).join("")}>${(node.children ?? []).map(serializeDomNode$1).join("")}</${tagName}>`;
+	return `<${tagName}${Object.entries(node.attribs ?? {}).map(([key, value]) => ` ${key}="${escapeAttribute$1(value)}"`).join("")}>${(node.children ?? []).map(serializeDomNode$1).join("")}</${tagName}>`;
 }
 function isTagNode(node) {
 	return node.type === "tag" && typeof node.name === "string";
@@ -17264,7 +18163,7 @@ function resolveComponentAttributeValue(value, scope) {
 	}
 	return interpolateTemplate$1(value, wxsScopeData(scope));
 }
-function applyNodeBindings(node, scope) {
+function applyNodeBindings(node, scope, richText = false) {
 	if (!isTagNode(node)) {
 		if (node.type === "text" && typeof node.data === "string") node.data = interpolateTemplateText(node.data, wxsScopeData(scope));
 		return;
@@ -17272,6 +18171,7 @@ function applyNodeBindings(node, scope) {
 	node.attribs ??= {};
 	node.attribs["data-sim-scope"] = scope.getScopeId();
 	for (const key of STRUCTURAL_ATTRS) delete node.attribs[key];
+	if (richText) node.children = [];
 	let dataset;
 	for (const [key, value] of Object.entries({ ...node.attribs })) {
 		if (EVENT_BINDING_ATTRS.includes(key)) {
@@ -17279,6 +18179,8 @@ function applyNodeBindings(node, scope) {
 			continue;
 		}
 		const resolvedValue = typeof value === "string" ? resolveAttributeValue(value, scope) : value;
+		if (key === "value") setNativePickerValue(node, resolvedValue);
+		if (richText && key === "nodes") node.children = renderRichTextNodes(resolvedValue);
 		node.attribs[key] = String(resolvedValue ?? "");
 		if (isDatasetAttribute(key)) {
 			dataset ??= {};
@@ -17305,8 +18207,7 @@ function createLoopScope(scope, itemName, indexName, item, index) {
 //#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/render/component.ts
 function resolveComponentRegistryEntry(context, ownerJsonPath, ownerFilePath, alias, genericComponentBasePath) {
-	const usingComponents = resolveUsingComponents(context, ownerJsonPath, ownerFilePath);
-	const componentBasePath = genericComponentBasePath ?? usingComponents.get(alias);
+	const componentBasePath = genericComponentBasePath ?? resolveUsingComponent(context, ownerJsonPath, ownerFilePath, alias);
 	if (!componentBasePath) return null;
 	const filePath = `${componentBasePath}.js`;
 	const templatePath = `${componentBasePath}.wxml`;
@@ -17327,30 +18228,25 @@ function readComponentConfig(artifactSource, jsonPath) {
 		return {};
 	}
 }
-function resolveUsingComponents(context, ownerJsonPath, ownerFilePath) {
+function resolveUsingComponent(context, ownerJsonPath, ownerFilePath, alias) {
 	try {
 		const usingComponents = readComponentConfig(context.artifactSource, ownerJsonPath).usingComponents;
-		if (!usingComponents || typeof usingComponents !== "object" || Array.isArray(usingComponents)) return /* @__PURE__ */ new Map();
-		const resolved = /* @__PURE__ */ new Map();
-		for (const [alias, rawPath] of Object.entries(usingComponents)) {
-			if (typeof rawPath !== "string") continue;
-			const basePath = resolvePluginRequest(context.project.plugins, rawPath, "publicComponent")?.resourcePath ?? resolveMiniProgramComponent(ownerFilePath, rawPath, context.project.miniprogramRootPath, (candidate) => context.artifactSource.readText(candidate) !== void 0);
-			resolved.set(alias, basePath.replace(LEADING_SLASH_RE$4, ""));
-		}
-		return resolved;
+		if (!usingComponents || typeof usingComponents !== "object" || Array.isArray(usingComponents)) return;
+		const rawPath = usingComponents[alias];
+		if (typeof rawPath !== "string") return;
+		return (resolvePluginRequest(context.project.plugins, rawPath, "publicComponent")?.resourcePath ?? resolveMiniProgramComponent(ownerFilePath, rawPath, context.project.miniprogramRootPath, (candidate) => context.artifactSource.has(candidate))).replace(LEADING_SLASH_RE$4, "");
 	} catch {
-		return /* @__PURE__ */ new Map();
+		return;
 	}
 }
 function resolveComponentGenerics(context, hostNode, ownerJsonPath, ownerFilePath, componentFilePath, ownerGenerics) {
 	const componentJsonPath = path.resolve(context.project.miniprogramRootPath, `${componentFilePath.replace(JS_FILE_RE, "")}.json`);
 	const componentGenerics = readComponentConfig(context.artifactSource, componentJsonPath).componentGenerics;
 	if (!componentGenerics || typeof componentGenerics !== "object" || Array.isArray(componentGenerics)) return;
-	const ownerComponents = resolveUsingComponents(context, ownerJsonPath, ownerFilePath);
 	const resolved = /* @__PURE__ */ new Map();
 	for (const [genericName, definition] of Object.entries(componentGenerics)) {
 		const selectedAlias = hostNode.attribs?.[`generic:${genericName}`];
-		const selectedPath = selectedAlias ? ownerGenerics?.get(selectedAlias) ?? ownerComponents.get(selectedAlias) : void 0;
+		const selectedPath = selectedAlias ? ownerGenerics?.get(selectedAlias) ?? resolveUsingComponent(context, ownerJsonPath, ownerFilePath, selectedAlias) : void 0;
 		if (selectedPath) {
 			resolved.set(genericName, selectedPath);
 			continue;
@@ -17362,67 +18258,6 @@ function resolveComponentGenerics(context, hostNode, ownerJsonPath, ownerFilePat
 	}
 	return resolved.size > 0 ? resolved : void 0;
 }
-function collectComponentEventBindings(hostNode) {
-	return collectMiniProgramEventBindings(hostNode.attribs);
-}
-function buildComponentTrigger(componentScopeId, context, hostNode) {
-	const hostDataset = collectDataset(hostNode);
-	const hostId = hostNode.attribs?.id ?? "";
-	return (instance, eventName, detail, triggerOptions) => {
-		const originScope = context.componentScopes.get(componentScopeId);
-		const interactionMark = instance.__lastInteractionEvent__?.mark;
-		const target = {
-			dataset: originScope?.dataset ?? hostDataset,
-			id: originScope?.hostId ?? hostId
-		};
-		let currentScopeId = componentScopeId;
-		while (currentScopeId) {
-			const currentScope = context.componentScopes.get(currentScopeId);
-			const binding = currentScope?.eventBindings?.get(eventName);
-			const listenerScope = currentScope?.listenerScopeId ? context.componentScopes.get(currentScope.listenerScopeId) : null;
-			const handler = binding && listenerScope ? listenerScope.getMethod(binding.method) : void 0;
-			if (handler) handler({
-				bubbles: triggerOptions?.bubbles ?? false,
-				capturePhase: false,
-				composed: triggerOptions?.composed ?? false,
-				currentTarget: {
-					dataset: currentScope?.dataset ?? hostDataset,
-					id: currentScope?.hostId ?? hostId
-				},
-				detail,
-				mark: interactionMark,
-				target,
-				type: eventName
-			});
-			if (binding?.stopAfter) break;
-			if (!triggerOptions?.bubbles || !triggerOptions?.composed) break;
-			currentScopeId = currentScope?.ownerScopeId;
-		}
-	};
-}
-function syncComponentProperties(instance, definition, nextProperties, bindingExpressions, changedPageKeys) {
-	const changedRootKeys = [];
-	const previousProperties = {};
-	for (const [key, value] of Object.entries(nextProperties)) {
-		const nextValue = normalizeComponentPropertyValue(definition, key, value);
-		const bindingExpression = bindingExpressions[key];
-		const bindingAffected = !!bindingExpression && changedPageKeys.some((changedKey) => {
-			return changedKey === bindingExpression || changedKey.startsWith(`${bindingExpression}.`) || changedKey.startsWith(`${bindingExpression}[`);
-		});
-		const previousSnapshot = instance.__propertySnapshots?.[key];
-		if (hasComponentPropertyValueChanged(instance.properties[key], previousSnapshot, nextValue, bindingAffected)) {
-			previousProperties[key] = instance.properties[key];
-			const deliveredValue = cloneValue$1(nextValue);
-			instance.properties[key] = deliveredValue;
-			if (Object.hasOwn(definition.properties ?? {}, key)) instance.data[key] = deliveredValue;
-			changedRootKeys.push(key);
-		}
-		instance.__propertySnapshots ??= {};
-		instance.__propertySnapshots[key] = cloneValue$1(nextValue);
-	}
-	if (changedRootKeys.length === 0) return;
-	runComponentObservers(definition, instance, changedRootKeys, previousProperties);
-}
 function createComponentScope(clonedNode, scope, componentScopeId, componentInstance, genericComponents, slots) {
 	const ownerScopeId = scope.getScopeId().includes("/") ? scope.getScopeId() : void 0;
 	return {
@@ -17430,7 +18265,7 @@ function createComponentScope(clonedNode, scope, componentScopeId, componentInst
 		classList: String(clonedNode.attribs?.class ?? "").split(CLASS_SPLIT_RE).map((item) => item.trim()).filter(Boolean),
 		data: { ...componentInstance.data },
 		dataset: collectDataset(clonedNode, wxsScopeData(scope)),
-		eventBindings: collectComponentEventBindings(clonedNode),
+		...bindComponentEventHost(clonedNode),
 		getMethod: (methodName) => {
 			const method = componentInstance?.[methodName];
 			return typeof method === "function" ? method.bind(componentInstance) : void 0;
@@ -17438,6 +18273,7 @@ function createComponentScope(clonedNode, scope, componentScopeId, componentInst
 		getScopeId: () => componentScopeId,
 		genericComponents,
 		hostId: typeof clonedNode.attribs?.id === "string" ? clonedNode.attribs.id : void 0,
+		hostNode: clonedNode,
 		id: typeof clonedNode.attribs?.id === "string" ? clonedNode.attribs.id : void 0,
 		listenerScopeId: scope.getScopeId(),
 		ownerScopeId,
@@ -17460,13 +18296,13 @@ function resolveComponentProperties(clonedNode, scope, definition) {
 		bindingExpressions
 	};
 }
-function createRuntimeComponentInstance(componentScopeId, context, clonedNode, componentEntry, nextProperties, ownerScopeId, beforeCreated) {
-	const componentProperties = Object.keys(componentEntry.definition.methods ?? {}).some((key) => key.startsWith("__weapp_vite_")) || Object.hasOwn(componentEntry.definition.properties ?? {}, "__wvSlotOwnerId") ? Object.fromEntries(Object.keys(componentEntry.definition.properties ?? {}).filter((key) => Object.hasOwn(nextProperties, key)).map((key) => [key, nextProperties[key]])) : nextProperties;
-	const componentInstance = createComponentInstance({
+function createRuntimeComponentInstance(componentScopeId, context, componentEntry, nextProperties, ownerScopeId, renderTemplate, bindEventsBeforeProperties = false) {
+	const instanceOptions = {
 		definition: componentEntry.definition,
-		requestRender: (callback) => context.session.requestRender(callback),
-		triggerEvent: buildComponentTrigger(componentScopeId, context, clonedNode)
-	});
+		requestRender: (callback) => context.session.requestRender(callback)
+	};
+	const componentInstance = createComponentInstance(instanceOptions);
+	bindAttachmentBindingScope(componentInstance, context);
 	setSelectorQueryScopeId(componentInstance, componentScopeId);
 	componentInstance.is = componentEntry.filePath.replace(JS_FILE_RE, "");
 	componentInstance.createIntersectionObserver = (options) => context.session.createIntersectionObserver(componentInstance, options);
@@ -17474,19 +18310,29 @@ function createRuntimeComponentInstance(componentScopeId, context, clonedNode, c
 	componentInstance.createSelectorQuery = () => context.moduleLoader.wx.createSelectorQuery().in(componentInstance);
 	componentInstance.selectComponent = (selector) => resolveNativeComponentSelection(context.session.selectComponentWithin(componentScopeId, selector));
 	componentInstance.selectAllComponents = (selector) => context.session.selectAllComponentsWithin(componentScopeId, selector).map(resolveNativeComponentSelection);
-	componentInstance.selectOwnerComponent = () => ownerScopeId ? context.componentCache.get(ownerScopeId) ?? null : null;
+	componentInstance.selectOwnerComponent = () => ownerScopeId ? resolveNativeComponentSelection(context.componentCache.get(ownerScopeId)) : null;
+	beginComponentConstruction(context.componentCache, componentScopeId, componentInstance);
 	context.componentCache.set(componentScopeId, componentInstance);
-	beforeCreated?.(componentInstance);
-	runComponentLifecycle(componentInstance, "created");
-	componentInstance.__propertySnapshots = Object.fromEntries(Object.entries(componentInstance.properties).map(([key, propertyValue]) => [key, cloneValue$1(propertyValue)]));
-	syncComponentProperties(componentInstance, componentInstance.__definition__ ?? componentEntry.definition, componentProperties, {}, []);
-	return componentInstance;
+	try {
+		renderTemplate?.(componentInstance, "defaults");
+		runComponentLifecycle(componentInstance, "created");
+		if (bindEventsBeforeProperties) instanceOptions.triggerEvent = buildComponentTrigger(componentScopeId, context);
+		componentInstance.__propertySnapshots = Object.fromEntries(Object.entries(componentInstance.properties).map(([key, propertyValue]) => [key, cloneValue$1(propertyValue)]));
+		syncComponentProperties(componentInstance, componentInstance.__definition__ ?? componentEntry.definition, nextProperties, {}, [], renderTemplate);
+		if (!bindEventsBeforeProperties) instanceOptions.triggerEvent = buildComponentTrigger(componentScopeId, context);
+		return componentInstance;
+	} catch (error) {
+		discardComponentConstruction(context.componentCache, context.componentScopes, componentScopeId);
+		throw error;
+	} finally {
+		finishComponentConstruction(context.componentCache, componentInstance);
+	}
 }
-function renderRuntimeComponentTemplate(context, componentEntry, renderNodeTree, componentScope, componentScopeId, seenComponentScopes) {
+function renderRuntimeComponentTemplate(context, componentEntry, renderNodeTree, componentScope, componentScopeId, renderPass) {
 	const componentDocument = parseTemplateDocument(readTemplateSource(context.artifactSource, componentEntry.absoluteTemplatePath));
 	const componentRoot = (componentDocument.children ?? [])[0] ?? componentDocument;
 	const templateRenderState = prepareTemplateRenderState(context.artifactSource, componentRoot, componentEntry.absoluteTemplatePath, context.project.miniprogramRootPath, getRuntimeWxsLoader(context.moduleLoader, context.artifactSource));
-	return renderNodeTree(componentRoot, componentScope, context, path.resolve(context.project.miniprogramRootPath, `${componentEntry.filePath.replace(JS_FILE_RE, "")}.json`), componentEntry.filePath, componentScopeId, seenComponentScopes, templateRenderState);
+	return renderNodeTree(componentRoot, componentScope, context, path.resolve(context.project.miniprogramRootPath, `${componentEntry.filePath.replace(JS_FILE_RE, "")}.json`), componentEntry.filePath, componentScopeId, renderPass, templateRenderState, componentScope.hostNode);
 }
 //#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/render/index.ts
@@ -17500,24 +18346,33 @@ function expandNodeByFor(node, scope) {
 	const items = resolveLoopEntries(resolveRawValueByPath$1(wxsScopeData(scope), forExpression));
 	const itemName = node.attribs?.["wx:for-item"]?.trim() || "item";
 	const indexName = node.attribs?.["wx:for-index"]?.trim() || "index";
+	const key = node.attribs?.["wx:key"]?.trim();
+	const keyOccurrences = key ? /* @__PURE__ */ new Map() : void 0;
 	return items.map(([index, item]) => ({
 		node: cloneNode(node),
 		scope: createLoopScope(scope, itemName, indexName, item, index),
-		instanceSuffix: `:for-${index}`
+		instanceSuffix: resolveLoopInstanceSuffix(item, index, key, keyOccurrences)
 	}));
 }
-function renderNodeVariants(node, scope, context, ownerJsonPath, ownerFilePath, instancePath, seenComponentScopes, templateRenderState) {
-	return expandNodeByFor(node, scope).map(({ node: expandedNode, scope: expandedScope, instanceSuffix }) => renderNodeTree(expandedNode, expandedScope, context, ownerJsonPath, ownerFilePath, `${instancePath}${instanceSuffix}`, seenComponentScopes, templateRenderState));
+function renderNodeVariants(node, scope, context, ownerJsonPath, ownerFilePath, instancePath, renderPass, templateRenderState, parent) {
+	const nodes = [];
+	if (isRenderPassStale(renderPass)) return nodes;
+	for (const { node: expandedNode, scope: expandedScope, instanceSuffix } of expandNodeByFor(node, scope)) {
+		if (isRenderPassStale(renderPass)) break;
+		nodes.push(renderNodeTree(expandedNode, expandedScope, context, ownerJsonPath, ownerFilePath, `${instancePath}${instanceSuffix}`, renderPass, templateRenderState, parent));
+	}
+	return nodes;
 }
-function renderChildren(children, scope, context, ownerJsonPath, ownerFilePath, instancePath, seenComponentScopes, templateRenderState) {
+function renderChildren(children, scope, context, ownerJsonPath, ownerFilePath, instancePath, renderPass, templateRenderState, parent) {
 	const renderedChildren = [];
 	for (const { node: child, index } of selectConditionalChildren(children, (node) => evaluateConditionalBranch(node, scope))) {
+		if (isRenderPassStale(renderPass)) break;
 		if (!isTagNode(child)) {
-			renderedChildren.push(...renderNodeVariants(child, scope, context, ownerJsonPath, ownerFilePath, `${instancePath}/node-${index}`, seenComponentScopes, templateRenderState));
+			renderedChildren.push(...renderNodeVariants(child, scope, context, ownerJsonPath, ownerFilePath, `${instancePath}/node-${index}`, renderPass, templateRenderState, parent));
 			continue;
 		}
 		if (isTemplateDefinition(child) || child.name === "import" || child.name === "wxs") continue;
-		renderedChildren.push(...renderNodeVariants(child, scope, context, ownerJsonPath, ownerFilePath, `${instancePath}/node-${index}`, seenComponentScopes, templateRenderState));
+		renderedChildren.push(...renderNodeVariants(child, scope, context, ownerJsonPath, ownerFilePath, `${instancePath}/node-${index}`, renderPass, templateRenderState, parent));
 	}
 	return renderedChildren;
 }
@@ -17549,22 +18404,38 @@ function collectComponentSlots(componentNode, scope, ownerJsonPath, ownerFilePat
 	}
 	return slots;
 }
-function renderNodeTree(node, scope, context, ownerJsonPath, ownerFilePath, instancePath, seenComponentScopes, templateRenderState) {
+function reconcileSlotDeclarations(context, renderPass) {
+	for (const [entries, { parent, scopeId }] of renderPass.slotDeclarations) {
+		if (isRenderPassStale(renderPass)) return;
+		if (isComponentConstructing(context.componentCache.get(scopeId))) continue;
+		for (const { index } of selectConditionalChildren(entries.map((entry) => entry.node), (node, index) => evaluateConditionalBranch(node, entries[index].scope))) {
+			if (isRenderPassStale(renderPass)) return;
+			const entry = entries[index];
+			if (renderPass.renderedSlots.has(entry)) continue;
+			const nodes = renderNodeVariants(entry.node, entry.scope, context, entry.ownerJsonPath, entry.ownerFilePath, entry.instancePath, renderPass, entry.templateRenderState, parent);
+			renderPass.renderedSlots.set(entry, nodes);
+			renderPass.hasUnprojectedSlots ||= nodes.length > 0;
+		}
+	}
+}
+function renderNodeTree(node, scope, context, ownerJsonPath, ownerFilePath, instancePath, renderPass, templateRenderState, parent) {
+	if (isRenderPassStale(renderPass)) return node;
 	if (scope.wxs !== templateRenderState.wxsModules) scope = {
 		...scope,
 		wxs: templateRenderState.wxsModules
 	};
 	const clonedNode = cloneNode(node);
+	registerComponentEventNode(clonedNode, scope, parent);
 	if (!isTagNode(clonedNode)) {
 		applyNodeBindings(clonedNode, scope);
 		return clonedNode;
 	}
-	if (isTemplateDefinition(clonedNode)) return {
-		type: "tag",
-		name: "block",
-		attribs: {},
-		children: []
-	};
+	if (isTemplateDefinition(clonedNode)) {
+		clonedNode.name = "block";
+		clonedNode.attribs = {};
+		clonedNode.children = [];
+		return clonedNode;
+	}
 	const templateName = resolveTemplateCall(clonedNode, wxsScopeData(scope));
 	if (templateName) {
 		const definition = templateRenderState.definitions.get(templateName);
@@ -17573,39 +18444,42 @@ function renderNodeTree(node, scope, context, ownerJsonPath, ownerFilePath, inst
 			data: resolveTemplateData(clonedNode, wxsScopeData(scope)),
 			wxs: definition && templateRenderState.definitionWxsScopes?.get(definition)
 		};
-		const children = definition && !templateRenderState.stack.includes(templateName) ? renderChildren(definition.children ?? [], templateScope, context, ownerJsonPath, ownerFilePath, `${instancePath}/template-${templateName}`, seenComponentScopes, {
+		clonedNode.name = "block";
+		clonedNode.attribs = {
+			"data-sim-node": instancePath,
+			"data-sim-scope": scope.getScopeId()
+		};
+		clonedNode.children = definition && !templateRenderState.stack.includes(templateName) ? renderChildren(definition.children ?? [], templateScope, context, ownerJsonPath, ownerFilePath, `${instancePath}/template-${templateName}`, renderPass, {
 			definitions: templateRenderState.definitionScopes?.get(definition) ?? templateRenderState.definitions,
 			definitionScopes: templateRenderState.definitionScopes,
 			definitionWxsScopes: templateRenderState.definitionWxsScopes,
 			wxsModules: templateScope.wxs,
 			stack: [...templateRenderState.stack, templateName]
-		}) : [];
-		return {
-			type: "tag",
-			name: "block",
-			attribs: {
-				"data-sim-node": instancePath,
-				"data-sim-scope": scope.getScopeId()
-			},
-			children
-		};
+		}, clonedNode) : [];
+		return clonedNode;
 	}
 	if (clonedNode.name === "slot") {
 		const slotName = clonedNode.attribs?.name?.trim() || "default";
 		const projected = scope.slots?.get(slotName) ?? [];
-		const children = projected.length ? selectConditionalChildren(projected.map((entry) => entry.node), (node, index) => evaluateConditionalBranch(node, projected[index].scope)).flatMap(({ index }) => {
-			const entry = projected[index];
-			return renderNodeVariants(entry.node, entry.scope, context, entry.ownerJsonPath, entry.ownerFilePath, entry.instancePath, seenComponentScopes, entry.templateRenderState);
-		}) : renderChildren(clonedNode.children ?? [], scope, context, ownerJsonPath, ownerFilePath, `${instancePath}/slot-fallback-${slotName}`, seenComponentScopes, templateRenderState);
-		return {
-			type: "tag",
-			name: "block",
-			attribs: {
-				"data-sim-node": instancePath,
-				"data-sim-scope": scope.getScopeId()
-			},
-			children
+		const fallbackChildren = clonedNode.children ?? [];
+		bindComponentEventHost(clonedNode);
+		clonedNode.name = "block";
+		clonedNode.attribs = {
+			"data-sim-node": instancePath,
+			"data-sim-scope": scope.getScopeId()
 		};
+		const slotOwner = scope.getScopeId();
+		if (projected.length && slotOwner && isComponentConstructing(context.componentCache.get(slotOwner))) {
+			clonedNode.children = [];
+			return clonedNode;
+		}
+		clonedNode.children = projected.length ? selectConditionalChildren(projected.map((entry) => entry.node), (node, index) => evaluateConditionalBranch(node, projected[index].scope)).flatMap(({ index }) => {
+			const entry = projected[index];
+			const nodes = renderNodeVariants(entry.node, entry.scope, context, entry.ownerJsonPath, entry.ownerFilePath, entry.instancePath, renderPass, entry.templateRenderState, clonedNode);
+			renderPass.renderedSlots.set(entry, nodes);
+			return nodes;
+		}) : renderChildren(fallbackChildren, scope, context, ownerJsonPath, ownerFilePath, `${instancePath}/slot-fallback-${slotName}`, renderPass, templateRenderState, clonedNode);
+		return clonedNode;
 	}
 	const componentEntry = resolveComponentRegistryEntry(context, ownerJsonPath, ownerFilePath, clonedNode.name, scope.genericComponents?.get(clonedNode.name));
 	if (componentEntry) {
@@ -17614,19 +18488,31 @@ function renderNodeTree(node, scope, context, ownerJsonPath, ownerFilePath, inst
 		const { nextProperties, bindingExpressions } = resolveComponentProperties(clonedNode, scope, componentEntry.definition);
 		const genericComponents = resolveComponentGenerics(context, clonedNode, ownerJsonPath, ownerFilePath, componentEntry.filePath, scope.genericComponents);
 		const slots = collectComponentSlots(clonedNode, scope, ownerJsonPath, ownerFilePath, componentScopeId, templateRenderState);
+		registerSlotDeclarations(renderPass, slots, clonedNode, componentScopeId);
+		applyNodeBindings(clonedNode, scope);
+		const reconcilePrivateTemplate = (instance, phase) => {
+			let bindingPass;
+			do {
+				const bindingScope = createComponentScope(clonedNode, scope, componentScopeId, instance, genericComponents, slots);
+				context.componentScopes.set(componentScopeId, bindingScope);
+				bindingPass = createRenderPass(phase === "properties", renderPass);
+				renderRuntimeComponentTemplate(context, componentEntry, renderNodeTree, bindingScope, componentScopeId, bindingPass);
+				reconcileSlotDeclarations(context, bindingPass);
+			} while (isRenderPassStale(bindingPass));
+		};
 		let componentInstance = context.componentCache.get(componentScopeId);
-		if (!componentInstance) componentInstance = createRuntimeComponentInstance(componentScopeId, context, clonedNode, componentEntry, nextProperties, ownerScopeId, (instance) => {
-			const initialScope = createComponentScope(clonedNode, scope, componentScopeId, instance, genericComponents, slots);
-			context.componentScopes.set(componentScopeId, initialScope);
-			renderRuntimeComponentTemplate(context, componentEntry, renderNodeTree, initialScope, componentScopeId, /* @__PURE__ */ new Set());
-		});
-		else syncComponentProperties(componentInstance, componentInstance.__definition__ ?? componentEntry.definition, nextProperties, bindingExpressions, context.changedPageKeys);
-		seenComponentScopes.add(componentScopeId);
+		if (!componentInstance) componentInstance = createRuntimeComponentInstance(componentScopeId, context, componentEntry, nextProperties, ownerScopeId, reconcilePrivateTemplate, renderPass.propertyUpdate);
+		else {
+			context.componentScopes.set(componentScopeId, createComponentScope(clonedNode, scope, componentScopeId, componentInstance, genericComponents, slots));
+			syncComponentProperties(componentInstance, componentInstance.__definition__ ?? componentEntry.definition, nextProperties, bindingExpressions, context.changedPageKeys, reconcilePrivateTemplate);
+		}
+		if (isRenderPassStale(renderPass)) return clonedNode;
+		renderPass.seenComponentScopes.add(componentScopeId);
 		const componentScope = createComponentScope(clonedNode, scope, componentScopeId, componentInstance, genericComponents, slots);
 		context.componentScopes.set(componentScopeId, componentScope);
-		const renderedComponentRoot = renderRuntimeComponentTemplate(context, componentEntry, renderNodeTree, componentScope, componentScopeId, seenComponentScopes);
+		const renderedComponentRoot = renderRuntimeComponentTemplate(context, componentEntry, renderNodeTree, componentScope, componentScopeId, renderPass);
+		mergeComponentEventRoot(renderedComponentRoot, clonedNode);
 		if (renderedComponentRoot.attribs) {
-			applyNodeBindings(clonedNode, scope);
 			renderedComponentRoot.attribs = {
 				...clonedNode.attribs,
 				...renderedComponentRoot.attribs
@@ -17639,66 +18525,94 @@ function renderNodeTree(node, scope, context, ownerJsonPath, ownerFilePath, inst
 			renderedComponentRoot.attribs["data-sim-node"] = instancePath;
 			renderedComponentRoot.attribs["data-sim-scope"] = componentScopeId;
 		}
+		renderPass.componentRoots.set(componentScopeId, renderedComponentRoot);
 		return renderedComponentRoot;
 	}
-	applyNodeBindings(clonedNode, scope);
+	const richText = clonedNode.name === "rich-text";
+	applyNodeBindings(clonedNode, scope, richText);
 	clonedNode.attribs["data-sim-node"] = instancePath;
-	clonedNode.children = renderChildren(clonedNode.children ?? [], scope, context, ownerJsonPath, ownerFilePath, `${instancePath}/${clonedNode.name}`, seenComponentScopes, templateRenderState);
+	if (richText) return clonedNode;
+	clonedNode.children = renderChildren(clonedNode.children ?? [], scope, context, ownerJsonPath, ownerFilePath, `${instancePath}/${clonedNode.name}`, renderPass, templateRenderState, clonedNode);
 	return clonedNode;
 }
+function reconcileRuntimePageTree(context, page, bindingsOnly = false) {
+	for (;;) {
+		bindAttachmentBindingScope(context, page);
+		if (page.__lastChangedKeys__) context.changedPageKeys = page.__lastChangedKeys__;
+		const route = page.route.replace(LEADING_SLASH_RE$4, "");
+		const resourcePath = context.project.routes.find((item) => item.route === route)?.resourcePath ?? route;
+		const templatePath = path.resolve(context.project.miniprogramRootPath, `${resourcePath}.wxml`);
+		const document = parseTemplateDocument(readTemplateSource(context.artifactSource, templatePath));
+		const pageScopeId = `page:${route}`;
+		const pageScope = {
+			data: page.data,
+			getMethod: (methodName) => {
+				const method = page[methodName];
+				return typeof method === "function" ? method.bind(page) : void 0;
+			},
+			getScopeId: () => pageScopeId,
+			id: "page-root"
+		};
+		for (const scopeId of context.componentScopes.keys()) if (scopeId === pageScopeId || scopeId.startsWith(`${pageScopeId}/`)) context.componentScopes.delete(scopeId);
+		context.componentScopes.set(pageScopeId, pageScope);
+		const renderPass = createPageRenderPass(page, context.componentCache);
+		const root = (document.children ?? [])[0] ?? document;
+		const templateRenderState = prepareTemplateRenderState(context.artifactSource, root, templatePath, context.project.miniprogramRootPath, getRuntimeWxsLoader(context.moduleLoader, context.artifactSource));
+		const renderedRoot = renderNodeTree(root, pageScope, context, path.resolve(context.project.miniprogramRootPath, `${resourcePath}.json`), `${resourcePath}.js`, pageScopeId, renderPass, templateRenderState);
+		const roots = [renderedRoot];
+		if (hasCustomTabBar(context.project.appConfig, route)) roots.push(renderNodeTree({
+			type: "tag",
+			name: "custom-tab-bar",
+			attribs: {},
+			children: []
+		}, customTabBarHostScope(), context, path.resolve(context.project.miniprogramRootPath, "app.json"), "app.js", pageScopeId, renderPass, templateRenderState));
+		reconcileSlotDeclarations(context, renderPass);
+		if (isRenderPassStale(renderPass)) continue;
+		markPageTreeConstructed(page, context.componentCache);
+		const treeRoot = roots.length > 1 ? {
+			type: "root",
+			children: roots
+		} : renderedRoot;
+		linkRenderedParents(treeRoot);
+		registerInspectionTrees(treeRoot, renderPass, context.componentScopes);
+		if (bindingsOnly) return {
+			root: treeRoot,
+			roots
+		};
+		let bindingsRefreshed = false;
+		const updateBindings = () => {
+			bindingsRefreshed = true;
+			if (hasPendingComponentConstruction(context.componentCache)) return;
+			reconcileRuntimePageTree(context, page, true);
+		};
+		const pageAttached = attachComponentPage(page, updateBindings);
+		if (bindingsRefreshed) continue;
+		const pageAttaching = isComponentPageAttaching(page);
+		const scopeIds = orderComponentAttachmentScopes(renderPass.seenComponentScopes, context.componentScopes);
+		const instances = scopeIds.map((scopeId) => context.componentCache.get(scopeId));
+		const attached = !pageAttaching && runWithAttachmentBindingUpdates(page, updateBindings, (scopes) => flushComponentAttachments(context.componentCache, scopes, (instance) => {
+			runComponentLifecycle(instance, "attached");
+			return bindingsRefreshed;
+		}), scopeIds);
+		if (attached === "restart") continue;
+		const canFinalize = !pageAttaching && !hasPendingComponentAttachments(instances);
+		const relationsChanged = canFinalize && reconcileRemovedComponents(context.componentCache, context.componentScopes, renderPass.seenComponentScopes, pageScopeId);
+		if (pageAttached || attached || relationsChanged) continue;
+		if (canFinalize && !isPageBeforeReady(page)) flushDiscardedComponentReady(context.componentCache, pageScopeId, (instance) => runComponentLifecycle(instance, "ready"));
+		if (canFinalize && !isPageBeforeReady(page) && flushComponentReady(instances, (instance) => {
+			runComponentLifecycle(instance, "ready");
+			if (instance !== context.componentCache.get(customTabBarScopeId(route))) instance.__definition__?.pageLifetimes?.show?.call(instance);
+		})) continue;
+		return {
+			root: treeRoot,
+			roots
+		};
+	}
+}
 function renderRuntimePageTree(context, page) {
-	const route = page.route.replace(LEADING_SLASH_RE$4, "");
-	const resourcePath = context.project.routes.find((item) => item.route === route)?.resourcePath ?? route;
-	const templatePath = path.resolve(context.project.miniprogramRootPath, `${resourcePath}.wxml`);
-	const document = parseTemplateDocument(readTemplateSource(context.artifactSource, templatePath));
-	const pageScopeId = `page:${route}`;
-	const pageScope = {
-		data: page.data,
-		getMethod: (methodName) => {
-			const method = page[methodName];
-			return typeof method === "function" ? method.bind(page) : void 0;
-		},
-		getScopeId: () => pageScopeId,
-		id: "page-root"
-	};
-	for (const scopeId of context.componentScopes.keys()) if (scopeId === pageScopeId || scopeId.startsWith(`${pageScopeId}/`)) context.componentScopes.delete(scopeId);
-	context.componentScopes.set(pageScopeId, pageScope);
-	const seenComponentScopes = /* @__PURE__ */ new Set();
-	const root = (document.children ?? [])[0] ?? document;
-	const templateRenderState = prepareTemplateRenderState(context.artifactSource, root, templatePath, context.project.miniprogramRootPath, getRuntimeWxsLoader(context.moduleLoader, context.artifactSource));
-	const renderedRoot = renderNodeTree(root, pageScope, context, path.resolve(context.project.miniprogramRootPath, `${resourcePath}.json`), `${resourcePath}.js`, pageScopeId, seenComponentScopes, templateRenderState);
-	const roots = [renderedRoot];
-	if (hasCustomTabBar(context.project.appConfig, route)) roots.push(renderNodeTree({
-		type: "tag",
-		name: "custom-tab-bar",
-		attribs: {},
-		children: []
-	}, customTabBarHostScope(), context, path.resolve(context.project.miniprogramRootPath, "app.json"), "app.js", pageScopeId, seenComponentScopes, templateRenderState));
-	const pageAttached = attachComponentPage(page);
-	const pageAttaching = isComponentPageAttaching(page);
-	const attached = !pageAttaching && flushComponentAttachments([...seenComponentScopes].map((scopeId) => context.componentCache.get(scopeId)), (instance) => runComponentLifecycle(instance, "attached"));
-	const removed = [...context.componentCache].filter(([scopeId]) => scopeId.startsWith(`${pageScopeId}/`) && !seenComponentScopes.has(scopeId));
-	for (const [scopeId, instance] of removed) if (isComponentAttached(instance)) runComponentLifecycle(instance, "detached");
-	else scheduleDiscardedComponentReady(context.componentCache, scopeId, instance);
-	const instances = [...seenComponentScopes].map((scopeId) => context.componentCache.get(scopeId));
-	const relationsChanged = !pageAttaching && !hasPendingComponentAttachments(instances) && syncComponentRelations(context.componentCache, seenComponentScopes, pageScopeId);
-	for (const [scopeId] of removed) {
-		context.componentCache.delete(scopeId);
-		context.componentScopes.delete(scopeId);
-	}
-	if (pageAttached || attached || relationsChanged) return renderRuntimePageTree(context, page);
-	if (!isPageBeforeReady(page)) flushDiscardedComponentReady(context.componentCache, pageScopeId, (instance) => runComponentLifecycle(instance, "ready"));
-	if (!isPageBeforeReady(page) && flushComponentReady(instances, (instance) => {
-		runComponentLifecycle(instance, "ready");
-		if (instance !== context.componentCache.get(customTabBarScopeId(route))) instance.__definition__?.pageLifetimes?.show?.call(instance);
-	})) return renderRuntimePageTree(context, page);
-	const treeRoot = roots.length > 1 ? {
-		type: "root",
-		children: roots
-	} : renderedRoot;
-	linkRenderedParents(treeRoot);
+	const { root, roots } = reconcileRuntimePageTree(context, page);
 	return {
-		root: treeRoot,
+		root,
 		wxml: roots.map(serializeDomNode$1).join("")
 	};
 }
@@ -17722,15 +18636,23 @@ function createDuplicateRegistrationError(kind, id) {
 function callDefinitionMethod(instance, method, args) {
 	if (typeof method === "function") return method.apply(instance, args);
 }
+function composeDefinitionMethods(primary, secondary) {
+	if (typeof primary !== "function" || typeof secondary !== "function" || primary === secondary) return primary ?? secondary;
+	return function composedDefinitionMethod(...args) {
+		const result = primary.apply(this, args);
+		secondary.apply(this, args);
+		return result;
+	};
+}
 function normalizeComponentPageDefinition(definition) {
 	const { lifetimes = {}, methods = {}, pageLifetimes = {}, ...rest } = definition;
 	const created = lifetimes.created ?? rest.created;
 	const attached = lifetimes.attached ?? rest.attached;
-	const ready = lifetimes.ready ?? rest.ready ?? methods.onReady ?? rest.onReady;
+	const ready = composeDefinitionMethods(lifetimes.ready ?? rest.ready, methods.onReady ?? rest.onReady);
 	const detached = lifetimes.detached ?? rest.detached ?? methods.onUnload ?? rest.onUnload;
 	const load = methods.onLoad ?? rest.onLoad;
-	const show = pageLifetimes.show ?? methods.onShow ?? rest.onShow;
-	const hide = pageLifetimes.hide ?? methods.onHide ?? rest.onHide;
+	const show = typeof pageLifetimes.show === "function" ? composeDefinitionMethods(pageLifetimes.show, methods.onShow) : methods.onShow ?? rest.onShow;
+	const hide = typeof pageLifetimes.hide === "function" ? composeDefinitionMethods(pageLifetimes.hide, methods.onHide) : methods.onHide ?? rest.onHide;
 	const resize = pageLifetimes.resize ?? methods.onResize ?? rest.onResize;
 	const routeDone = pageLifetimes.routeDone ?? methods.onRouteDone ?? rest.onRouteDone;
 	const pageDefinition = {
@@ -17758,10 +18680,7 @@ function normalizeComponentPageDefinition(definition) {
 			return callDefinitionMethod(this, routeDone, args);
 		}
 	};
-	registerComponentPageAttachment(pageDefinition, function() {
-		callDefinitionMethod(this, created, []);
-		callDefinitionMethod(this, attached, []);
-	});
+	registerComponentPageAttachment(pageDefinition, (instance) => callDefinitionMethod(instance, created, []), (instance) => callDefinitionMethod(instance, attached, []));
 	return pageDefinition;
 }
 function createHostRegistries() {
@@ -17952,7 +18871,7 @@ function resolveCapabilityValue(source, schema) {
 	}
 	return current;
 }
-function createHeadlessWx(driver, runtimeConsole = console) {
+function createHeadlessWx(driver, runtimeConsole = console, workers) {
 	const eventBus = createHeadlessUniEventBus();
 	const rpx2px = (value) => {
 		const width = driver.getWindowInfoSync().windowWidth;
@@ -17960,6 +18879,10 @@ function createHeadlessWx(driver, runtimeConsole = console) {
 	};
 	const capabilityTree = {
 		canIUse: true,
+		...workers ? {
+			createWorker: true,
+			preDownloadSubpackage: true
+		} : {},
 		canvasToTempFilePath: true,
 		chooseImage: { return: {
 			errMsg: true,
@@ -18217,6 +19140,14 @@ function createHeadlessWx(driver, runtimeConsole = console) {
 		...eventBus,
 		[WEVU_ROUTE_EVENT_CONTRACT_KEY]: 1,
 		[WEVU_PAGE_SCROLL_EVENT_CONTRACT_KEY]: 1,
+		createWorker: (script) => {
+			if (!workers) throw new Error("Worker host is unavailable");
+			return workers.createWorker(script);
+		},
+		preDownloadSubpackage: (option) => {
+			if (!workers) throw new Error("Worker host is unavailable");
+			workers.preDownloadSubpackage(option);
+		},
 		canIUse: (schema) => typeof schema === "string" && schema.trim() !== "" && resolveCapabilityValue(capabilityTree, schema.trim()) != null,
 		canvasToTempFilePath: (option) => invokeWxApi(() => driver.canvasToTempFilePath(option), option),
 		chooseImage: (option) => invokeWxApi(() => driver.chooseImage(option ?? {}), option),
@@ -18340,9 +19271,7 @@ function createHeadlessWx(driver, runtimeConsole = console) {
 		navigateBack: (option) => runNavigationApi(driver, option, (deferred) => invokeWxApi(() => {
 			driver.navigateBack(deferred);
 		}, deferred)),
-		navigateTo: (option) => runNavigationApi(driver, option, (deferred) => invokeWxApi(() => {
-			driver.navigateTo(deferred);
-		}, deferred)),
+		navigateTo: (option) => runNavigationApi(driver, option, (deferred) => driver.navigateTo(deferred)),
 		nextTick: (callback) => driver.nextTick(callback),
 		offBeforeAppRoute: (listener) => driver.offBeforeAppRoute(listener),
 		offBeforePageUnload: (listener) => driver.offBeforePageUnload(listener),
@@ -18453,7 +19382,13 @@ function invokePreparedNavigationApi(prepare, option) {
 //#region ../../mpcore/packages/simulator/src/kernel/artifactSource.ts
 function createFileSystemArtifactSource() {
 	return {
-		has: (filePath) => fs.existsSync(filePath),
+		has(filePath) {
+			try {
+				return fs.statSync(filePath).isFile();
+			} catch {
+				return false;
+			}
+		},
 		readText(filePath) {
 			try {
 				return fs.readFileSync(filePath, "utf8");
@@ -18598,6 +19533,62 @@ var RuntimeKernel = class {
 	}
 };
 //#endregion
+//#region ../../mpcore/packages/simulator/src/kernel/renderQueue.ts
+/** 两类宿主共享提交、错误诊断与等待回调边界，失败批次不自动重试。 */
+var RuntimeRenderQueue = class {
+	options;
+	closed = false;
+	pending = false;
+	running = false;
+	callbacks = [];
+	constructor(options) {
+		this.options = options;
+	}
+	close() {
+		this.closed = true;
+		this.pending = false;
+		this.callbacks.length = 0;
+	}
+	request(callback) {
+		if (this.isClosed()) return;
+		if (callback) this.callbacks.push(callback);
+		if (this.pending) return;
+		this.pending = true;
+		if (this.running) return;
+		Promise.resolve().then(async () => {
+			if (this.isClosed()) return;
+			this.pending = false;
+			this.running = true;
+			const callbacks = this.callbacks.splice(0);
+			try {
+				const rendered = this.options.render();
+				if (rendered && typeof rendered.then === "function") await rendered;
+			} catch (error) {
+				this.options.onError(error);
+				callbacks.push(...this.callbacks.splice(0));
+				this.pending = false;
+			} finally {
+				for (const callback of callbacks) {
+					if (this.isClosed()) break;
+					try {
+						callback();
+					} catch (error) {
+						this.options.onError(error);
+					}
+				}
+				this.running = false;
+				if (this.pending && !this.isClosed()) {
+					this.pending = false;
+					this.request();
+				}
+			}
+		});
+	}
+	isClosed() {
+		return this.closed || this.options.isClosed();
+	}
+};
+//#endregion
 //#region ../../mpcore/packages/simulator/src/project/resolveRoutes.ts
 const LEADING_SLASH_RE$3 = /^\/+/;
 const TRAILING_SLASH_RE$1 = /\/+$/;
@@ -18798,6 +19789,22 @@ function loadProject(projectPath) {
 	});
 }
 //#endregion
+//#region ../../mpcore/packages/simulator/src/view/nodeSerialization.ts
+function escapeText$1(text) {
+	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function serializeNode(node) {
+	if (node.type === "text") return escapeText$1(node.data ?? "");
+	if (node.type !== "tag") return (node.children ?? []).map(serializeNode).join("");
+	if (node.name === "page") return (node.children ?? []).filter((child) => !(child.type === "tag" && (child.name === "import" || child.name === "wxs"))).map(serializeNode).join("");
+	const attrs = Object.entries(node.attribs ?? {}).filter(([key]) => !key.startsWith("data-sim-")).map(([key, value]) => ` ${key}="${escapeText$1(value).replaceAll("\"", "&quot;")}"`).join("");
+	return `<${node.name ?? ""}${attrs}>${(node.children ?? []).map(serializeNode).join("")}</${node.name ?? ""}>`;
+}
+function collectNodeText$1(node) {
+	if (node.type === "text") return node.data ?? "";
+	return (node.children ?? []).map(collectNodeText$1).join("");
+}
+//#endregion
 //#region ../../node_modules/.pnpm/boolbase@2.0.0/node_modules/boolbase/dist/index.js
 function trueFunc() {
 	return true;
@@ -20224,23 +21231,31 @@ function appendNextSiblings(element, adapter) {
 const selectAll = getSelectorFunction((query, elements, options) => query === falseFunc || !elements || elements.length === 0 ? [] : findAll(query, elements, options));
 //#endregion
 //#region ../../mpcore/packages/simulator/src/view/selectors.ts
-const adapter = {
-	isTag: (node) => node.type === "tag",
-	getAttributeValue: (node, name) => node.attribs?.[name],
-	getChildren: (node) => node.children ?? [],
-	getName: (node) => node.name ?? "",
-	getParent: (node) => node.parent ?? null,
-	getSiblings: (node) => node.parent?.children ?? [node],
-	getText: (node) => node.type === "text" ? node.data ?? "" : (node.children ?? []).map((child) => adapter.getText(child)).join(""),
-	hasAttrib: (node, name) => Object.hasOwn(node.attribs ?? {}, name),
-	removeSubsets: (nodes) => {
-		const unique = new Set(nodes);
-		return [...unique].filter((node) => {
-			for (let parent = node.parent; parent; parent = parent.parent) if (unique.has(parent)) return false;
-			return true;
-		});
-	}
-};
+function createAdapter(getChildren, getParent) {
+	const adapter = {
+		isTag: (node) => node.type === "tag",
+		getAttributeValue: (node, name) => node.attribs?.[name],
+		getChildren,
+		getName: (node) => node.name ?? "",
+		getParent,
+		getSiblings: (node) => {
+			const parent = getParent(node);
+			return parent ? getChildren(parent) : [node];
+		},
+		getText: (node) => node.type === "text" ? node.data ?? "" : getChildren(node).map((child) => adapter.getText(child)).join(""),
+		hasAttrib: (node, name) => Object.hasOwn(node.attribs ?? {}, name),
+		removeSubsets: (nodes) => {
+			const unique = new Set(nodes);
+			return [...unique].filter((node) => {
+				for (let parent = getParent(node); parent; parent = getParent(parent)) if (unique.has(parent)) return false;
+				return true;
+			});
+		}
+	};
+	return adapter;
+}
+const renderedAdapter = createAdapter((node) => node.children ?? [], (node) => node.parent ?? null);
+const inspectionAdapter = createAdapter(getInspectionChildren, getInspectionParent);
 function resolveComponentTags(selectors) {
 	return selectors.map((group) => group.map((token) => {
 		if (token.type === SelectorType.Pseudo && Array.isArray(token.data)) return {
@@ -20263,7 +21278,7 @@ function resolveComponentTags(selectors) {
 		};
 	}));
 }
-function querySelectorAll(root, selector) {
+function queryWithAdapter(root, selector, adapter) {
 	const parsed = parse$1(selector);
 	const query = resolveComponentTags(parsed);
 	const includesPageRoot = root.type === "tag" && root.name === "page" && parsed.some((group) => group.some((token) => token.type === SelectorType.Tag && token.name === "page"));
@@ -20272,12 +21287,18 @@ function querySelectorAll(root, selector) {
 		cacheResults: false
 	});
 }
+function querySelectorAll(root, selector) {
+	return queryWithAdapter(root, selector, renderedAdapter);
+}
+function queryInspectionSelectorAll(root, selector) {
+	return queryWithAdapter(root, selector, inspectionAdapter);
+}
 //#endregion
 //#region ../../node_modules/.pnpm/whynot@5.0.0/node_modules/whynot/dist/whynot.umd.cjs
-var require_whynot_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_whynot_umd = /* @__PURE__ */ __commonJSMin(((exports, module, this$4) => {
 	(function(t, s) {
 		"object" == typeof exports && "undefined" != typeof module ? s(exports) : "function" == typeof define && define.amd ? define(["exports"], s) : s((t = "undefined" != typeof globalThis ? globalThis : t || self).whynot = {});
-	})(exports, (function(t) {
+	})(this$4, (function(t) {
 		"use strict";
 		function s(t, s, i, r) {
 			const n = {
@@ -20625,10 +21646,10 @@ var require_whynot_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 //#endregion
 //#region ../../node_modules/.pnpm/xspattern@3.1.0/node_modules/xspattern/dist/xspattern.umd.cjs
-var require_xspattern_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_xspattern_umd = /* @__PURE__ */ __commonJSMin(((exports, module, this$3) => {
 	(function(A, B) {
 		"object" == typeof exports && "undefined" != typeof module ? B(exports, require_whynot_umd()) : "function" == typeof define && define.amd ? define(["exports", "whynot"], B) : B((A = "undefined" != typeof globalThis ? globalThis : A || self).xspattern = {}, A.whynot);
-	})(exports, (function(A, B) {
+	})(this$3, (function(A, B) {
 		"use strict";
 		function a(A) {
 			return (B) => B === A;
@@ -21925,10 +22946,10 @@ var require_xspattern_umd = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 }));
 //#endregion
 //#region ../../node_modules/.pnpm/prsc@4.0.0/node_modules/prsc/dist/prsc.umd.cjs
-var require_prsc_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_prsc_umd = /* @__PURE__ */ __commonJSMin(((exports, module, this$2) => {
 	(function(n, t) {
 		"object" == typeof exports && "undefined" != typeof module ? t(exports) : "function" == typeof define && define.amd ? define(["exports"], t) : t((n = "undefined" != typeof globalThis ? globalThis : n || self).prsc = {});
-	})(exports, (function(n) {
+	})(this$2, (function(n) {
 		"use strict";
 		function t(n, t) {
 			return {
@@ -22171,12 +23192,12 @@ var require_prsc_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 //#endregion
 //#region ../../mpcore/packages/simulator/src/view/xpath.ts
-var import_fontoxpath = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+var import_fontoxpath = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
 	(function(root, factory) {
 		if (typeof define === "function" && define.amd) define(["xspattern", "prsc"], factory);
 		else if (typeof exports === "object") module.exports = factory(require_xspattern_umd(), require_prsc_umd());
 		else root.fontoxpath = factory(root.xspattern, root.prsc);
-	})(exports, function(xspattern, prsc) {
+	})(this$1, function(xspattern, prsc) {
 		return (function(xspattern, prsc) {
 			const VERSION = "3.34.0";
 			const fontoxpathGlobal = {};
@@ -38019,7 +39040,10 @@ var import_fontoxpath = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin((
 	});
 })))(), 1);
 const xpathEngine = Reflect.get(import_fontoxpath, "default") ?? import_fontoxpath;
-function wrapNode(source, parent = null) {
+function getRenderedChildren(node) {
+	return node.children ?? [];
+}
+function wrapNode(source, getChildren, parent = null) {
 	const node = {
 		attributes: [],
 		children: [],
@@ -38042,7 +39066,7 @@ function wrapNode(source, parent = null) {
 		prefix: null,
 		value
 	}));
-	node.children = (source.children ?? []).map((child) => wrapNode(child, node));
+	node.children = getChildren(source).map((child) => wrapNode(child, getChildren, node));
 	return node;
 }
 function sibling(node, offset) {
@@ -38062,40 +39086,28 @@ const domFacade = {
 	getParentNode: (node) => node.parent,
 	getPreviousSibling: (node) => sibling(node, -1)
 };
-function queryXPathElements(root, expression) {
+function queryElements(root, expression, getChildren) {
 	if (!expression.trim()) throw new Error("XPath must be a non-empty expression in headless testing runtime.");
 	const document = wrapNode(root.type === "root" ? root : {
 		type: "root",
 		children: [root]
-	});
+	}, getChildren);
 	return xpathEngine.evaluateXPathToNodes(expression, document, domFacade).filter((node) => node.nodeType === 1).map((node) => node.source);
 }
+function queryXPathElements(root, expression) {
+	return queryElements(root, expression, getRenderedChildren);
+}
+function queryInspectionXPathElements(root, expression) {
+	return queryElements(root, expression, getInspectionChildren);
+}
 //#endregion
 //#region ../../mpcore/packages/simulator/src/view/nodeHandle.ts
-function escapeText$1(text) {
-	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
 function createValueEventDetail(value, detail) {
 	return {
 		value,
 		...detail ?? {}
 	};
 }
-function escapeAttribute$1(value) {
-	return escapeText$1(value).replaceAll("\"", "&quot;");
-}
-function serializeNode(node) {
-	if (node.type === "text") return escapeText$1(node.data ?? "");
-	if (node.type !== "tag") return (node.children ?? []).map(serializeNode).join("");
-	if (node.name === "page") return (node.children ?? []).filter((child) => !(child.type === "tag" && (child.name === "import" || child.name === "wxs"))).map(serializeNode).join("");
-	const attrs = Object.entries(node.attribs ?? {}).filter(([key]) => !key.startsWith("data-sim-")).map(([key, value]) => ` ${key}="${escapeAttribute$1(value)}"`).join("");
-	const children = (node.children ?? []).map(serializeNode).join("");
-	return `<${node.name ?? ""}${attrs}>${children}</${node.name ?? ""}>`;
-}
-function collectText(node) {
-	if (node.type === "text") return node.data ?? "";
-	return (node.children ?? []).map(collectText).join("");
-}
 function resolvePageScopeId$1(scopeId) {
 	if (!scopeId) return null;
 	const pagePathIndex = scopeId.indexOf("/page/");
@@ -38116,7 +39128,7 @@ var HeadlessTestingNodeHandle = class HeadlessTestingNodeHandle {
 		this.interactions?.assertActive?.();
 	}
 	query(selector) {
-		const nodes = querySelectorAll(this.node, selector);
+		const nodes = (this.interactions?.projectionOnly ? querySelectorAll : queryInspectionSelectorAll)(this.node, selector);
 		const scope = this.node.attribs?.["data-sim-scope"];
 		if (!scope || !this.interactions) return nodes;
 		return nodes.filter((node) => {
@@ -38135,7 +39147,7 @@ var HeadlessTestingNodeHandle = class HeadlessTestingNodeHandle {
 	}
 	async getElementsByXpath(expression) {
 		this.assertActive();
-		return queryXPathElements(this.node, expression).map((node) => new HeadlessTestingNodeHandle(node, this.interactions));
+		return (this.interactions?.projectionOnly ? queryXPathElements : queryInspectionXPathElements)(this.node, expression).map((node) => new HeadlessTestingNodeHandle(node, this.interactions));
 	}
 	async attr(name) {
 		this.assertActive();
@@ -38173,7 +39185,7 @@ var HeadlessTestingNodeHandle = class HeadlessTestingNodeHandle {
 	}
 	async text() {
 		this.assertActive();
-		return collectText(this.node);
+		return collectNodeText$1(this.node);
 	}
 	async tagName() {
 		this.assertActive();
@@ -38185,10 +39197,23 @@ var HeadlessTestingNodeHandle = class HeadlessTestingNodeHandle {
 		const normalizedEventName = eventName.trim();
 		if (!normalizedEventName) throw new Error("Event name must be a non-empty string in headless testing runtime.");
 		let handlerResults;
-		const nativeHandled = this.interactions.dispatchNativeEvent?.(this.node, normalizedEventName, event, normalizedEventName === "tap" ? (result) => {
-			handlerResults ??= [];
-			handlerResults.push(result);
-		} : void 0);
+		let nativeHandled;
+		try {
+			nativeHandled = this.interactions.dispatchNativeEvent?.(this.node, normalizedEventName, event, normalizedEventName === "tap" ? (result) => {
+				handlerResults ??= [];
+				handlerResults.push(result);
+			} : void 0);
+		} catch (error) {
+			let failures;
+			if (handlerResults) {
+				for (const result of await Promise.allSettled(handlerResults)) if (result.status === "rejected") {
+					failures ??= [error];
+					failures.push(result.reason);
+				}
+			}
+			if (failures) throw new AggregateError(failures, "Native interaction handlers failed", { cause: error });
+			throw error;
+		}
 		if (normalizedEventName === "tap" && nativeHandled) return handlerResults ? (await Promise.all(handlerResults))[0] : void 0;
 		const binding = resolveMiniProgramEventBinding(this.node.attribs, normalizedEventName);
 		if (!binding?.method) {
@@ -38200,6 +39225,20 @@ var HeadlessTestingNodeHandle = class HeadlessTestingNodeHandle {
 	async tap(event = {}) {
 		return await this.trigger("tap", event);
 	}
+	async touchstart(event = {}) {
+		return await this.trigger("touchstart", event);
+	}
+	async touchmove(event = {}) {
+		return await this.trigger("touchmove", event);
+	}
+	async touchend(event = {}) {
+		return await this.trigger("touchend", event);
+	}
+	async dispatchEvent({ eventName, $: selector, ...event }) {
+		const target = selector ? await this.$(selector) : this;
+		if (!target) throw new Error(`No node matching "${selector}" was found for dispatchEvent in headless testing runtime.`);
+		return await target.trigger(eventName, event);
+	}
 	async input(value, event = {}) {
 		return await this.trigger("input", {
 			...event,
@@ -38252,16 +39291,20 @@ function isMustacheOnly(value) {
 	return trimmed.startsWith("{{") && trimmed.endsWith("}}") && !trimmed.includes("{{", 2);
 }
 function visitDom(node, visitor) {
-	visitor(node);
+	if (visitor(node) === false) return;
 	for (const child of node.children ?? []) visitDom(child, visitor);
 }
 function interpolateDomTree(root, data) {
 	visitDom(root, (node) => {
+		const richText = node.type === "tag" && node.name === "rich-text";
+		if (richText) node.children = [];
 		if (typeof node.data === "string") node.data = interpolateTemplateText(node.data, data);
 		if (node.attribs) {
 			let dataset;
 			for (const [key, value] of Object.entries(node.attribs)) {
 				const resolvedValue = isMustacheOnly(value) ? resolveRawValueByPath(data, value.trim().slice(2, -2)) : interpolateTemplate(value, data);
+				if (key === "value") setNativePickerValue(node, resolvedValue);
+				if (richText && key === "nodes") node.children = renderRichTextNodes(resolvedValue);
 				node.attribs[key] = String(resolvedValue ?? "");
 				if (isDatasetAttribute(key)) {
 					dataset ??= {};
@@ -38270,6 +39313,7 @@ function interpolateDomTree(root, data) {
 			}
 			node.dataset = dataset;
 		}
+		if (richText) return false;
 	});
 }
 function escapeText(text) {
@@ -38291,11 +39335,12 @@ function renderPageTree(project, page) {
 	const templateSource = project.artifactSource.readText(templatePath);
 	if (templateSource == null) throw new Error(`Missing template in headless runtime: ${templatePath}`);
 	const document = parseDocument(`<page>${templateSource}</page>`, {
-		xmlMode: false,
+		xmlMode: true,
 		decodeEntities: false,
 		recognizeSelfClosing: true
 	});
 	interpolateDomTree(document, page.data);
+	linkRenderedParents(document);
 	return {
 		root: document,
 		wxml: serializeDomNode((document.children ?? [])[0] ?? document)
@@ -38466,7 +39511,7 @@ function getNativeScrollOffset(page, node) {
 	};
 }
 /** 原生交互更新宿主状态，导航仍交给统一 wx 路由入口。 */
-function dispatchNativeNodeEvent(page, node, eventName, event, wx, resolveMethod, onHandlerResult) {
+function dispatchNativeNodeEvent(page, node, eventName, event, wx, resolveMethod, onHandlerResult, resolveComponent) {
 	if (eventName === "scroll" && node.name === "scroll-view") {
 		const detail = event.detail;
 		const state = pageScrollViews.get(page)?.get(nodeKey(node));
@@ -38480,30 +39525,42 @@ function dispatchNativeNodeEvent(page, node, eventName, event, wx, resolveMethod
 	if (eventName !== "tap") return false;
 	let current = node;
 	let navigator;
+	let button;
+	const origin = getNativeNodeOwner(node)?.target ?? node;
 	let handlers;
 	let handled = false;
-	while (current) {
-		if (!navigator && current.name === "navigator") navigator = current;
-		const binding = resolveMiniProgramEventBinding(current.attribs, "tap");
-		if (binding?.method) {
-			const call = resolveMethod(current.attribs?.["data-sim-scope"] ?? null, binding.method);
+	const collectHandler = (scopeId, target, binding) => {
+		if (binding.method) {
+			const call = resolveMethod(scopeId, binding.method);
 			handlers ??= [];
 			handlers.push({
-				node: current,
+				event: createMiniProgramEventPayload(target, "tap", event, origin),
 				call
 			});
 			handled = true;
 		}
-		if (binding?.stopAfter) {
+	};
+	while (current) {
+		if (!navigator && current.name === "navigator") navigator = current;
+		if (!button && current.name === "button") button = current;
+		if (visitNativeNodeEventBindings(current, "tap", collectHandler)) {
 			handled = true;
 			break;
 		}
 		current = current.parent;
 	}
+	const submit = button ? prepareNativeFormSubmit(button, `page:${page.route}`, event, resolveMethod, resolveComponent) : void 0;
 	if (handlers) for (const handler of handlers) {
-		const result = handler.call(createMiniProgramEventPayload(handler.node, "tap", event, node));
+		const result = handler.call(handler.event);
 		onHandlerResult?.(result);
 	}
+	if (submit) {
+		handled = true;
+		if (submit.call) {
+			const result = submit.call(submit.event);
+			onHandlerResult?.(result);
+		}
+	}
 	if (!navigator) return handled;
 	const openType = navigator.attribs?.["open-type"] ?? "navigate";
 	const url = navigator.attribs?.url ?? "";
@@ -39288,6 +40345,64 @@ function createHeadlessMediaQueryObserver(driver, onDisconnect) {
 	};
 }
 //#endregion
+//#region ../../mpcore/packages/simulator/src/view/templateRegistration.ts
+/** 编译模板及递归依赖共用全局注册图，图外原生模板继续实时读取。 */
+function createTemplateRegistration(source, projectRoot, compiledTemplatePaths = []) {
+	const root = normalize(projectRoot);
+	const normalizeTemplatePath = (filePath) => {
+		const normalized = normalize(filePath);
+		const local = relative(root, normalized);
+		if (!normalized.endsWith(".wxml") || isAbsolute(local) || local === ".." || local.startsWith("../")) throw new TypeError("Compiled template paths must stay inside the mini-program root and end in .wxml.");
+		return normalized;
+	};
+	const resolveRelativeTemplatePath = (filePath) => {
+		const local = normalize(filePath);
+		if (isAbsolute(local) || local === ".." || local.startsWith("../")) throw new TypeError("Compiled template paths must stay inside the mini-program root and end in .wxml.");
+		return normalizeTemplatePath(join(root, local));
+	};
+	const entries = [...new Set(compiledTemplatePaths.map((filePath) => {
+		if (typeof filePath !== "string" || !filePath || isAbsolute(filePath)) throw new TypeError("Compiled template paths must be project-relative WXML paths.");
+		return resolveRelativeTemplatePath(filePath);
+	}))];
+	let registered = /* @__PURE__ */ new Map();
+	function readSnapshot() {
+		const snapshot = /* @__PURE__ */ new Map();
+		const collect = (filePath) => {
+			filePath = normalizeTemplatePath(filePath);
+			if (snapshot.has(filePath)) return;
+			const content = source.readText(filePath);
+			if (content === void 0) throw new Error(`Missing compiled template during host registration: ${relative(root, filePath)}`);
+			snapshot.set(filePath, content);
+			const visit = (node) => {
+				const request = node.attribs?.src;
+				if ((node.name === "include" || node.name === "import") && request) {
+					const target = (request.endsWith(".wxml") ? request : `${request}.wxml`).replaceAll("\\", "/");
+					if (isAbsolute(target) && !target.startsWith("/")) throw new TypeError("Compiled template paths must stay inside the mini-program root and end in .wxml.");
+					collect(resolveRelativeTemplatePath(target.startsWith("/") ? target.slice(1) : join(relative(root, dirname(filePath)), target)));
+				}
+				for (const child of node.children ?? []) visit(child);
+			};
+			visit(parseWxsTemplateDocument(content));
+		};
+		for (const filePath of entries) collect(filePath);
+		return snapshot;
+	}
+	function reload() {
+		const snapshot = readSnapshot();
+		const changed = snapshot.size !== registered.size || [...snapshot].some(([filePath, content]) => registered.get(filePath) !== content);
+		registered = snapshot;
+		return changed;
+	}
+	reload();
+	return {
+		artifactSource: {
+			has: (filePath) => registered.has(normalize(filePath)) || source.has(filePath),
+			readText: (filePath) => registered.get(normalize(filePath)) ?? source.readText(filePath)
+		},
+		reload
+	};
+}
+//#endregion
 //#region ../../mpcore/packages/simulator/src/view/videoContext.ts
 function createEventPayload(node, eventName, detail) {
 	const dataset = collectNodeDataset(node);
@@ -39416,6 +40531,490 @@ var HeadlessAppLifecycle = class {
 	}
 };
 //#endregion
+//#region ../../mpcore/packages/simulator/src/runtime/workerHost.ts
+/** 两种 simulator 共用消息与生命周期；每个 worker 独立模块缓存、全局对象及计时器。 */
+function createWorkerHost(options) {
+	const active = /* @__PURE__ */ new Set();
+	let closed = false;
+	const configuredRoot = () => {
+		return JSON.parse(options.read(join(options.root, "app.json")) ?? "{}").workers;
+	};
+	return {
+		apis: {
+			preDownloadSubpackage(option) {
+				const config = configuredRoot();
+				if (option.packageType !== "workers" || typeof config !== "object" || !config.isSubpackage) {
+					const error = /* @__PURE__ */ new Error("preDownloadSubpackage:fail workers subpackage is not configured");
+					option.fail?.(error);
+					option.complete?.();
+					return;
+				}
+				const result = { errMsg: "preDownloadSubpackage:ok" };
+				option.success?.(result);
+				option.complete?.(result);
+			},
+			createWorker(scriptPath) {
+				if (closed) throw new Error("createWorker:fail runtime has closed");
+				const config = configuredRoot();
+				const directory = typeof config === "string" ? config : config?.path;
+				if (!directory || typeof scriptPath !== "string" || !scriptPath.endsWith(".js")) throw new Error("createWorker:fail invalid worker path");
+				const root = normalize(join(options.root, directory));
+				const entry = normalize(join(options.root, scriptPath));
+				const inside = (file) => file.startsWith(`${root}/`);
+				if (!inside(entry) || options.read(entry) === void 0) throw new Error("createWorker:fail worker entry is outside the configured directory or missing");
+				const messages = /* @__PURE__ */ new Set();
+				const incoming = /* @__PURE__ */ new Set();
+				const errors = /* @__PURE__ */ new Set();
+				const cache = /* @__PURE__ */ new Map();
+				let terminated = false;
+				const scheduler = new RuntimeScheduler((error) => {
+					const value = { message: error instanceof Error ? error.message : String(error) };
+					if (errors.size) for (const listener of errors) listener(value);
+					else options.console.error(value.message);
+				});
+				const post = (listeners, message) => {
+					if (terminated) return;
+					const copy = structuredClone(message);
+					scheduler.setTimeout(() => {
+						for (const listener of [...listeners]) {
+							if (terminated) break;
+							listener(copy);
+						}
+					}, 0);
+				};
+				const globals = {
+					wx: void 0,
+					App: void 0,
+					Page: void 0,
+					Component: void 0,
+					getApp: void 0,
+					console: options.console,
+					worker: {
+						onMessage: (listener) => incoming.add(listener),
+						postMessage: (message) => post(messages, message)
+					},
+					setTimeout: scheduler.setTimeout.bind(scheduler),
+					clearTimeout: scheduler.clearTimeout.bind(scheduler),
+					setInterval: scheduler.setInterval.bind(scheduler),
+					clearInterval: scheduler.clearInterval.bind(scheduler)
+				};
+				globals.globalThis = globals;
+				const execute = options.createExecutor(globals);
+				const load = (file) => {
+					if (terminated) return;
+					if (!inside(file)) throw new Error("Worker require cannot leave its configured directory");
+					if (cache.has(file)) return cache.get(file).exports;
+					const source = options.read(file);
+					if (source === void 0) throw new Error(`Missing worker module: ${file}`);
+					if (file.endsWith(".json")) return JSON.parse(source);
+					const module = { exports: {} };
+					cache.set(file, module);
+					const require = Object.assign((request) => {
+						const target = resolveMiniProgramModule(file, request, root, (candidate) => options.read(candidate) !== void 0);
+						if (!target) throw new Error(`Cannot resolve worker module: ${request}`);
+						return load(target);
+					}, { async: (request) => Promise.resolve().then(() => require(request)) });
+					try {
+						execute(source, file, module, require);
+					} catch (error) {
+						cache.delete(file);
+						throw error;
+					}
+					return module.exports;
+				};
+				const worker = {
+					onMessage: (listener) => {
+						messages.add(listener);
+					},
+					offMessage: (listener) => {
+						if (listener) messages.delete(listener);
+						else messages.clear();
+					},
+					postMessage: (message) => post(incoming, message),
+					onError: (listener) => {
+						errors.add(listener);
+					},
+					offError: (listener) => {
+						if (listener) errors.delete(listener);
+						else errors.clear();
+					},
+					terminate() {
+						if (terminated) return;
+						terminated = true;
+						scheduler.close();
+						messages.clear();
+						incoming.clear();
+						errors.clear();
+						cache.clear();
+						active.delete(worker);
+					}
+				};
+				active.add(worker);
+				scheduler.setTimeout(() => load(entry), 0);
+				return worker;
+			}
+		},
+		close() {
+			closed = true;
+			for (const worker of active) worker.terminate();
+		}
+	};
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/runtime/moduleSyntax/ast.ts
+function isSyntaxNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function childNodes(node) {
+	const children = [];
+	for (const [key, value] of Object.entries(node)) for (const child of Array.isArray(value) ? value : [value]) if (isSyntaxNode(child)) children.push({
+		key,
+		node: child
+	});
+	return children;
+}
+function patternIdentifiers(node) {
+	if (node.type === "Identifier") return [node];
+	const keys = node.type === "ObjectPattern" ? ["properties"] : node.type === "ObjectProperty" ? ["value"] : node.type === "AssignmentPattern" ? ["left"] : node.type === "RestElement" ? ["argument"] : ["elements"];
+	return childNodes(node).filter((child) => keys.includes(child.key)).flatMap((child) => patternIdentifiers(child.node));
+}
+function createUniqueName(root) {
+	const used = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (node.type === "Identifier" && typeof node.name === "string") used.add(node.name);
+		childNodes(node).forEach((child) => visit(child.node));
+	};
+	visit(root);
+	let index = 0;
+	return () => {
+		let name;
+		do
+			name = `__mpcoreEsm${index++}`;
+		while (used.has(name));
+		used.add(name);
+		return name;
+	};
+}
+function applySourceEdits(source, edits) {
+	for (const edit of edits.toSorted((left, right) => right.start - left.start || right.end - left.end)) source = source.slice(0, edit.start) + edit.content + source.slice(edit.end);
+	return source;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/runtime/moduleSyntax/bindings.ts
+const functionTypes = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression",
+	"ObjectMethod",
+	"ClassMethod",
+	"ClassPrivateMethod"
+]);
+const blockTypes = /* @__PURE__ */ new Set([
+	"BlockStatement",
+	"CatchClause",
+	"ForStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"SwitchStatement",
+	"StaticBlock"
+]);
+/** 按词法作用域改写导入引用；声明、键名及同名局部变量保持原样。 */
+function rewriteImportReferences(root, imports, bindingName) {
+	const scopes = /* @__PURE__ */ new WeakMap();
+	const declarations = /* @__PURE__ */ new WeakSet();
+	const moduleScope = {
+		bindings: /* @__PURE__ */ new Set(),
+		variable: true,
+		functionDepth: 0
+	};
+	const declare = (pattern, scope) => {
+		if (!isSyntaxNode(pattern)) return;
+		for (const identifier of patternIdentifiers(pattern)) {
+			scope.bindings.add(String(identifier.name));
+			declarations.add(identifier);
+		}
+	};
+	const visit = (node, inherited, parent, key) => {
+		let scope = inherited;
+		if (functionTypes.has(node.type)) {
+			if (node.type === "FunctionDeclaration") declare(node.id, inherited);
+			scope = {
+				parent: inherited,
+				bindings: /* @__PURE__ */ new Set(),
+				variable: false,
+				functionDepth: inherited.functionDepth + 1
+			};
+			declare(node.id, scope);
+			if (Array.isArray(node.params)) node.params.forEach((parameter) => declare(parameter, scope));
+		} else if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+			if (node.type === "ClassDeclaration") declare(node.id, inherited);
+			scope = {
+				parent: inherited,
+				bindings: /* @__PURE__ */ new Set(),
+				variable: false,
+				functionDepth: inherited.functionDepth
+			};
+			declare(node.id, scope);
+		} else if (blockTypes.has(node.type)) {
+			scope = {
+				parent: inherited,
+				bindings: /* @__PURE__ */ new Set(),
+				variable: node.type === "StaticBlock" || key === "body" && !!parent && functionTypes.has(parent.type),
+				functionDepth: inherited.functionDepth
+			};
+			if (node.type === "CatchClause") declare(node.param, scope);
+		}
+		scopes.set(node, scope);
+		if (node.type === "VariableDeclaration") {
+			let owner = scope;
+			while (node.kind === "var" && !owner.variable && owner.parent) owner = owner.parent;
+			for (const child of childNodes(node)) declare(child.node.id, owner);
+		}
+		if (node.type === "ImportDeclaration") {
+			for (const child of childNodes(node)) if (child.key === "specifiers") declare(child.node.local, moduleScope);
+			return;
+		}
+		if (node.type === "ImportExpression" || node.type === "CallExpression" && isSyntaxNode(node.callee) && node.callee.type === "Import") throw new SyntaxError("Dynamic import is not supported by the synchronous mini-program module loader.");
+		if (node.type === "MetaProperty" && isSyntaxNode(node.meta) && node.meta.name === "import") throw new SyntaxError("import.meta is not supported by the synchronous mini-program module loader.");
+		if (scope.functionDepth === 0 && (node.type === "AwaitExpression" || node.type === "ForOfStatement" && node.await)) throw new SyntaxError("Top-level await is not supported by the synchronous mini-program module loader.");
+		if (scope.functionDepth === 0 && node.type === "ReturnStatement") throw new SyntaxError("Top-level return is not valid in a mini-program ES module.");
+		for (const child of childNodes(node)) {
+			const computedMethodKey = functionTypes.has(node.type) && child.key === "key";
+			const switchDiscriminant = node.type === "SwitchStatement" && child.key === "discriminant";
+			visit(child.node, computedMethodKey || switchDiscriminant ? inherited : scope, node, child.key);
+		}
+	};
+	visit(root, moduleScope);
+	const edits = [];
+	const rewrite = (node, parent, key) => {
+		if (node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration" && !node.declaration) return;
+		if (node.type === "Identifier" && !declarations.has(node) && imports.has(String(node.name))) {
+			const property = parent && key === "key" && !parent.computed && [
+				"ObjectProperty",
+				"ObjectMethod",
+				"ClassMethod",
+				"ClassPrivateMethod",
+				"ClassProperty"
+			].includes(parent.type);
+			const member = parent && key === "property" && !parent.computed && ["MemberExpression", "OptionalMemberExpression"].includes(parent.type);
+			const label = key === "label" || parent?.type === "PrivateName" || parent?.type === "MetaProperty";
+			let owner = scopes.get(node);
+			while (owner && !owner.bindings.has(String(node.name))) owner = owner.parent;
+			if (!property && !member && !label && owner === moduleScope) {
+				let content = `${bindingName}[${JSON.stringify(node.name)}]`;
+				if (parent && (key === "callee" && ["CallExpression", "OptionalCallExpression"].includes(parent.type) || key === "tag" && parent.type === "TaggedTemplateExpression")) content = `(0, ${content})`;
+				if (parent?.type === "ObjectProperty" && parent.shorthand && key === "value") content = `${node.name}: ${content}`;
+				edits.push({
+					start: node.start,
+					end: node.end,
+					content
+				});
+			}
+		}
+		childNodes(node).forEach((child) => rewrite(child.node, node, child.key));
+	};
+	rewrite(root);
+	return edits;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/runtime/moduleSyntax/index.ts
+function position(node, edge) {
+	const value = node[edge];
+	if (typeof value !== "number") throw new SyntaxError("Missing source range in mini-program module syntax.");
+	return value;
+}
+function identifierName(node) {
+	return node.type === "Identifier" ? String(node.name) : String(node.value);
+}
+/** 同步转换静态 ESM；CJS 保留原字节，Node 与浏览器共享导入和导出语义。 */
+function transformMiniProgramModule(source) {
+	if (!/\b(?:import|export)\b/.test(source)) return source;
+	const ast = parse$2(source, {
+		sourceType: "unambiguous",
+		allowReturnOutsideFunction: true,
+		tokens: true
+	});
+	const moduleNodes = ast.program.body.filter((node) => [
+		"ImportDeclaration",
+		"ExportNamedDeclaration",
+		"ExportDefaultDeclaration",
+		"ExportAllDeclaration"
+	].includes(node.type));
+	if (moduleNodes.length === 0) return source;
+	const root = ast.program;
+	const fresh = createUniqueName(root);
+	const moduleName = fresh();
+	const requireName = fresh();
+	const objectName = fresh();
+	const bindingsName = fresh();
+	const dependencies = /* @__PURE__ */ new Map();
+	const imports = /* @__PURE__ */ new Map();
+	const exports = /* @__PURE__ */ new Map();
+	const hoistedDefaultNames = [];
+	const starExports = [];
+	const edits = [];
+	const dependency = (request) => {
+		let name = dependencies.get(request);
+		if (!name) {
+			name = fresh();
+			dependencies.set(request, name);
+		}
+		return name;
+	};
+	const remove = (node) => edits.push({
+		start: position(node, "start"),
+		end: position(node, "end"),
+		content: ""
+	});
+	const own = (object, key) => `${objectName}.prototype.hasOwnProperty.call(${object}, ${key})`;
+	for (const node of moduleNodes) {
+		if ("attributes" in node && node.attributes?.length) throw new SyntaxError("Import attributes are not supported by the synchronous mini-program module loader.");
+		if (node.type === "ImportDeclaration") {
+			if (node.phase) throw new SyntaxError("Import phases are not supported by the synchronous mini-program module loader.");
+			const namespace = dependency(node.source.value);
+			for (const specifier of node.specifiers) {
+				const binding = specifier.type === "ImportNamespaceSpecifier" ? namespace : specifier.type === "ImportDefaultSpecifier" ? `${namespace} != null && ${own(namespace, "\"default\"")} ? ${namespace}.default : ${namespace}` : `${namespace}[${JSON.stringify(identifierName(specifier.imported))}]`;
+				imports.set(specifier.local.name, binding);
+			}
+			remove(node);
+		} else if (node.type === "ExportNamedDeclaration") {
+			if (node.declaration) {
+				edits.push({
+					start: position(node, "start"),
+					end: position(node.declaration, "start"),
+					content: ""
+				});
+				const patterns = node.declaration.type === "VariableDeclaration" ? node.declaration.declarations.map((declaration) => declaration.id) : "id" in node.declaration && node.declaration.id ? [node.declaration.id] : [];
+				for (const pattern of patterns) for (const identifier of patternIdentifiers(pattern)) exports.set(String(identifier.name), String(identifier.name));
+			} else {
+				const namespace = node.source ? dependency(node.source.value) : void 0;
+				for (const specifier of node.specifiers) {
+					const exported = identifierName(specifier.exported);
+					if (specifier.type === "ExportNamespaceSpecifier" && namespace) exports.set(exported, namespace);
+					else if (specifier.type === "ExportSpecifier") {
+						const local = identifierName(specifier.local);
+						exports.set(exported, namespace ? `${namespace}[${JSON.stringify(local)}]` : local);
+					} else throw new SyntaxError(`Unsupported mini-program export specifier: ${specifier.type}.`);
+				}
+				remove(node);
+			}
+		} else if (node.type === "ExportAllDeclaration") {
+			starExports.push(dependency(node.source.value));
+			remove(node);
+		} else if (node.type === "ExportDefaultDeclaration") {
+			const declaration = node.declaration;
+			const defaultToken = ast.tokens?.find((token) => token.start > position(node, "start") && token.end <= position(declaration, "start") && token.type.label === "default");
+			if (!defaultToken) throw new SyntaxError("Missing default export token in mini-program module syntax.");
+			if (declaration.type === "FunctionDeclaration" && !declaration.id) {
+				const name = fresh();
+				const keyword = ast.tokens?.find((token) => token.start >= position(declaration, "start") && token.type.label === "function");
+				const nameToken = declaration.generator ? ast.tokens?.find((token) => token.start >= (keyword?.end ?? position(declaration, "start")) && token.type.label === "*") : keyword;
+				if (!nameToken) throw new SyntaxError("Missing default function token in mini-program module syntax.");
+				exports.set("default", name);
+				hoistedDefaultNames.push(name);
+				edits.push({
+					start: position(node, "start"),
+					end: defaultToken.end,
+					content: ""
+				});
+				edits.push({
+					start: nameToken.end,
+					end: nameToken.end,
+					content: ` ${name}`
+				});
+			} else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id) {
+				exports.set("default", declaration.id.name);
+				edits.push({
+					start: position(node, "start"),
+					end: defaultToken.end,
+					content: ""
+				});
+			} else {
+				const name = fresh();
+				exports.set("default", name);
+				edits.push({
+					start: position(node, "start"),
+					end: defaultToken.end,
+					content: `const ${name} = `
+				});
+				edits.push({
+					start: position(node, "end"),
+					end: position(node, "end"),
+					content: ";"
+				});
+			}
+		}
+	}
+	edits.push(...rewriteImportReferences(root, new Set(imports.keys()), bindingsName));
+	const declarations = [
+		dependencies.size ? `let ${[...dependencies.values()].join(", ")};` : "",
+		`const ${bindingsName} = ${objectName}.create(null);`,
+		...[...imports].map(([name, expression]) => `${objectName}.defineProperty(${bindingsName}, ${JSON.stringify(name)}, { get: () => (${expression}) });`),
+		...[...exports].map(([name, expression]) => {
+			const value = imports.has(expression) ? `${bindingsName}[${JSON.stringify(expression)}]` : expression;
+			return `${objectName}.defineProperty(${moduleName}.exports, ${JSON.stringify(name)}, { enumerable: true, get: () => ${value} });`;
+		}),
+		...hoistedDefaultNames.map((name) => `${objectName}.defineProperty(${name}, 'name', { value: 'default', configurable: true });`),
+		...[...dependencies].map(([request, namespace]) => `${namespace} = ${requireName}(${JSON.stringify(request)});`)
+	];
+	if (starExports.length) {
+		const owners = fresh();
+		const namespace = fresh();
+		const key = fresh();
+		declarations.push(`
+      const ${owners} = ${objectName}.create(null);
+      for (const ${namespace} of [${starExports.join(", ")}]) {
+        for (const ${key} of ${objectName}.keys(${namespace})) {
+          if (${key} === 'default' || ${own(`${moduleName}.exports`, key)}) continue;
+          ${owners}[${key}] = ${own(owners, key)} && ${owners}[${key}] !== ${namespace} ? null : ${namespace};
+        }
+      }
+      for (const ${key} of ${objectName}.keys(${owners})) {
+        if (${owners}[${key}] !== null) ${objectName}.defineProperty(${moduleName}.exports, ${key}, { enumerable: true, get: () => ${owners}[${key}][${key}] });
+      }
+    `);
+	}
+	return `(function(${moduleName}, ${requireName}, ${objectName}) {\n"use strict";\n${declarations.join("\n")}\n${applySourceEdits(source, edits)}\n${objectName}.preventExtensions(${moduleName}.exports);\n}).call(undefined, module, require, Object);`;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/runtime/pageDefinitionReload.ts
+/** 定义更新只解析已有路由，不触发普通导航的启动或 page-not-found 生命周期。 */
+function resolvePageDefinitionReloadRoute(project, route) {
+	if (typeof route !== "string" || !route.trim() || /[?#]/.test(route)) throw new TypeError("Page definition reload requires a route path without query or hash.");
+	const normalized = route.trim().replace(/^\/+/, "");
+	const record = project.routes.find((record) => record.route === normalized);
+	if (!record) throw new Error(`Unknown page definition reload route: ${route}`);
+	return record;
+}
+function restoreMap(target, snapshot) {
+	target.clear();
+	for (const [key, value] of snapshot) target.set(key, value);
+}
+/** 仅替换目标 entry；失败恢复缓存和注册表，保留未变依赖的对象身份。 */
+function reloadPageModuleDefinition(options) {
+	const { filePath, route, source, cache, registries } = options;
+	const previous = cache.get(filePath);
+	if (!previous || !registries.pages.has(route)) throw new Error(`Cannot reload a page definition before it is loaded: ${route}`);
+	if (source === void 0) throw new Error(`Missing page script for definition reload: ${route}`);
+	if (source === previous.source) return false;
+	const modules = new Map(cache);
+	const pages = new Map(registries.pages);
+	const components = new Map(registries.components);
+	const app = registries.appDefinition;
+	cache.delete(filePath);
+	registries.pages.delete(route);
+	try {
+		options.execute();
+		return true;
+	} catch (error) {
+		restoreMap(cache, modules);
+		restoreMap(registries.pages, pages);
+		restoreMap(registries.components, components);
+		registries.appDefinition = app;
+		throw error;
+	}
+}
+//#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/runtimeGlobals.ts
 const MINI_PROGRAM_UNAVAILABLE_GLOBAL_NAMES = [
 	"window",
@@ -39459,108 +41058,12 @@ function createMiniProgramRuntimeGlobals(availableGlobals, overrides) {
 }
 //#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/moduleLoader.ts
-const ESM_IMPORT_LINE_RE = /^[ \t]*import[^\n]*$/gm;
-const ESM_EXPORT_LIST_RE = /^[ \t]*export[ \t]*\{([^}\n]+)\}[ \t]*;?$/gm;
-const ESM_EXPORT_DECLARATION_RE = /\bexport\s+(const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g;
-const ESM_EXPORT_DEFAULT_DECLARATION_RE = /\bexport\s+default\s+(function|class)\s+([A-Za-z_$][\w$]*)/g;
-function isImportWhitespace(value) {
-	return value === " " || value === "	";
-}
-function parseEsmImportLine(line) {
-	let statement = line.trim().slice(6).trim();
-	if (statement.endsWith(";")) statement = statement.slice(0, -1).trimEnd();
-	if (statement.startsWith("\"") || statement.startsWith("'")) {
-		const quote = statement[0];
-		if (statement.endsWith(quote) && statement.length > 1) return {
-			request: statement.slice(1, -1),
-			sideEffect: true
-		};
-		return;
-	}
-	let fromIndex = statement.indexOf("from");
-	while (fromIndex >= 0) {
-		if (isImportWhitespace(statement[fromIndex - 1]) && isImportWhitespace(statement[fromIndex + 4])) break;
-		fromIndex = statement.indexOf("from", fromIndex + 4);
-	}
-	if (fromIndex < 0) return;
-	const specifier = statement.slice(0, fromIndex).trim();
-	const requestLiteral = statement.slice(fromIndex + 4).trim();
-	const quote = requestLiteral[0];
-	if (!specifier || quote !== "\"" && quote !== "'" || requestLiteral.length < 2 || !requestLiteral.endsWith(quote)) return;
-	return {
-		request: requestLiteral.slice(1, -1),
-		sideEffect: false,
-		specifier
-	};
-}
-function createEsmImportBindings(specifier, request, index) {
-	const namespaceName = `__headlessEsmImport${index}`;
-	const statements = [`const ${namespaceName} = require(${JSON.stringify(request)});`];
-	const normalizedSpecifier = specifier.trim();
-	if (normalizedSpecifier.startsWith("{") && normalizedSpecifier.endsWith("}")) {
-		const entries = normalizedSpecifier.slice(1, -1).split(",");
-		for (const entry of entries) {
-			const [importedName, localName] = entry.trim().split(/\s+as\s+/);
-			if (!importedName) continue;
-			const bindingName = localName || importedName;
-			statements.push(`const ${bindingName} = ${namespaceName}[${JSON.stringify(importedName)}];`);
-		}
-		return statements.join("\n");
-	}
-	if (normalizedSpecifier.startsWith("* as ")) {
-		const bindingName = normalizedSpecifier.slice(5).trim();
-		statements.push(`const ${bindingName} = ${namespaceName};`);
-		return statements.join("\n");
-	}
-	const [defaultName, namedPart] = normalizedSpecifier.split(/\s*,\s*/, 2);
-	if (defaultName) statements.push(`const ${defaultName.trim()} = ${namespaceName}.default ?? ${namespaceName};`);
-	if (namedPart?.startsWith("{") && namedPart.endsWith("}")) statements.push(createEsmImportBindings(namedPart, request, index).split("\n").slice(1).join("\n"));
-	return statements.join("\n");
-}
-function transformEsmToCommonJs(source) {
-	if (!/^\s*(?:import|export)\b/m.test(source)) return source;
-	let importIndex = 0;
-	const exportedNames = [];
-	let transformed = source.replace(ESM_IMPORT_LINE_RE, (line) => {
-		const parsed = parseEsmImportLine(line);
-		if (!parsed) return line;
-		if (parsed.sideEffect) return `require(${JSON.stringify(parsed.request)});`;
-		return createEsmImportBindings(parsed.specifier, parsed.request, importIndex++);
-	});
-	transformed = transformed.replace(ESM_EXPORT_LIST_RE, (_match, entries) => {
-		for (const entry of entries.split(",")) {
-			const [local, exported] = entry.trim().split(/\s+as\s+/);
-			if (local) exportedNames.push({
-				exported: exported || local,
-				local
-			});
-		}
-		return "";
-	});
-	transformed = transformed.replace(ESM_EXPORT_DEFAULT_DECLARATION_RE, (_match, kind, local) => {
-		exportedNames.push({
-			exported: "default",
-			local
-		});
-		return `${kind} ${local}`;
-	});
-	transformed = transformed.replace(ESM_EXPORT_DECLARATION_RE, (_match, kind, local) => {
-		exportedNames.push({
-			exported: local,
-			local
-		});
-		return `${kind} ${local}`;
-	});
-	transformed = transformed.replace(/\bexport\s+default\s+/g, "module.exports.default = ");
-	if (exportedNames.length > 0) transformed += `\n${exportedNames.map(({ exported, local }) => `module.exports[${JSON.stringify(exported)}] = ${local};`).join("\n")}`;
-	return transformed;
-}
 function createRequireNotFoundError(request, importer) {
 	return /* @__PURE__ */ new Error(`Cannot resolve require("${request}") from ${normalize(importer)} in headless runtime.`);
 }
-function createExecutionContext(registries, getCurrentPages, getApp, wxDriver, kernel, globals, onConsole) {
+function createExecutionContext(registries, getCurrentPages, getApp, wxDriver, kernel, globals, onConsole, workers) {
 	const runtimeConsole = kernel.diagnostics.createConsole(console, onConsole);
-	const wx = createHeadlessWx(wxDriver, runtimeConsole);
+	const wx = createHeadlessWx(wxDriver, runtimeConsole, workers);
 	return createMiniProgramRuntimeGlobals({
 		App(definition) {
 			return registerAppDefinition(registries, definition);
@@ -39593,8 +41096,19 @@ function createExecutionContext(registries, getCurrentPages, getApp, wxDriver, k
 	}, globals);
 }
 function createModuleLoader(registries, getCurrentPages, getApp, wxDriver, options) {
+	const workers = createWorkerHost({
+		root: options.miniprogramRootPath,
+		read: (file) => options.artifactSource.readText(file),
+		console: options.kernel.diagnostics.createConsole(console, options.onConsole),
+		createExecutor(globals) {
+			const realm = vm.createContext(globals);
+			return (source, file, module, require) => {
+				new vm.Script(`(function(module, exports, require) {${source}\n})`, { filename: file }).runInContext(realm)(module, module.exports, require);
+			};
+		}
+	});
 	const moduleCache = /* @__PURE__ */ new Map();
-	const executionContext = createExecutionContext(registries, getCurrentPages, getApp, wxDriver, options.kernel, options.globals ?? {}, options.onConsole);
+	const executionContext = createExecutionContext(registries, getCurrentPages, getApp, wxDriver, options.kernel, options.globals ?? {}, options.onConsole, workers.apis);
 	executionContext.globalThis = executionContext;
 	function executeModule(filePath, loadContext) {
 		const resolvedPath = path.resolve(filePath);
@@ -39603,6 +41117,7 @@ function createModuleLoader(registries, getCurrentPages, getApp, wxDriver, optio
 		const source = options.artifactSource.readText(resolvedPath);
 		if (source == null) throw new TypeError(`Missing module in headless runtime: ${normalize(resolvedPath)}`);
 		const module = {
+			source,
 			componentDefinitions: [],
 			exports: {}
 		};
@@ -39612,7 +41127,7 @@ function createModuleLoader(registries, getCurrentPages, getApp, wxDriver, optio
 		const previousLoadContext = registries.currentLoadContext;
 		registries.currentLoadContext = loadContext;
 		const localRequire = ((request) => {
-			const requiredPath = resolveMiniProgramModule(resolvedPath, request, options.miniprogramRootPath, (candidate) => options.artifactSource.readText(candidate) !== void 0);
+			const requiredPath = resolveMiniProgramModule(resolvedPath, request, options.miniprogramRootPath, (candidate) => options.artifactSource.has(candidate));
 			if (!requiredPath) throw createRequireNotFoundError(request, resolvedPath);
 			if (requiredPath.endsWith(".json")) {
 				const content = options.artifactSource.readText(requiredPath);
@@ -39625,7 +41140,7 @@ function createModuleLoader(registries, getCurrentPages, getApp, wxDriver, optio
 		});
 		localRequire.async = (request) => Promise.resolve().then(() => localRequire(request));
 		try {
-			new vm.Script(`(function (exports, module, require, __filename, __dirname) { ${transformEsmToCommonJs(source)}\n})`, { filename: resolvedPath }).runInNewContext(executionContext)(module.exports, module, localRequire, resolvedPath, path.dirname(resolvedPath));
+			new vm.Script(`(function (exports, module, require, __filename, __dirname) { ${transformMiniProgramModule(source)}\n})`, { filename: resolvedPath }).runInNewContext(executionContext)(module.exports, module, localRequire, resolvedPath, path.dirname(resolvedPath));
 			const registeredDefinitions = [...registries.components.values()].filter((definition) => !registeredDefinitionsBefore.has(definition));
 			module.componentDefinitions = [.../* @__PURE__ */ new Set([
 				...requiredComponentDefinitions,
@@ -39653,6 +41168,7 @@ function createModuleLoader(registries, getCurrentPages, getApp, wxDriver, optio
 			return callback(...args);
 		},
 		close() {
+			workers.close();
 			moduleCache.clear();
 			closeRuntimeWxsLoader(loader);
 		},
@@ -39671,6 +41187,17 @@ function createModuleLoader(registries, getCurrentPages, getApp, wxDriver, optio
 			if (!definition) throw new Error(`Page() was not registered for route "${route}" while executing ${normalize(filePath)}.`);
 			return definition;
 		},
+		reloadPageModule(filePath, route) {
+			const resolvedPath = path.resolve(filePath);
+			return reloadPageModuleDefinition({
+				filePath: resolvedPath,
+				route,
+				source: options.artifactSource.readText(resolvedPath),
+				cache: moduleCache,
+				registries,
+				execute: () => loader.executePageModule(resolvedPath, route)
+			});
+		},
 		executeComponentModule(filePath, id) {
 			const loadedModule = executeModule(filePath, {
 				kind: "component",
@@ -39707,6 +41234,7 @@ var HeadlessRouteEvents = class {
 	nextRouteId = 0;
 	nextWebviewId = 0;
 	activeEvent;
+	activeState;
 	constructor(requestRender, isCurrentPage) {
 		this.requestRender = requestRender;
 		this.isCurrentPage = isCurrentPage;
@@ -39718,6 +41246,7 @@ var HeadlessRouteEvents = class {
 		this.bus.$off(name, listener);
 	}
 	begin(path, query, openType, renderer, page) {
+		this.cancel(this.activeState, /* @__PURE__ */ new Error("navigateTo:fail navigation was superseded"));
 		const previous = page ? this.pages.get(page) : void 0;
 		const event = {
 			path,
@@ -39734,12 +41263,28 @@ var HeadlessRouteEvents = class {
 	}
 	attach(page, event) {
 		const state = this.pages.get(page);
-		this.pages.set(page, {
+		const next = {
 			webviewId: event.webviewId,
 			ready: state?.ready ?? false,
 			event,
-			committed: false
-		});
+			committed: false,
+			completed: false
+		};
+		this.pages.set(page, next);
+		if (this.activeEvent === event) this.activeState = next;
+	}
+	/** 原生 navigateTo 的回调属于本次路由记录，不能以当前页面或提交栈代替完成。 */
+	navigateTo(operation, callbacks) {
+		let state;
+		try {
+			state = this.pages.get(operation());
+		} catch (error) {
+			this.settle(callbacks, error);
+			return;
+		}
+		if (!state || state.canceled) this.settle(callbacks, state?.canceled ?? /* @__PURE__ */ new Error("navigateTo:fail target page was unloaded"));
+		else if (state.completed) this.settle(callbacks);
+		else state.callbacks = callbacks;
 	}
 	commit(page, event) {
 		const state = this.pages.get(page);
@@ -39756,10 +41301,40 @@ var HeadlessRouteEvents = class {
 	}
 	complete(page, state) {
 		this.requestRender(() => {
-			if (this.pages.get(page) !== state || this.activeEvent !== state.event || !this.isCurrentPage(page)) return;
-			this.bus.$emit("appRouteDone", state.event);
+			if (state.completed || state.canceled || this.pages.get(page) !== state || this.activeEvent !== state.event || !this.isCurrentPage(page)) return;
+			state.completed = true;
+			const callbacks = state.callbacks;
+			state.callbacks = void 0;
+			try {
+				const event = state.event;
+				this.bus.$emit("appRouteDone", {
+					path: event.path,
+					query: { ...event.query },
+					openType: event.openType,
+					webviewId: event.webviewId,
+					routeEventId: event.routeEventId,
+					timeStamp: event.timeStamp
+				});
+			} finally {
+				this.settle(callbacks);
+			}
 		});
 	}
+	settle(callbacks, error) {
+		try {
+			if (error) callbacks?.fail?.(error);
+			else callbacks?.success?.();
+		} finally {
+			callbacks?.complete?.();
+		}
+	}
+	cancel(state, error) {
+		if (!state || state.completed || state.canceled) return;
+		state.canceled = error;
+		const callbacks = state.callbacks;
+		state.callbacks = void 0;
+		this.settle(callbacks, error);
+	}
 	beforeUnload(page, event) {
 		const state = this.pages.get(page);
 		if (event && state) this.bus.$emit("beforePageUnload", {
@@ -39770,9 +41345,12 @@ var HeadlessRouteEvents = class {
 			webviewId: state.webviewId,
 			page
 		});
+		this.cancel(state, /* @__PURE__ */ new Error("navigateTo:fail target page was unloaded"));
 		this.pages.delete(page);
 	}
 	close() {
+		this.cancel(this.activeState, /* @__PURE__ */ new Error("navigateTo:fail runtime session closed"));
+		this.activeState = void 0;
 		this.activeEvent = void 0;
 		this.bus.$off();
 	}
@@ -41620,6 +43198,7 @@ var HeadlessSession = class {
 	appInstance = null;
 	appLifecycle = new HeadlessAppLifecycle();
 	moduleLoader;
+	templateRegistration;
 	routeEvents = new HeadlessRouteEvents((callback) => this.requestRender(callback), (page) => this.currentPageInstance === page && !this.kernel.isClosed);
 	eventListeners = /* @__PURE__ */ new Map();
 	registries;
@@ -41628,8 +43207,13 @@ var HeadlessSession = class {
 	componentCache = /* @__PURE__ */ new Map();
 	componentScopes = /* @__PURE__ */ new Map();
 	selectorQueryScopeSnapshots = /* @__PURE__ */ new WeakMap();
-	renderRequestPending = false;
-	renderRequestCallbacks = [];
+	renderQueue = new RuntimeRenderQueue({
+		isClosed: () => this.kernel.isClosed,
+		onError: (error) => this.kernel.diagnostics.record("exception", [error]),
+		render: () => {
+			if (this.currentPageInstance) this.renderCurrentPage();
+		}
+	});
 	tabBarRoutes;
 	tabPages = /* @__PURE__ */ new Map();
 	tabBarItems = /* @__PURE__ */ new Map();
@@ -41648,6 +43232,7 @@ var HeadlessSession = class {
 	constructor(options) {
 		if (!options.project && !options.projectPath) throw new Error("Headless runtime requires projectPath or project.");
 		this.project = options.project ?? loadProject(options.projectPath);
+		this.templateRegistration = createTemplateRegistration(this.project.artifactSource, this.project.miniprogramRootPath, options.compiledTemplatePaths);
 		this.wxState = createHeadlessWxState(this.kernel.scheduler, {
 			strictMocks: options.strictHostMocks,
 			readPackageFile: createPackageAssetReader((relative) => this.project.artifactSource.readText(path.join(this.project.miniprogramRootPath, relative)))
@@ -41701,7 +43286,7 @@ var HeadlessSession = class {
 			getMenuButtonBoundingClientRect: () => deriveMenuButtonBoundingClientRect(this.systemInfo),
 			getNetworkType: () => this.wxState.getNetworkType(),
 			navigateBack: (option) => this.navigateBack(option?.delta),
-			navigateTo: (option) => this.navigateTo(option.url),
+			navigateTo: (option) => this.routeEvents.navigateTo(() => this.navigateTo(option.url), option),
 			pageScrollTo: (option) => this.pageScrollTo(option),
 			openDocument: (option) => this.wxState.openDocument(option),
 			clearStorageSync: () => this.wxState.clearStorageSync(),
@@ -41785,8 +43370,7 @@ var HeadlessSession = class {
 			failure = { error };
 		}
 		this.canvasContexts.clear();
-		this.renderRequestCallbacks.length = 0;
-		this.renderRequestPending = false;
+		this.renderQueue.close();
 		this.appLifecycle.close();
 		this.routeEvents.close();
 		this.wxState.close();
@@ -41836,6 +43420,23 @@ var HeadlessSession = class {
 		this.assertActive();
 		return this.pages.slice();
 	}
+	/** 显式重载已变更的页面 entry，保留 App 与依赖缓存；调用者随后自行导航。 */
+	reloadPageDefinition(route) {
+		this.assertActive();
+		const record = resolvePageDefinitionReloadRoute(this.project, route);
+		const filePath = path.resolve(this.project.miniprogramRootPath, `${record.resourcePath ?? record.route}.js`);
+		return this.moduleLoader.reloadPageModule(filePath, record.route);
+	}
+	/** 显式提交编译模板及其 import/include 依赖；不重载脚本、不导航或替换实例。 */
+	reloadTemplates() {
+		this.assertActive();
+		const changed = this.templateRegistration.reload();
+		if (changed) {
+			closeRuntimeWxsLoader(this.moduleLoader);
+			this.requestRender();
+		}
+		return changed;
+	}
 	getWx() {
 		this.assertActive();
 		return this.moduleLoader.wx;
@@ -41891,7 +43492,7 @@ var HeadlessSession = class {
 		const current = this.requireCurrentPage("renderCurrentPage()");
 		const rendered = renderRuntimePageTree({
 			changedPageKeys: current.__lastChangedKeys__ ?? [],
-			artifactSource: this.project.artifactSource,
+			artifactSource: this.templateRegistration.artifactSource,
 			componentCache: this.componentCache,
 			componentScopes: this.componentScopes,
 			moduleLoader: this.moduleLoader,
@@ -41921,20 +43522,18 @@ var HeadlessSession = class {
 	dispatchNativeNodeEvent(node, eventName, event, onHandlerResult) {
 		const current = this.requireCurrentPage("dispatchNativeNodeEvent()");
 		if (eventName === "tap") this.renderCurrentPage();
-		return dispatchNativeNodeEvent(current, node, eventName, event, this.moduleLoader.wx, (scopeId, method) => this.resolveScopeMethod(current, scopeId, method), onHandlerResult);
+		return dispatchNativeNodeEvent(current, node, eventName, event, this.moduleLoader.wx, (scopeId, method) => this.resolveScopeMethod(current, scopeId, method), onHandlerResult, (scopeId) => {
+			const instance = this.componentCache.get(scopeId);
+			const scope = this.componentScopes.get(scopeId);
+			return instance?.__definition__ && scope ? {
+				definition: instance.__definition__,
+				ownerScopeId: scope.ownerScopeId ?? null
+			} : void 0;
+		});
 	}
 	requestRender(callback) {
 		this.assertActive();
-		if (callback) this.renderRequestCallbacks.push(callback);
-		if (this.renderRequestPending) return;
-		this.renderRequestPending = true;
-		Promise.resolve().then(() => {
-			if (this.kernel.isClosed) return;
-			this.renderRequestPending = false;
-			const callbacks = this.renderRequestCallbacks.splice(0);
-			if (this.currentPageInstance) this.renderCurrentPage();
-			callbacks.forEach((cb) => cb());
-		});
+		this.renderQueue.request(callback);
 	}
 	getScopeSnapshot(scopeId) {
 		const scope = this.componentScopes.get(scopeId);
@@ -42016,19 +43615,19 @@ var HeadlessSession = class {
 		return this.wxState.getShareMenu();
 	}
 	selectComponent(selector) {
-		this.renderCurrentPage();
+		if (!hasPendingComponentConstruction(this.componentCache)) this.renderCurrentPage();
 		return this.selectComponentsWithin(null, selector)[0] ?? null;
 	}
 	selectAllComponents(selector) {
-		this.renderCurrentPage();
+		if (!hasPendingComponentConstruction(this.componentCache)) this.renderCurrentPage();
 		return this.selectComponentsWithin(null, selector);
 	}
 	selectComponentWithin(scopeId, selector) {
-		this.renderCurrentPage();
+		if (!hasPendingComponentConstruction(this.componentCache)) this.renderCurrentPage();
 		return this.selectComponentsWithin(scopeId, selector)[0] ?? null;
 	}
 	selectAllComponentsWithin(scopeId, selector) {
-		this.renderCurrentPage();
+		if (!hasPendingComponentConstruction(this.componentCache)) this.renderCurrentPage();
 		return this.selectComponentsWithin(scopeId, selector);
 	}
 	selectOwnerComponent(scopeId) {
@@ -42768,6 +44367,7 @@ function createPageRootNodeHandle(options) {
 	const tree = session?.getCurrentPages().includes(page) ? session.renderCurrentPage() : renderPageTree(project, page);
 	return new HeadlessTestingNodeHandle(tree.root.type === "root" && !options.includeHostRoots ? tree.root.children?.[0] ?? tree.root : tree.root, {
 		assertActive: options.assertActive,
+		projectionOnly: options.projectionOnly,
 		dispatchNativeEvent: (node, eventName, event, onHandlerResult) => session?.getCurrentPages().at(-1) === page ? session.dispatchNativeNodeEvent(node, eventName, event, onHandlerResult) : false,
 		callMethod: (scopeId, methodName, event) => {
 			if (session?.getCurrentPages().includes(page)) return session.callScopeMethod(scopeId, methodName, event);
@@ -43130,7 +44730,18 @@ var HeadlessTestingPageHandle = class {
 	renderedAccess() {
 		return {
 			assertActive: () => this.assertActive(),
-			findAll: async (selector) => await this.$$(selector),
+			findAll: async (selector) => {
+				this.assertActive();
+				const root = createPageRootNodeHandle({
+					assertActive: () => this.assertActive(),
+					createPageHandle: () => this,
+					page: this.page,
+					project: this.project,
+					projectionOnly: true,
+					session: this.session
+				});
+				return selector === "page" ? [root] : await root.$$(selector);
+			},
 			waitFor: async (ms) => await this.waitFor(ms),
 			wxml: async () => await this.wxml()
 		};
@@ -43147,6 +44758,133 @@ var HeadlessTestingPageHandle = class {
 	}
 };
 //#endregion
+//#region ../../mpcore/packages/simulator/src/testing/sessionHandle/protocol.ts
+/** 无头协议只公布已有运行时语义；不把宿主缺失能力伪装为调试器结果。 */
+var HeadlessTestingProtocolUnsupportedError = class extends Error {
+	method;
+	code = HEADLESS_PROTOCOL_UNSUPPORTED;
+	constructor(method) {
+		super(`Protocol method ${method} is not supported by the headless testing runtime.`);
+		this.method = method;
+		this.name = "HeadlessTestingProtocolUnsupportedError";
+	}
+};
+function requireString(params, name) {
+	const value = params[name];
+	if (typeof value !== "string" || !value.trim()) throw new TypeError(`Protocol parameter ${name} must be a non-empty string.`);
+	return value;
+}
+function readArgs(params) {
+	if (params.args === void 0) return [];
+	if (!Array.isArray(params.args)) throw new TypeError("Protocol parameter args must be an array.");
+	return cloneProtocolValue(params.args);
+}
+function pageSnapshot(page) {
+	return {
+		pageId: page.pageId,
+		path: page.path,
+		query: page.query
+	};
+}
+async function dispatch(target, method, params) {
+	switch (method) {
+		case "Tool.getInfo": return await target.toolInfo();
+		case "App.getCurrentPage": {
+			const page = await target.currentPage();
+			return page ? pageSnapshot(page) : null;
+		}
+		case "App.getPageStack": return { pageStack: (await target.getCurrentPages()).map(pageSnapshot) };
+		case "App.callFunction": return { result: cloneProtocolValue(await target.evaluateWithOptions(requireString(params, "functionDeclaration"), {}, ...readArgs(params))) };
+		case "App.callWxMethod": return { result: cloneProtocolValue(await target.callWxMethodWithOptions(requireString(params, "method"), {}, ...readArgs(params))) };
+		default: throw new HeadlessTestingProtocolUnsupportedError(method);
+	}
+}
+async function sendHeadlessTestingProtocol(target, method, params, options) {
+	let rejectClosed;
+	const closed = new Promise((_resolve, reject) => {
+		rejectClosed = reject;
+	});
+	const onClose = () => rejectClosed(/* @__PURE__ */ new Error(`The headless testing session closed before protocol method ${method} completed.`));
+	target.on("close", onClose);
+	try {
+		return await runWithTimeout(() => Promise.race([dispatch(target, method, params), closed]), options.timeout, `Timed out executing protocol method ${method} in headless testing runtime.`);
+	} finally {
+		target.off("close", onClose);
+	}
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/testing/sessionHandle/cdp.ts
+/** 保留官方调用形状；当前后端的 enable 会明确报告不支持。 */
+function createHeadlessTestingCDP(target, assertActive) {
+	let enabling;
+	const enable = (options) => {
+		enabling ??= target.send("App.CDPEnable", {}, options).catch((error) => {
+			enabling = void 0;
+			throw error;
+		});
+		return enabling;
+	};
+	return {
+		enable,
+		async sendCommand(domain, method, params = {}, options) {
+			await enable(options);
+			return await target.send("App.CDPCommand", {
+				domain,
+				method,
+				params
+			}, options);
+		},
+		async listProtocol(options) {
+			await enable(options);
+			return await target.send("App.CDPListProtocol", {}, options);
+		},
+		onEvent() {
+			assertActive();
+			throw new HeadlessTestingProtocolUnsupportedError("App.CDPEvent");
+		}
+	};
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/testing/sessionHandle/navigation.ts
+/** 所有测试句柄通过同一个 wx 导航边界等待成功、失败或关闭通知。 */
+var HeadlessTestingNavigation = class {
+	session;
+	pending = /* @__PURE__ */ new Set();
+	constructor(session) {
+		this.session = session;
+		session.on("close", () => {
+			for (const reject of this.pending) reject(/* @__PURE__ */ new Error("The headless testing session closed before navigation completed."));
+			this.pending.clear();
+		});
+	}
+	invoke(methodName, options) {
+		return new Promise((resolve, reject) => {
+			const rejectNavigation = (error) => {
+				this.pending.delete(rejectNavigation);
+				reject(error);
+			};
+			this.pending.add(rejectNavigation);
+			try {
+				this.session.callWxMethod(methodName, {
+					...options,
+					success: () => {
+						this.pending.delete(rejectNavigation);
+						resolve();
+					},
+					fail: (error) => {
+						const details = error && typeof error === "object" ? error : void 0;
+						const reason = typeof details?.errMsg === "string" ? details.errMsg : typeof details?.message === "string" ? details.message : String(error);
+						const target = options.url ? ` route "${options.url}"` : "";
+						rejectNavigation(new Error(`Failed to ${methodName}${target} through the headless wx runtime: ${reason}`, { cause: error }));
+					}
+				});
+			} catch (error) {
+				rejectNavigation(error);
+			}
+		});
+	}
+};
+//#endregion
 //#region ../../mpcore/packages/simulator/src/testing/sessionHandle/scope.ts
 var HeadlessTestingScopeHandle = class HeadlessTestingScopeHandle {
 	scopeId;
@@ -43208,16 +44946,41 @@ var HeadlessTestingScopeHandle = class HeadlessTestingScopeHandle {
 var HeadlessTestingSessionHandle = class {
 	project;
 	session;
-	pendingNavigations = /* @__PURE__ */ new Set();
+	navigation;
+	disconnection;
+	cdp;
 	constructor(project, session) {
 		this.project = project;
 		this.session = session;
-		this.session.on("close", () => {
-			for (const reject of this.pendingNavigations) reject(/* @__PURE__ */ new Error("The headless testing session closed before navigation completed."));
-		});
+		this.navigation = new HeadlessTestingNavigation(session);
 	}
-	async close() {
-		this.session.close();
+	close() {
+		return this.disconnect();
+	}
+	/** 先保存共享结果，再同步开始关闭，覆盖关闭监听器内的重入调用。 */
+	disconnect() {
+		if (!this.disconnection) {
+			let resolve;
+			let reject;
+			this.disconnection = new Promise((accept, fail) => {
+				resolve = accept;
+				reject = fail;
+			});
+			try {
+				this.session.close();
+				resolve();
+			} catch (error) {
+				reject(error);
+			}
+		}
+		return this.disconnection;
+	}
+	async send(method, params = {}, options = {}) {
+		this.session.assertActive();
+		return await sendHeadlessTestingProtocol(this, method, params, options);
+	}
+	CDP() {
+		return this.cdp ??= createHeadlessTestingCDP(this, () => this.session.assertActive());
 	}
 	async toolInfo() {
 		return { version: "mpcore-simulator" };
@@ -43256,6 +45019,10 @@ var HeadlessTestingSessionHandle = class {
 		const normalizedMethodName = normalizeNonEmptyInput(methodName, "wx method name");
 		return await runWithTimeout(() => this.session.callWxMethod(normalizedMethodName, ...args), options.timeout, `Timed out calling wx.${normalizedMethodName} in headless testing runtime.`);
 	}
+	/** 返回与 DevTools automator 兼容的运行时系统信息。 */
+	async systemInfo() {
+		return await this.callWxMethod("getSystemInfoSync");
+	}
 	async scopeSnapshot(scopeId) {
 		const normalizedScopeId = normalizeNonEmptyInput(scopeId, "Scope id");
 		return this.session.getScopeSnapshot(normalizedScopeId);
@@ -43283,23 +45050,31 @@ var HeadlessTestingSessionHandle = class {
 		}, `Timed out waiting for ${normalizedCount} component(s) matching "${normalizedSelector}" in headless testing runtime.`, options);
 	}
 	async reLaunch(route) {
-		await this.invokeNavigation("reLaunch", { url: route });
+		await this.navigation.invoke("reLaunch", { url: route });
 		return await this.requireCurrentPage("reLaunch", route);
 	}
+	/** 只更新页面定义；不隐式导航，也不替换当前页面或应用实例。 */
+	async reloadPageDefinition(route) {
+		return this.session.reloadPageDefinition(route);
+	}
+	/** 显式提交宿主编译模板；不隐式重载脚本或导航。 */
+	async reloadTemplates() {
+		return this.session.reloadTemplates();
+	}
 	async navigateTo(route) {
-		await this.invokeNavigation("navigateTo", { url: route });
+		await this.navigation.invoke("navigateTo", { url: route });
 		return await this.requireCurrentPage("navigateTo", route);
 	}
 	async redirectTo(route) {
-		await this.invokeNavigation("redirectTo", { url: route });
+		await this.navigation.invoke("redirectTo", { url: route });
 		return await this.requireCurrentPage("redirectTo", route);
 	}
 	async navigateBack(delta = 1) {
-		await this.invokeNavigation("navigateBack", { delta });
+		await this.navigation.invoke("navigateBack", { delta });
 		return await this.currentPage();
 	}
 	async switchTab(route) {
-		await this.invokeNavigation("switchTab", { url: route });
+		await this.navigation.invoke("switchTab", { url: route });
 		return await this.requireCurrentPage("switchTab", route);
 	}
 	async waitForCurrentPage(route, options = {}) {
@@ -43335,32 +45110,6 @@ var HeadlessTestingSessionHandle = class {
 	async triggerRouteDone(options) {
 		this.session.triggerRouteDone(options);
 	}
-	invokeNavigation(methodName, options) {
-		return new Promise((resolve, reject) => {
-			const rejectNavigation = (error) => {
-				this.pendingNavigations.delete(rejectNavigation);
-				reject(error);
-			};
-			this.pendingNavigations.add(rejectNavigation);
-			try {
-				this.session.callWxMethod(methodName, {
-					...options,
-					success: () => {
-						this.pendingNavigations.delete(rejectNavigation);
-						resolve();
-					},
-					fail: (error) => {
-						const details = error && typeof error === "object" ? error : void 0;
-						const reason = typeof details?.errMsg === "string" ? details.errMsg : typeof details?.message === "string" ? details.message : String(error);
-						const target = options.url ? ` route "${options.url}"` : "";
-						rejectNavigation(new Error(`Failed to ${methodName}${target} through the headless wx runtime: ${reason}`, { cause: error }));
-					}
-				});
-			} catch (error) {
-				rejectNavigation(error);
-			}
-		});
-	}
 	async requireCurrentPage(methodName, route) {
 		const page = await this.currentPage();
 		if (!page) throw new Error(`Failed to ${methodName} route "${route}" through the headless wx runtime.`);
@@ -43379,7 +45128,10 @@ function resolveInitialRoute(session) {
 	return session.project.routes[0]?.route ?? null;
 }
 async function launch(options) {
-	const session = createHeadlessSession({ projectPath: options.projectPath });
+	const session = createHeadlessSession({
+		compiledTemplatePaths: options.compiledTemplatePaths,
+		projectPath: options.projectPath
+	});
 	const handle = new HeadlessTestingSessionHandle(session.project, session);
 	try {
 		await options.onSessionCreated?.(handle);