@vue/runtime-core 3.6.0-rc.13 → 3.6.0-rc.15

package/dist/runtime-core.cjs.js

@@ -1,5 +1,5 @@
 /**
-  * @vue/runtime-core v3.6.0-rc.13
+  * @vue/runtime-core v3.6.0-rc.15
   * (c) 2018-present Yuxi (Evan) You and Vue contributors
   * @license MIT
   **/
@@ -201,7 +201,7 @@ function callWithAsyncErrorHandling(fn, instance, type, args) {
 	if ((0, _vue_shared.isFunction)(fn)) {
 		const res = callWithErrorHandling(fn, instance, type, args);
 		if (res && (0, _vue_shared.isPromise)(res)) res.catch((err) => {
-			handleError(err, instance, type);
+			handleError(err, instance, type, void 0, true);
 		});
 		return res;
 	}
@@ -211,7 +211,7 @@ function callWithAsyncErrorHandling(fn, instance, type, args) {
 		return values;
 	} else warn$1(`Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`);
 }
-function handleError(err, instance, type, throwInDev = true) {
+function handleError(err, instance, type, throwInDev = true, isAsyncError = false) {
 	const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || _vue_shared.EMPTY_OBJ;
 	if (instance) {
 		let cur = instance.parent;
@@ -219,7 +219,7 @@ function handleError(err, instance, type, throwInDev = true) {
 		const errorInfo = ErrorTypeStrings$1[type];
 		while (cur) {
 			const errorCapturedHooks = cur.ec;
-			if (errorCapturedHooks) {
+			if (errorCapturedHooks && !cur.isUnmounted && (!isAsyncError || cur.scope.active)) {
 				for (let i = 0; i < errorCapturedHooks.length; i++) if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) return;
 			}
 			cur = cur.parent;
@@ -524,7 +524,11 @@ function reload(id, newComp) {
 	updateComponentDef(record.initialDef, newComp);
 	const instances = [...record.instances];
 	if (isVapor && newComp.__vapor && !instances.some((instance) => instance.parent && !instance.parent.vapor) && !instances.some((i) => i.ceReload)) {
-		for (const instance of instances) if (instance.root && instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(instance.type);
+		for (const instance of instances) {
+			if (instance.root && instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(instance.type);
+			const oldComp = normalizeClassComponent(instance.type);
+			if (oldComp !== record.initialDef) updateComponentDef(oldComp, newComp);
+		}
 		const dirtyInstances = new Set(instances);
 		const rerenderedParents = /* @__PURE__ */ new Set();
 		runWithHmrUpdating(() => {
@@ -565,7 +569,25 @@ function reload(id, newComp) {
 			if (instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(oldComp);
 		}
 		parents.forEach((parent) => {
-			queueJob(() => {
+			const children = instances.filter((instance) => instance.parent === parent);
+			const update = () => {
+				if (!parent.scope.active) return;
+				const activeChildren = children.filter((instance) => instance.scope.active);
+				if (!activeChildren.length) return;
+				const pending = activeChildren.find((instance) => instance.asyncDep && !instance.asyncResolved) || locateUnresolvedAsyncRoot(parent);
+				if (pending) {
+					pending.asyncDep.catch(_vue_shared.NOOP).then(() => {
+						if (parent.scope.active && (pending.asyncResolved || !pending.scope.active)) queueJob(update);
+					});
+					return;
+				}
+				for (const instance of activeChildren) {
+					const oldComp = normalizeClassComponent(instance.type);
+					let dirtyInstances = hmrDirtyComponents.get(oldComp);
+					if (!dirtyInstances) hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+					dirtyInstances.add(instance);
+					hmrDirtyComponentsMode.set(oldComp, !!isVapor);
+				}
 				runWithHmrUpdating(() => {
 					if (parent.vapor) parent.hmrRerender();
 					else {
@@ -576,7 +598,12 @@ function reload(id, newComp) {
 						}
 					}
 				});
-			});
+				queuePostFlushCb(() => {
+					hmrDirtyComponents.clear();
+					hmrDirtyComponentsMode.clear();
+				});
+			};
+			queueJob(update);
 		});
 	}
 	queuePostFlushCb(() => {
@@ -773,18 +800,35 @@ function withDirectives(vnode, directives) {
 	return vnode;
 }
 function invokeDirectiveHook(vnode, prevVNode, instance, name) {
-	const bindings = vnode.dirs;
+	let hookVNode = vnode;
+	if (name === "beforeMount") vnode._mount = vnode;
+	else if (name === "beforeUpdate") {
+		const mount = prevVNode && prevVNode._mount;
+		if (mount) {
+			mount._latest = vnode;
+			vnode._mount = mount;
+		}
+	} else if (name === "mounted") {
+		const latest = vnode._latest;
+		vnode._mount = vnode._latest = void 0;
+		if (latest) {
+			hookVNode = latest;
+			latest._mount = void 0;
+		}
+	}
+	const bindings = hookVNode.dirs;
 	const oldBindings = prevVNode && prevVNode.dirs;
 	for (let i = 0; i < bindings.length; i++) {
-		const binding = bindings[i];
+		let binding = bindings[i];
 		if (oldBindings) binding.oldValue = oldBindings[i].value;
+		else if (name === "mounted" && binding.oldValue !== void 0) binding = (0, _vue_shared.extend)({}, binding, { oldValue: void 0 });
 		let hook = binding.dir[name];
 		if (hook) {
 			const prevSub = (0, _vue_reactivity.setActiveSub)();
 			callWithAsyncErrorHandling(hook, instance, 8, [
 				vnode.el,
 				binding,
-				vnode,
+				hookVNode,
 				prevVNode
 			]);
 			(0, _vue_reactivity.setActiveSub)(prevSub);
@@ -1227,7 +1271,15 @@ const BaseTransitionImpl = {
 			const { mode } = rawProps;
 			checkTransitionMode(mode);
 			return prepareTransitionSwitch(instance.subTree, child, rawProps, state, instance, mode === "out-in" ? resumeAfterLeave || (resumeAfterLeave = () => {
-				if (!(instance.effect.flags & 1024)) instance.update();
+				if (!(instance.effect.flags & 1024)) {
+					if (instance.effect.running) {
+						const job = () => {
+							if (!(instance.effect.flags & 1024)) instance.update();
+						};
+						job.i = instance;
+						queueJob(job);
+					} else instance.update();
+				}
 			}) : _vue_shared.NOOP);
 		};
 	}
@@ -1257,7 +1309,7 @@ function getLeavingNodesForType(state, vnode) {
 	}
 	return leavingVNodesCache;
 }
-function resolveTransitionHooks(vnode, props, state, instance, postClone) {
+function resolveTransitionHooks(vnode, props, state, instance) {
 	const key = String(vnode.key);
 	const leavingVNodesCache = getLeavingNodesForType(state, vnode);
 	const hooks = baseResolveTransitionHooks({
@@ -1280,9 +1332,7 @@ function resolveTransitionHooks(vnode, props, state, instance, postClone) {
 			}
 		},
 		cloneHooks: (vnode) => {
-			const hooks = resolveTransitionHooks(vnode, props, state, instance, postClone);
-			if (postClone) postClone(hooks);
-			return hooks;
+			return resolveTransitionHooks(vnode, props, state, instance);
 		}
 	}, props, state, instance);
 	if (isVaporInteropEnabled && vnode.type === VaporSlot) (0, _vue_shared.extend)(hooks, {
@@ -1320,7 +1370,7 @@ function baseResolveTransitionHooks(context, props, state, instance) {
 			callHook(hook, [el]);
 		},
 		enter(el) {
-			if (!isHmrUpdating && isLeaving()) return;
+			if (!isHmrUpdating && isLeaving(el)) return;
 			let hook = onEnter;
 			let afterHook = onAfterEnter;
 			let cancelHook = onEnterCancelled;
@@ -1364,7 +1414,19 @@ function baseResolveTransitionHooks(context, props, state, instance) {
 			else done();
 		},
 		clone(node) {
-			return cloneHooks ? cloneHooks(node) : hooks;
+			if (!cloneHooks) return hooks;
+			const cloned = cloneHooks(node);
+			cloned.afterLeave = () => {
+				if (hooks.afterLeave) hooks.afterLeave();
+			};
+			cloned.delayLeave = (el, earlyRemove, delayedLeave) => {
+				if (hooks.delayLeave) hooks.delayLeave(el, earlyRemove, delayedLeave);
+				else delayedLeave();
+			};
+			cloned.delayedLeave = () => {
+				if (hooks.delayedLeave) hooks.delayedLeave();
+			};
+			return cloned;
 		}
 	};
 	return hooks;
@@ -1399,10 +1461,7 @@ function prepareTransitionSwitch(previous, next, props, state, instance, resumeA
 	if (state.isLeaving) return emptyPlaceholder(next);
 	const nextInner = getInnerChild$1(next);
 	if (!nextInner) return emptyPlaceholder(next);
-	let enterHooks = resolveTransitionHooks(nextInner, props, state, instance, (hooks) => {
-		if (delayedLeaveSource) forwardDelayedLeave(hooks, delayedLeaveSource);
-		enterHooks = hooks;
-	});
+	const enterHooks = resolveTransitionHooks(nextInner, props, state, instance);
 	if (delayedLeaveSource) forwardDelayedLeave(enterHooks, delayedLeaveSource);
 	if (nextInner.type !== Comment) setTransitionHooks(nextInner, enterHooks);
 	const mode = props.mode;
@@ -1468,9 +1527,14 @@ function setTransitionHooks(vnode, hooks) {
 			return setTransitionHooks(isTeleport(subTree.type) ? getInnerChild$1(subTree) || subTree : subTree, hooks);
 		}
 	} else if (vnode.shapeFlag & 128) {
-		const contentHooks = vnode.ssContent.transition = hooks.clone(vnode.ssContent);
-		const fallbackHooks = vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
-		return vnode.suspense && vnode.suspense.activeBranch === vnode.ssFallback ? fallbackHooks : contentHooks;
+		const suspense = vnode.suspense;
+		if (suspense) {
+			const branch = suspense.isHydrating ? suspense.pendingBranch : suspense.activeBranch;
+			if (branch) return setTransitionHooks(branch, hooks.clone(branch));
+		} else {
+			vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+			vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+		}
 	} else {
 		vnode.transition = hooks;
 		if (vnode.type === Fragment && (0, _vue_shared.isArray)(vnode.children)) {
@@ -1688,6 +1752,8 @@ const getContainerType = (container) => {
 	if (isMathMLContainer(container)) return "mathml";
 };
 const isComment = (node) => node.nodeType === 8;
+/** The data of a comment opening a range a hydration steps over as one. */
+const isRangeStart = (data) => data === "[" || data === "(" || (0, _vue_shared.isVaporRangeStart)(data);
 function createHydrationFunctions(rendererInternals) {
 	const { mt: mountComponent, p: patch, o: { patchProp, createText, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals;
 	const hydrate = (vnode, container) => {
@@ -1705,7 +1771,7 @@ function createHydrationFunctions(rendererInternals) {
 	};
 	const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
 		optimized = optimized || !!vnode.dynamicChildren;
-		const isFragmentStart = isComment(node) && (node.data === "[" || node.data === "(");
+		const isFragmentStart = isComment(node) && (node.data === "[" || node.data === "(" || isVaporInteropEnabled && (0, _vue_shared.isVaporRangeStart)(node.data));
 		const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart);
 		const { type, ref, shapeFlag, patchFlag } = vnode;
 		let domType = node.nodeType;
@@ -1894,16 +1960,17 @@ function createHydrationFunctions(rendererInternals) {
 		const container = parentNode(node);
 		const first = nextSibling(node);
 		const next = isVaporInteropEnabled && vnode.vo && node.data === "(" ? getVaporInterface(parentComponent, vnode).hydrateSlotOutlet(vnode, node, parentComponent, parentSuspense, slotScopeIds) : hydrateChildren(first, vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized);
-		if (next && isComment(next) && next.data === (node.data === "(" ? ")" : "]")) return nextSibling(vnode.anchor = next);
+		const close = isVaporInteropEnabled ? (0, _vue_shared.rangeCloseOf)(node.data) : node.data === "(" ? ")" : "]";
+		if (next && isComment(next) && next.data === close) return nextSibling(vnode.anchor = next);
 		else {
 			logMismatchError();
-			insert(vnode.anchor = createComment(`]`), container, next);
+			insert(vnode.anchor = createComment(close), container, next);
 			return next;
 		}
 	};
 	const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
 		if (!isNodeMismatchAllowed(node, vnode)) {
-			warn$1(`Hydration node mismatch:\n- rendered on server:`, node, node.nodeType === 3 ? `(text)` : isComment(node) && (node.data === "[" || node.data === "(") ? `(start of fragment)` : ``, `\n- expected on client:`, vnode.type);
+			warn$1(`Hydration node mismatch:\n- rendered on server:`, node, node.nodeType === 3 ? `(text)` : isComment(node) && isRangeStart(node.data) ? `(start of fragment)` : ``, `\n- expected on client:`, vnode.type);
 			logMismatchError();
 		}
 		vnode.el = null;
@@ -1919,18 +1986,18 @@ function createHydrationFunctions(rendererInternals) {
 		const container = parentNode(node);
 		remove(node);
 		patch(null, vnode, container, next, parentComponent, parentSuspense, getContainerType(container), slotScopeIds);
-		if (parentComponent && parentComponent.vnode) {
+		if (parentComponent && parentComponent.vnode && parentComponent.vnode.el === node) {
 			parentComponent.vnode.el = vnode.el;
 			updateHOCHostEl(parentComponent, vnode.el);
 		}
 		return next;
 	};
-	const locateClosingAnchor = (node, open = node && isComment(node) && node.data === "(" ? "(" : "[", close = open === "(" ? ")" : "]") => {
+	const locateClosingAnchor = (node, open = node && isComment(node) && (node.data === "(" || isVaporInteropEnabled && node.data === "{") ? node.data : "[", close = isVaporInteropEnabled ? (0, _vue_shared.rangeCloseOf)(open) : open === "(" ? ")" : "]") => {
 		let match = 0;
 		while (node) {
 			node = nextSibling(node);
 			if (node && isComment(node)) {
-				if (node.data === open) match++;
+				if (node.data === open || isVaporInteropEnabled && open === "[" && (0, _vue_shared.isVaporBranchStart)(node.data)) match++;
 				if (node.data === close) {
 					if (match === 0) return nextSibling(node);
 					else match--;
@@ -2186,9 +2253,9 @@ const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => {
 	return teardown;
 };
 function forEachElement(node, cb) {
-	if (isComment(node) && (node.data === "[" || node.data === "(")) {
+	if (isComment(node) && isRangeStart(node.data)) {
 		const open = node.data;
-		const close = open === "[" ? "]" : ")";
+		const close = (0, _vue_shared.rangeCloseOf)(open);
 		let depth = 1;
 		let next = node.nextSibling;
 		while (next) {
@@ -2197,7 +2264,7 @@ function forEachElement(node, cb) {
 			} else if (isComment(next)) {
 				if (next.data === close) {
 					if (--depth === 0) break;
-				} else if (next.data === open) depth++;
+				} else if (close === "]" ? next.data === "[" || (0, _vue_shared.isVaporBranchStart)(next.data) : next.data === open) depth++;
 			}
 			next = next.nextSibling;
 		}
@@ -2225,7 +2292,7 @@ function defineAsyncComponent(source) {
 			if (resolvedComp) return () => createInnerComp(resolvedComp, instance);
 			const onError = (err) => {
 				setPendingRequest(null);
-				handleError(err, instance, 13, !errorComponent);
+				handleError(err, instance, 13, !errorComponent, true);
 			};
 			if (suspensible && instance.suspense || isInSSRComponentSetup) return load().then((comp) => {
 				return () => createInnerComp(comp, instance);
@@ -2306,10 +2373,12 @@ const useAsyncComponentState = (delay = 200, timeout, onError, instance = curren
 	const delayed = (0, _vue_reactivity.ref)(!!delay);
 	let timeoutTimer;
 	let delayTimer;
-	if (instance) onUnmounted(() => {
-		if (timeoutTimer != null) clearTimeout(timeoutTimer);
-		if (delayTimer != null) clearTimeout(delayTimer);
-	}, instance);
+	if (instance) instance.scope.run(() => {
+		(0, _vue_reactivity.onScopeDispose)(() => {
+			if (timeoutTimer != null) clearTimeout(timeoutTimer);
+			if (delayTimer != null) clearTimeout(delayTimer);
+		});
+	});
 	if (delay) delayTimer = setTimeout(() => {
 		if (instance && instance.isUnmounted) return;
 		delayed.value = false;
@@ -2344,7 +2413,12 @@ function performAsyncHydrate(el, instance, hydrate, getResolvedComp, load, hydra
 			}
 			return;
 		}
-		if (!el.parentNode || wasConnected && !el.isConnected) return;
+		if (!el.parentNode) return;
+		if (wasConnected && !el.isConnected) {
+			let current = instance;
+			while (current && !current.isDeactivated) current = current.parent;
+			if (!current) return;
+		}
 		hydrate();
 	};
 	const doHydrate = hydrateStrategy ? () => {
@@ -2402,7 +2476,11 @@ const KeepAlive = /*@__PURE__*/ withKeepAliveEnabled({
 			activate(vnode, container, anchor, renderer, keepAliveInstance, parentSuspense, namespace, optimized);
 		};
 		sharedContext.deactivate = (vnode) => {
-			deactivate(vnode, storageContainer, renderer, keepAliveInstance, parentSuspense);
+			const cached = sharedContext.getCachedComponent(vnode);
+			if (!cached || cached.component !== vnode.component) return false;
+			if (isVaporInteropEnabled && isVaporComponent(vnode.type)) getVaporInterface(keepAliveInstance, vnode).deactivate(vnode, storageContainer, parentSuspense);
+			else deactivate(vnode, storageContainer, renderer, keepAliveInstance, parentSuspense);
+			return true;
 		};
 		function unmount(vnode) {
 			resetShapeFlag(vnode);
@@ -2434,11 +2512,15 @@ const KeepAlive = /*@__PURE__*/ withKeepAliveEnabled({
 		let pendingCacheKey = null;
 		const cacheSubtree = () => {
 			if (pendingCacheKey != null) {
-				if (isSuspense(keepAliveInstance.subTree.type)) queuePostRenderEffect(() => {
-					const vnode = getInnerChild(keepAliveInstance.subTree);
-					if (vnode.component) cache.set(pendingCacheKey, vnode);
-				}, void 0, keepAliveInstance.subTree.suspense);
-				else cache.set(pendingCacheKey, getInnerChild(keepAliveInstance.subTree));
+				if (isSuspense(keepAliveInstance.subTree.type)) {
+					const cacheInnerChild = () => {
+						const vnode = getInnerChild(keepAliveInstance.subTree);
+						if (vnode.component) cache.set(pendingCacheKey, vnode);
+					};
+					const suspense = keepAliveInstance.subTree.suspense;
+					if (suspense.pendingBranch) queuePostRenderEffect(cacheInnerChild, void 0, suspense);
+					else cacheInnerChild();
+				} else cache.set(pendingCacheKey, getInnerChild(keepAliveInstance.subTree));
 			}
 		};
 		onMounted(cacheSubtree);
@@ -2543,9 +2625,8 @@ function registerKeepAliveHook(hook, type, target = getCurrentGenericInstance())
 }
 function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
 	const injected = injectHook(type, hook, keepAliveRoot, true);
-	onUnmounted(() => {
-		(0, _vue_shared.remove)(keepAliveRoot[type], injected);
-	}, target);
+	const removal = injectHook("um", () => (0, _vue_shared.remove)(keepAliveRoot[type], injected), target);
+	removal.flags = 8;
 }
 function resetShapeFlag(vnode) {
 	vnode.shapeFlag &= -257;
@@ -2770,6 +2851,11 @@ function renderSlot(slots, name, props, fallback, noSlotted, branchKey) {
 			ret.props = (0, _vue_shared.extend)({}, ret.props, { key: branchKey });
 			ret.key = branchKey;
 		}
+		if (isBlockTreeEnabled <= 0) {
+			if (!ret.vs.props) ret.vs.props = ret.props;
+			ret.props = ret.key != null ? { key: ret.key } : null;
+			ret.vs.attrs = _vue_shared.EMPTY_OBJ;
+		}
 		if (!noSlotted && ret.scopeId) ret.slotScopeIds = [ret.scopeId + "-s"];
 		return ret;
 	}
@@ -4571,8 +4657,10 @@ function baseCreateRenderer(options, createHydrationFns) {
 		(0, _vue_shared.def)(el, "__vnode", vnode, true);
 		(0, _vue_shared.def)(el, "__vueParentComponent", parentComponent, true);
 		if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
-		if (transition) performTransitionEnter(el, transition, () => hostInsert(el, container, anchor), parentSuspense);
-		else hostInsert(el, container, anchor);
+		if (transition) {
+			if (!needTransition(parentSuspense, transition) && !transition.persisted) el[deferredEnterKey] = true;
+			performTransitionEnter(el, transition, () => hostInsert(el, container, anchor), parentSuspense);
+		} else hostInsert(el, container, anchor);
 		if ((vnodeHook = props && props.onVnodeMounted) || dirs) {
 			const isHmr = isHmrUpdating;
 			queuePostRenderEffect(() => {
@@ -4829,16 +4917,20 @@ function baseCreateRenderer(options, createHydrationFns) {
 			} else {
 				let { next, bu, u, parent, vnode } = instance;
 				{
-					const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
-					if (nonHydratedAsyncRoot) {
+					const unresolvedAsyncRoot = locateUnresolvedAsyncRoot(instance);
+					if (unresolvedAsyncRoot) {
 						if (next) {
 							next.el = vnode.el;
 							updateComponentPreRender(instance, next, optimized);
 						}
-						nonHydratedAsyncRoot.asyncDep.then(() => {
-							queuePostRenderEffect(() => {
-								if (!instance.isUnmounted) instance.update();
-							}, void 0, parentSuspense);
+						unresolvedAsyncRoot.asyncDep.then(() => {
+							const retry = () => {
+								if (instance.effect.flags & 1024) return;
+								if (parentSuspense && parentSuspense.pendingBranch) queuePostRenderEffect(retry, void 0, parentSuspense);
+								else instance.update();
+							};
+							retry.flags = 24;
+							queuePostRenderEffect(retry, void 0, parentSuspense);
 						});
 						return;
 					}
@@ -4861,7 +4953,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 				const prevTree = instance.subTree;
 				instance.subTree = nextTree;
 				startMeasure(instance, `patch`);
-				patch(prevTree, nextTree, hostParentNode(prevTree.el), getNextHostNode(prevTree), instance, parentSuspense, namespace);
+				patch(prevTree, nextTree, hostParentNode(prevTree.el || resolveAsyncComponentPlaceholder(prevTree)), getNextHostNode(prevTree), instance, parentSuspense, namespace);
 				endMeasure(instance, `patch`);
 				next.el = nextTree.el;
 				if (originNext === null) updateHOCHostEl(instance, nextTree.el);
@@ -5064,9 +5156,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 		}
 		if (cacheIndex != null && (!vnode.ctx || vnode.ctx === parentComponent)) parentComponent.renderCache[cacheIndex] = void 0;
 		if (shapeFlag & 256) {
-			if (isVaporInteropEnabled && isVaporComponent(vnode.type)) getVaporInterface(parentComponent, vnode).deactivate(vnode, parentComponent.ctx.getStorageContainer(), parentSuspense);
-			else parentComponent.ctx.deactivate(vnode);
-			return;
+			if (parentComponent.ctx.deactivate(vnode)) return;
 		}
 		if (isVaporInteropEnabled && shapeFlag & 6 && isVaporComponent(type)) {
 			getVaporInterface(parentComponent, vnode).unmount(vnode, doRemove, parentSuspense);
@@ -5146,12 +5236,14 @@ function baseCreateRenderer(options, createHydrationFns) {
 		if (effect) {
 			effect.stop();
 			unmount(subTree, instance, parentSuspense, doRemove);
-		} else if (instance.vnode.el && subTree) {
+		} else if (subTree) {
 			subTree.transition = instance.vnode.transition;
 			unmount(subTree, instance, parentSuspense, doRemove);
 		}
 		if (um) queuePostRenderEffect(um, void 0, parentSuspense);
-		queuePostRenderEffect(() => instance.isUnmounted = true, void 0, parentSuspense);
+		const markUnmounted = () => instance.isUnmounted = true;
+		markUnmounted.flags = 8;
+		queuePostRenderEffect(markUnmounted, void 0, parentSuspense);
 		devtoolsComponentRemoved(instance);
 	};
 	const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
@@ -5265,11 +5357,11 @@ function traverseStaticChildren(n1, n2, shallow = false) {
 		c2.el && (c2.el.__vnode = c2);
 	}
 }
-function locateNonHydratedAsyncRoot(instance) {
+function locateUnresolvedAsyncRoot(instance) {
 	const subComponent = instance.subTree && instance.subTree.component;
 	if (subComponent) {
 		if (subComponent.asyncDep && !subComponent.asyncResolved) return subComponent;
-		else return locateNonHydratedAsyncRoot(subComponent);
+		else return locateUnresolvedAsyncRoot(subComponent);
 	}
 }
 function invalidateMount(hooks) {
@@ -5339,7 +5431,9 @@ function getInheritedScopeIds(vnode, parentComponent, includeVaporRootIds = true
 function resolveAsyncComponentPlaceholder(anchorVnode) {
 	if (anchorVnode.placeholder) return anchorVnode.placeholder;
 	const instance = anchorVnode.component;
-	if (instance) return resolveAsyncComponentPlaceholder(instance.subTree);
+	if (instance && instance.subTree) return resolveAsyncComponentPlaceholder(instance.subTree);
+	const suspense = anchorVnode.suspense;
+	if (suspense && suspense.activeBranch) return resolveAsyncComponentPlaceholder(suspense.activeBranch);
 	return null;
 }
 //#endregion
@@ -5351,17 +5445,22 @@ function withSuspenseEnabled(value) {
 	return value;
 }
 let suspenseId = 0;
+const deferredEnterKey = Symbol("_deferredEnter");
 const Suspense = /*@__PURE__*/ withSuspenseEnabled({
 	name: "Suspense",
 	__isSuspense: true,
 	process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
 		if (n1 == null) mountSuspense(n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals);
 		else {
-			if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback && !parentSuspense.isHydrating) {
-				n2.suspense = n1.suspense;
-				n2.suspense.vnode = n2;
-				n2.el = n1.el;
-				return;
+			const suspense = n1.suspense;
+			if (parentSuspense && parentSuspense.deps > 0 && !parentSuspense.isHydrating) {
+				const owner = suspense.parentComponent;
+				if (!!owner && owner.suspense === parentSuspense && owner.suspenseId !== parentSuspense.pendingId ? parentSuspense.pendingBranch && !isSameVNodeType(n2.ssContent, suspense.pendingBranch || suspense.activeBranch) : !suspense.isInFallback) {
+					n2.suspense = suspense;
+					suspense.vnode = n2;
+					n2.el = n1.el;
+					return;
+				}
 			}
 			patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, rendererInternals);
 		}
@@ -5373,6 +5472,36 @@ function triggerEvent(vnode, name) {
 	const eventListener = vnode.props && vnode.props[name];
 	if ((0, _vue_shared.isFunction)(eventListener)) eventListener();
 }
+function enterDeferred(suspense, branch) {
+	const enters = [];
+	collectDeferredEnters(branch, enters, true);
+	if (isVaporInteropEnabled) {
+		const { parentComponent } = suspense;
+		const vapor = parentComponent && parentComponent.appContext.vapor;
+		if (vapor) vapor.enterDeferred(suspense, enters);
+	}
+	if (enters.length) queuePostFlushCb(enters);
+}
+function collectDeferredEnters(vnode, enters, isRoot) {
+	const { el, transition, children, shapeFlag } = vnode;
+	if (shapeFlag & 6) {
+		const subTree = vnode.component.subTree;
+		if (subTree) collectDeferredEnters(subTree, enters, isRoot);
+		return;
+	}
+	if (shapeFlag & 192) return;
+	if (shapeFlag & 1) {
+		if (!isRoot && el && el[deferredEnterKey]) {
+			el[deferredEnterKey] = void 0;
+			if (transition && !transition.persisted) {
+				transition.beforeEnter(el);
+				enters.push(() => transition.enter(el));
+			}
+		}
+		isRoot = false;
+	}
+	if (shapeFlag & 16) for (let i = 0; i < children.length; i++) collectDeferredEnters(children[i], enters, isRoot);
+}
 function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
 	const { p: patch, o: { createElement } } = rendererInternals;
 	const hiddenContainer = createElement("div");
@@ -5412,11 +5541,7 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
 				suspense.activeBranch = pendingBranch;
 			} else unmount(pendingBranch, parentComponent, suspense);
 			suspense.deps = 0;
-			for (let i = 0; i < suspense.effects.length; i++) {
-				const effect = suspense.effects[i];
-				if (effect.flags & 8) queuePostFlushCb(effect);
-			}
-			suspense.effects.length = 0;
+			discardEffects(suspense);
 			suspense.hiddenContainer = createElement("div");
 			if (isInFallback) {
 				patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
@@ -5439,14 +5564,14 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
 	} else {
 		triggerEvent(n2, "onPending");
 		suspense.pendingBranch = newBranch;
-		if (newBranch.shapeFlag & 512) suspense.pendingId = newBranch.component.suspenseId;
-		else suspense.pendingId = suspenseId++;
+		suspense.pendingId = suspenseId++;
 		patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
 		if (suspense.deps <= 0) suspense.resolve();
 		else {
-			const { timeout, pendingId } = suspense;
-			if (timeout > 0) setTimeout(() => {
-				if (suspense.pendingId === pendingId) suspense.fallback(newFallback);
+			const { timeout } = suspense;
+			if (timeout > 0) suspense.timeoutTimer = setTimeout(() => {
+				suspense.timeoutTimer = void 0;
+				suspense.fallback(suspense.vnode.ssFallback);
 			}, timeout);
 			else if (timeout === 0) suspense.fallback(newFallback);
 		}
@@ -5482,6 +5607,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
 		deps: 0,
 		pendingId: suspenseId++,
 		timeout: typeof timeout === "number" ? timeout : -1,
+		timeoutTimer: void 0,
 		activeBranch: null,
 		isFallbackMountPending: false,
 		pendingBranch: null,
@@ -5499,26 +5625,39 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
 				delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
 				let hasUpdatedAnchor = false;
 				if (delayEnter) activeBranch.transition.afterLeave = () => {
-					if (pendingId === suspense.pendingId) {
+					if (pendingId === suspense.pendingId && !suspense.isUnmounted) {
+						enterDeferred(suspense, pendingBranch);
 						move(pendingBranch, container, anchor === initialAnchor && !hasUpdatedAnchor ? next(activeBranch) : anchor, 0, parentComponent);
 						queuePostFlushCb(effects);
 						if (isInFallback && vnode.ssFallback) vnode.ssFallback.el = null;
 					}
 				};
 				if (activeBranch && !suspense.isFallbackMountPending) {
-					if (parentNode(activeBranch.el) === container) {
+					if (parentNode(activeBranch.el || resolveAsyncComponentPlaceholder(activeBranch)) === container) {
 						anchor = next(activeBranch);
 						hasUpdatedAnchor = true;
 					}
 					unmount(activeBranch, parentComponent, suspense, true);
 					if (!delayEnter && isInFallback && vnode.ssFallback) queuePostRenderEffect(() => vnode.ssFallback.el = null, void 0, suspense);
 				}
-				if (!delayEnter) move(pendingBranch, container, anchor, 0, parentComponent);
+				if (!delayEnter) {
+					enterDeferred(suspense, pendingBranch);
+					move(pendingBranch, container, anchor, 0, parentComponent);
+				}
 			}
+			clearTimeout(suspense.timeoutTimer);
+			suspense.timeoutTimer = void 0;
 			suspense.isFallbackMountPending = false;
 			setActiveBranch(suspense, pendingBranch);
 			suspense.pendingBranch = null;
 			suspense.isInFallback = false;
+			let kept = 0;
+			for (let i = 0; i < effects.length; i++) {
+				const effect = effects[i];
+				if (effect.flags & 16) queuePostFlushCb(effect);
+				else effects[kept++] = effect;
+			}
+			effects.length = kept;
 			let parent = suspense.parent;
 			let hasUnresolvedAncestor = false;
 			while (parent) {
@@ -5541,13 +5680,13 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
 			triggerEvent(vnode, "onResolve");
 		},
 		fallback(fallbackVNode) {
-			if (!suspense.pendingBranch) return;
+			if (suspense.isUnmounted || !suspense.pendingBranch) return;
 			const { vnode, activeBranch, parentComponent, container, namespace } = suspense;
 			triggerEvent(vnode, "onFallback");
 			const anchor = next(activeBranch);
 			const mountFallback = () => {
 				suspense.isFallbackMountPending = false;
-				if (!suspense.isInFallback) return;
+				if (suspense.isUnmounted || !suspense.isInFallback) return;
 				const latestFallback = suspense.vnode.ssFallback;
 				patch(null, latestFallback, container, anchor, parentComponent, null, namespace, slotScopeIds, optimized);
 				setActiveBranch(suspense, latestFallback);
@@ -5571,24 +5710,52 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
 		registerDep(instance, onResolve) {
 			const isInPendingSuspense = !!suspense.pendingBranch;
 			if (isInPendingSuspense) suspense.deps++;
+			const render = (setupResult) => {
+				instance.asyncResolved = true;
+				onResolve(setupResult);
+			};
 			instance.asyncDep.catch((err) => {
-				handleError(err, instance, 0);
+				handleError(err, instance, 0, false, true);
+				return () => null;
 			}).then((asyncSetupResult) => {
-				if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) return;
+				if (instance.isUnmounted || suspense.isUnmounted) return;
+				const isPendingDep = isInPendingSuspense && suspense.pendingId === instance.suspenseId;
 				setCurrentInstance(null, void 0);
 				if (!instance.scope.active) {
-					if (isInPendingSuspense && --suspense.deps === 0) suspense.resolve();
+					if (isPendingDep && --suspense.deps === 0) suspense.resolve();
 					return;
 				}
-				instance.asyncResolved = true;
-				onResolve(asyncSetupResult);
-				if (isInPendingSuspense && --suspense.deps === 0) suspense.resolve();
+				if (!isPendingDep && suspense.pendingBranch) {
+					const job = () => {
+						if (instance.isUnmounted || suspense.isUnmounted || !instance.scope.active) return;
+						if (suspense.pendingBranch) queueEffectWithSuspense(job, void 0, suspense);
+						else render(asyncSetupResult);
+					};
+					job.flags = 24;
+					queueEffectWithSuspense(job, void 0, suspense);
+					return;
+				}
+				render(asyncSetupResult);
+				if (isPendingDep && --suspense.deps === 0) suspense.resolve();
 			});
 		},
 		unmount(parentSuspense, doRemove) {
 			suspense.isUnmounted = true;
+			clearTimeout(suspense.timeoutTimer);
+			suspense.timeoutTimer = void 0;
+			if (parentSuspenseId !== void 0) {
+				const parent = suspense.parent;
+				const pendingId = parentSuspenseId;
+				parentSuspenseId = void 0;
+				queuePostFlushCb(() => {
+					if (parent.pendingId === pendingId && !parent.isUnmounted && --parent.deps === 0) parent.resolve();
+				});
+			}
 			if (suspense.activeBranch) unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove);
-			if (suspense.pendingBranch) unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove);
+			if (suspense.pendingBranch) {
+				unmount(suspense.pendingBranch, parentComponent, suspense, doRemove);
+				discardEffects(suspense);
+			}
 		}
 	};
 	return suspense;
@@ -5629,6 +5796,14 @@ function normalizeSuspenseSlot(s) {
 	if (block && !s.dynamicChildren) s.dynamicChildren = block.filter((c) => c !== s);
 	return s;
 }
+function discardEffects(suspense) {
+	const { effects } = suspense;
+	for (let i = 0; i < effects.length; i++) {
+		const effect = effects[i];
+		if (effect.flags & 8) queuePostFlushCb(effect);
+	}
+	effects.length = 0;
+}
 function queueEffectWithSuspense(fn, id, suspense) {
 	if (suspense && suspense.pendingBranch) {
 		if ((0, _vue_shared.isArray)(fn)) suspense.effects.push(...fn);
@@ -5853,7 +6028,8 @@ function _createVNode(type, props = null, children = null, patchFlag = 0, dynami
 }
 function guardReactiveProps(props) {
 	if (!props) return null;
-	return (0, _vue_reactivity.isProxy)(props) || isInternalObject(props) ? (0, _vue_shared.extend)({}, props) : props;
+	if ((0, _vue_reactivity.isProxy)(props)) return (0, _vue_shared.extend)({}, props);
+	return isInternalObject(props) ? (0, _vue_shared.extend)({}, props[rawAttrsKey] || props) : props;
 }
 function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
 	const { props, ref, patchFlag, children, transition } = vnode;
@@ -5966,6 +6142,17 @@ function normalizeVNode(child) {
 function cloneIfMounted(child) {
 	return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
 }
+let deferElementSlots = false;
+/**
+* While enabled, compiled default slots passed as children of plain elements
+* are kept on the vnode so the server renderer can render them in push mode.
+* @internal
+*/
+function setDeferElementSlots(value) {
+	const prev = deferElementSlots;
+	deferElementSlots = value;
+	return prev;
+}
 function normalizeChildren(vnode, children) {
 	let type = 0;
 	const { shapeFlag } = vnode;
@@ -5974,6 +6161,11 @@ function normalizeChildren(vnode, children) {
 	else if (typeof children === "object") {
 		if (shapeFlag & 65) {
 			const slot = children.default;
+			if (deferElementSlots && slot && slot._c && shapeFlag & 1) {
+				vnode.children = children;
+				vnode.shapeFlag |= 32;
+				return;
+			}
 			if (slot) {
 				slot._c && (slot._d = false);
 				normalizeChildren(vnode, slot());
@@ -6248,7 +6440,8 @@ function setupStatefulComponent(instance, isSSR) {
 					setInSSRSetupState(false);
 				}
 			}).catch((e) => {
-				handleError(e, instance, 0);
+				handleError(e, instance, 0, void 0, true);
+				instance.ssrRender = (_, push) => push("<!---->");
 			});
 			else {
 				instance.asyncDep = setupResult;
@@ -6319,11 +6512,16 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
 		else warn$1(`Component is missing template or render function: `, Component);
 	}
 }
+/**
+* Read through the setup context `attrs` proxy to get the raw attrs object.
+* @internal
+*/
+const rawAttrsKey = Symbol();
 const attrsProxyHandlers = {
 	get(target, key) {
 		markAttrsAccessed();
 		(0, _vue_reactivity.track)(target, "get", "");
-		return target[key];
+		return key === rawAttrsKey ? target : target[key];
 	},
 	set() {
 		warn$1(`setupContext.attrs is readonly.`);
@@ -6621,7 +6819,7 @@ function isMemoSame(cached, memo) {
 }
 //#endregion
 //#region packages/runtime-core/src/index.ts
-const version = "3.6.0-rc.13";
+const version = "3.6.0-rc.15";
 const warn = warn$1;
 /**
 * Runtime error messages. Only exposed in dev or esm builds.
@@ -6647,7 +6845,8 @@ const ssrUtils = {
 	popWarningContext,
 	VaporSlot,
 	rawVaporSlotKey,
-	invokeSlotFallback
+	invokeSlotFallback,
+	setDeferElementSlots
 };
 /**
 * @internal only exposed in compat builds