@vue/runtime-vapor 3.6.0-beta.10 → 3.6.0-beta.11

package/dist/runtime-vapor.esm-bundler.js

@@ -1,24 +1,22 @@
 /**
-  * @vue/runtime-vapor v3.6.0-beta.10
+  * @vue/runtime-vapor v3.6.0-beta.11
   * (c) 2018-present Yuxi (Evan) You and Vue contributors
   * @license MIT
   **/
-import { EffectScope, Fragment, NULL_DYNAMIC_COMPONENT, Static, TransitionPropsValidators, VueElementBase, activate, baseApplyTranslation, baseEmit, baseNormalizePropsOptions, baseResolveTransitionHooks, baseUseCssVars, callPendingCbs, callWithAsyncErrorHandling, callWithErrorHandling, checkTransitionMode, createAppAPI, createAsyncComponentContext, createCanSetSetupRefChecker, createInternalObject, createVNode, currentInstance, currentInstance as currentInstance$1, deactivate, devtoolsComponentAdded, endMeasure, ensureHydrationRenderer, ensureRenderer, ensureVaporSlotFallback, expose, flushOnAppMount, forceReflow, getAttributeMismatch, getComponentName, getFunctionalFallthrough, getInheritedScopeIds, getTransitionRawChildren, handleError, handleMovedChildren, hasCSSTransform, initFeatureFlags, invalidateMount, invokeDirectiveHook, isAsyncWrapper, isEmitListener, isHydrating, isKeepAlive, isMapEqual, isMismatchAllowed, isRef, isSetEqual, isTeleportDeferred, isTeleportDisabled, isTemplateNode, isTemplateRefKey, isVNode, isValidHtmlOrSvgAttribute, knownTemplateRefs, leaveCbKey, markAsyncBoundary, matches, mergeProps, nextUid, normalizeContainer, normalizeRef, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onMounted, onScopeDispose, onUpdated, patchStyle, performAsyncHydrate, performTransitionEnter, performTransitionLeave, popWarningContext, pushWarningContext, queueJob, queuePostFlushCb, registerHMR, renderSlot, resetShapeFlag, resolveDynamicComponent, resolvePropValue, resolveTeleportTarget, resolveTransitionProps, setCurrentInstance, setCurrentRenderingInstance, setDevtoolsHook, setRef, setTransitionHooks, setVarsOnNode, shallowReactive, shallowRef, shouldSetAsProp, shouldSetAsPropForVueCE, shouldUpdateComponent, simpleSetCurrentInstance, startMeasure, toClassSet, toStyleMap, unregisterHMR, unsafeToTrustedHTML, useAsyncComponentState, useTransitionState, vModelCheckboxInit, vModelCheckboxUpdate, vModelGetValue, vModelSelectInit, vModelSetSelected, vModelTextInit, vModelTextUpdate, vShowHidden, vShowOriginalDisplay, validateProps, warn, warnExtraneousAttributes, warnPropMismatch, watch, withAsyncContext as withAsyncContext$1, xlinkNS } from "@vue/runtime-dom";
+import { EffectScope, Fragment, NULL_DYNAMIC_COMPONENT, Static, TransitionPropsValidators, VaporSlot, VueElementBase, activate, baseApplyTranslation, baseEmit, baseNormalizePropsOptions, baseResolveTransitionHooks, baseUseCssVars, callPendingCbs, callWithAsyncErrorHandling, callWithErrorHandling, checkTransitionMode, createAppAPI, createAsyncComponentContext, createCanSetSetupRefChecker, createInternalObject, createVNode, currentInstance, currentInstance as currentInstance$1, deactivate, devtoolsComponentAdded, endMeasure, ensureHydrationRenderer, ensureRenderer, ensureValidVNode, ensureVaporSlotFallback, expose, flushOnAppMount, forceReflow, getAttributeMismatch, getComponentName, getFunctionalFallthrough, getInheritedScopeIds, getTransitionRawChildren, handleError, handleMovedChildren, hasCSSTransform, initFeatureFlags, invalidateMount, invokeDirectiveHook, isAsyncWrapper, isEmitListener, isHydrating, isKeepAlive, isMapEqual, isMismatchAllowed, isRef, isSetEqual, isTeleportDeferred, isTeleportDisabled, isTemplateNode, isTemplateRefKey, isVNode, isValidHtmlOrSvgAttribute, knownTemplateRefs, leaveCbKey, markAsyncBoundary, matches, mergeProps, nextUid, normalizeContainer, normalizeRef, normalizeVNode, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onMounted, onScopeDispose, onUpdated, patchStyle, performAsyncHydrate, performTransitionEnter, performTransitionLeave, popWarningContext, pushWarningContext, queueJob, queuePostFlushCb, registerHMR, renderSlot, resetShapeFlag, resolveDynamicComponent, resolvePropValue, resolveTeleportTarget, resolveTransitionProps, setCurrentInstance, setCurrentRenderingInstance, setDevtoolsHook, setRef, setTransitionHooks, setVarsOnNode, shallowReactive, shallowRef, shouldSetAsProp, shouldSetAsPropForVueCE, shouldUpdateComponent, simpleSetCurrentInstance, startMeasure, toClassSet, toStyleMap, unregisterHMR, unsafeToTrustedHTML, useAsyncComponentState, useTransitionState, vModelCheckboxInit, vModelCheckboxUpdate, vModelGetValue, vModelSelectInit, vModelSetSelected, vModelTextInit, vModelTextUpdate, vShowHidden, vShowOriginalDisplay, validateProps, warn, warnExtraneousAttributes, warnPropMismatch, watch, withAsyncContext as withAsyncContext$1, xlinkNS } from "@vue/runtime-dom";
 import { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, camelize, canSetValueDirectly, extend, getEscapedCssVarName, getGlobalThis, hasOwn, includeBooleanAttr, invokeArrayFns, isArray, isFunction, isObject, isOn, isPlainObject, isPromise, isReservedProp, isString, looseEqual, normalizeClass, normalizeCssVarValue, normalizeStyle, parseStringStyle, remove as remove$1, stringifyStyle, toDisplayString } from "@vue/shared";
-import { EffectScope as EffectScope$1, ReactiveEffect, computed, effectScope, isReactive, isReadonly, isRef as isRef$1, isShallow, markRaw, onEffectCleanup, onScopeDispose as onScopeDispose$1, pauseTracking, proxyRefs, resetTracking, setActiveSub, shallowReadArray, shallowRef as shallowRef$1, toRaw, toReactive, toReadonly, traverse, unref, watch as watch$1 } from "@vue/reactivity";
+import { EffectScope as EffectScope$1, ReactiveEffect, computed, effectScope, getCurrentScope, isReactive, isReadonly, isRef as isRef$1, isShallow, markRaw, onEffectCleanup, onScopeDispose as onScopeDispose$1, pauseTracking, proxyRefs, resetTracking, setActiveSub, shallowReadArray, shallowRef as shallowRef$1, toRaw, toReactive, toReadonly, traverse, unref, watch as watch$1 } from "@vue/reactivity";
 //#region packages/runtime-vapor/src/insertionState.ts
 let insertionParent;
 let insertionAnchor;
 let insertionIndex;
-let isLastInsertion;
 /**
 * This function is called before a block type that requires insertion
 * (component, slot outlet, if, for) is created. The state is used for actual
 * insertion on client-side render, and used for node adoption during hydration.
 */
-function setInsertionState(parent, anchor, logicalIndex, last) {
+function setInsertionState(parent, anchor, logicalIndex) {
 	insertionParent = parent;
-	isLastInsertion = last;
 	insertionIndex = logicalIndex;
 	if (anchor !== void 0) if (isHydrating$1) insertionAnchor = void 0;
 	else {
@@ -28,7 +26,7 @@ function setInsertionState(parent, anchor, logicalIndex, last) {
 	else insertionAnchor = void 0;
 }
 function resetInsertionState() {
-	insertionParent = insertionAnchor = insertionIndex = isLastInsertion = void 0;
+	insertionParent = insertionAnchor = insertionIndex = void 0;
 }
 //#endregion
 //#region packages/runtime-vapor/src/dom/hydration.ts
@@ -105,14 +103,38 @@ const isComment = (node, data) => node.nodeType === 8 && node.data === data;
 function setCurrentHydrationNode(node) {
 	currentHydrationNode = node;
 }
-/* @__NO_SIDE_EFFECTS__ */
-function locateNextSiblingOfParent(n) {
-	if (!n.parentNode) return null;
-	return /* @__PURE__ */ _next(n.parentNode) || /* @__PURE__ */ locateNextSiblingOfParent(n.parentNode);
-}
 function advanceHydrationNode(node) {
-	const ret = /* @__PURE__ */ _next(node) || /* @__PURE__ */ locateNextSiblingOfParent(node);
-	if (ret) setCurrentHydrationNode(ret);
+	let next = node.nextSibling;
+	if (next && currentHydrationNode === next) return;
+	while (!next) {
+		const parent = node.parentNode;
+		if (!parent) break;
+		node = parent;
+		next = node.nextSibling;
+	}
+	if (currentHydrationNode !== next) currentHydrationNode = next;
+}
+function enterHydrationCursor(consumeFragmentStart = false) {
+	const resume = insertionParent ? currentHydrationNode : void 0;
+	locateHydrationNode(consumeFragmentStart);
+	return {
+		start: currentHydrationNode,
+		resume
+	};
+}
+/**
+* Capture only the outer resume cursor for dynamic wrappers whose inner owner
+* locates the local start later, after the selected inner path is known.
+* This avoids consuming insertion state too early.
+*/
+function captureHydrationCursor() {
+	return {
+		start: null,
+		resume: insertionParent ? currentHydrationNode : void 0
+	};
+}
+function exitHydrationCursor(cursor) {
+	if (cursor && cursor.resume !== void 0) setCurrentHydrationNode(cursor.resume);
 }
 /**
 * Locate the first non-fragment-comment node and locate the next node
@@ -220,10 +242,19 @@ function removeHydrationNode(node, close = null) {
 	}
 	remove(node, parent);
 }
-function cleanupHydrationTail(node) {
-	const container = node.parentElement;
-	if (container) warnHydrationChildrenMismatch(container);
-	removeHydrationNode(node);
+function cleanupHydrationTail(node, container) {
+	const mismatchContainer = container || node.parentElement;
+	if (mismatchContainer instanceof Element) warnHydrationChildrenMismatch(mismatchContainer);
+	if (!container) {
+		removeHydrationNode(node);
+		return;
+	}
+	let current = node;
+	while (current && current.parentNode === container) {
+		const next = locateNextNode(current);
+		removeHydrationNode(current);
+		current = next;
+	}
 }
 function markHydrationAnchor(node) {
 	node.$vha = 1;
@@ -314,8 +345,8 @@ function child(node, logicalIndex) {
 	return /* @__PURE__ */ _child(node);
 }
 /* @__NO_SIDE_EFFECTS__ */
-function nthChild(node, i) {
-	if (isHydrating$1) return locateChildByLogicalIndex(node, i);
+function nthChild(node, i, logicalIndex = i) {
+	if (isHydrating$1) return locateChildByLogicalIndex(node, logicalIndex);
 	return node.childNodes[i];
 }
 /* @__NO_SIDE_EFFECTS__ */
@@ -628,11 +659,18 @@ function setHtmlToBlock(block, value) {
 function setDynamicProps(el, args, isSVG) {
 	const props = args.length > 1 ? mergeProps(...args) : args[0];
 	const cacheKey = `$dprops${isApplyingFallthroughProps ? "$" : ""}`;
-	const prevKeys = el[cacheKey];
-	if (prevKeys) {
-		for (const key of prevKeys) if (!(key in props)) setDynamicProp(el, key, null, isSVG);
+	const prevProps = el[cacheKey];
+	const nextProps = Object.create(null);
+	if (prevProps) {
+		for (const key in prevProps) if (!(key in props)) setDynamicProp(el, key, null, isSVG);
+	}
+	for (const key of Object.keys(props)) {
+		const value = props[key];
+		nextProps[key] = value;
+		if (prevProps && key in prevProps && !isOn(key) && (value == null || typeof value !== "object") && Object.is(prevProps[key], value)) continue;
+		setDynamicProp(el, key, value, isSVG);
 	}
-	for (const key of el[cacheKey] = Object.keys(props)) setDynamicProp(el, key, props[key], isSVG);
+	el[cacheKey] = nextProps;
 }
 /**
 * @internal
@@ -734,17 +772,17 @@ function shouldForceHydrate(el, key) {
 }
 //#endregion
 //#region packages/runtime-vapor/src/transition.ts
-let _applyTransitionHooks;
-let _applyTransitionLeaveHooks;
+let applyTransitionHooks;
+let applyTransitionLeaveHooks;
+let isTransitionEnabled = false;
 function registerTransitionHooks(applyHooks, applyLeaveHooks) {
-	_applyTransitionHooks = applyHooks;
-	_applyTransitionLeaveHooks = applyLeaveHooks;
+	isTransitionEnabled = true;
+	applyTransitionHooks = applyHooks;
+	applyTransitionLeaveHooks = applyLeaveHooks;
 }
-function applyTransitionHooks(block, hooks) {
-	return _applyTransitionHooks ? _applyTransitionHooks(block, hooks) : hooks;
-}
-function applyTransitionLeaveHooks(block, enterHooks, afterLeaveCb) {
-	_applyTransitionLeaveHooks && _applyTransitionLeaveHooks(block, enterHooks, afterLeaveCb);
+const displayName = "VaporTransition";
+function isVaporTransition(component) {
+	return getComponentName(component) === displayName;
 }
 //#endregion
 //#region packages/runtime-vapor/src/directives/vShow.ts
@@ -822,7 +860,6 @@ function setInteropEnabled() {
 }
 //#endregion
 //#region packages/runtime-vapor/src/components/Transition.ts
-const displayName = "VaporTransition";
 let registered = false;
 const ensureTransitionHooksRegistered = () => {
 	if (!registered) {
@@ -1037,7 +1074,7 @@ function resolveTransitionBlock(block, onFragment) {
 		}
 	}
 	else {
-		if (getComponentName(block.type) === displayName) return void 0;
+		if (getComponentName(block.type) === "VaporTransition") return void 0;
 		child = resolveTransitionBlock(block.block, onFragment);
 		if (child) {
 			if (child.$key == null) {
@@ -1144,8 +1181,17 @@ function unsetRef(el) {
 	if (c) c.fn();
 }
 //#endregion
-//#region packages/runtime-vapor/src/components/KeepAlive.ts
+//#region packages/runtime-vapor/src/keepAlive.ts
+let isKeepAliveEnabled = false;
 let currentKeepAliveCtx = null;
+let currentCacheKey;
+function enableKeepAlive() {
+	isKeepAliveEnabled = true;
+}
+function withKeepAliveEnabled(value) {
+	enableKeepAlive();
+	return value;
+}
 function setCurrentKeepAliveCtx(ctx) {
 	try {
 		return currentKeepAliveCtx;
@@ -1153,7 +1199,6 @@ function setCurrentKeepAliveCtx(ctx) {
 		currentKeepAliveCtx = ctx;
 	}
 }
-let currentCacheKey;
 function withCurrentCacheKey(key, fn) {
 	const prev = currentCacheKey;
 	currentCacheKey = key;
@@ -1163,7 +1208,7 @@ function withCurrentCacheKey(key, fn) {
 		currentCacheKey = prev;
 	}
 }
-const VaporKeepAlive = /* @__PURE__ */ defineVaporComponent({
+const VaporKeepAlive = /* @__PURE__ */ withKeepAliveEnabled(/* @__PURE__ */ defineVaporComponent({
 	name: "VaporKeepAlive",
 	__isKeepAlive: true,
 	props: {
@@ -1206,7 +1251,13 @@ const VaporKeepAlive = /* @__PURE__ */ defineVaporComponent({
 			const rerender = keepAliveInstance.hmrRerender;
 			keepAliveInstance.hmrRerender = () => {
 				keepAliveInstance.exposed = null;
-				cache.forEach((cached) => unsetShapeFlag(cached));
+				cache.forEach((cached) => {
+					unsetShapeFlag(cached);
+					if (cached !== current) {
+						const parentNode = findBlockNode(cached).parentNode;
+						if (parentNode) remove(cached, parentNode);
+					}
+				});
 				cache.clear();
 				keys.clear();
 				keptAliveScopes.forEach((scope) => scope.stop());
@@ -1373,7 +1424,7 @@ const VaporKeepAlive = /* @__PURE__ */ defineVaporComponent({
 		}
 		return children;
 	}
-});
+}));
 const shouldCache = (block, props, interop = false) => {
 	const isAsync = isAsyncWrapper(interop ? block.vnode : block);
 	const type = interop && isInteropEnabled ? block.vnode.type : block.type;
@@ -1437,8 +1488,12 @@ function deactivate$1(instance, container) {
 	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) devtoolsComponentAdded(instance);
 }
 //#endregion
-//#region packages/runtime-vapor/src/components/Suspense.ts
+//#region packages/runtime-vapor/src/suspense.ts
+let isSuspenseEnabled = false;
 let parentSuspense = null;
+function enableSuspense() {
+	isSuspenseEnabled = true;
+}
 function setParentSuspense(suspense) {
 	try {
 		return parentSuspense;
@@ -1467,16 +1522,22 @@ const vaporInteropImpl = {
 		const propsRef = shallowRef(filterReservedProps(vnode.props));
 		const slotsRef = shallowRef(vnode.children);
 		let prevSuspense = null;
-		if (parentSuspense) prevSuspense = setParentSuspense(parentSuspense);
+		if (isSuspenseEnabled && parentSuspense) prevSuspense = setParentSuspense(parentSuspense);
 		const dynamicPropSource = [() => propsRef.value];
 		dynamicPropSource[interopKey] = true;
 		const instance = vnode.component = createComponent(vnode.type, { $: dynamicPropSource }, { _: slotsRef }, void 0, void 0, parentComponent ? parentComponent.appContext : vnode.appContext, true);
 		instance.rawPropsRef = propsRef;
 		instance.rawSlotsRef = slotsRef;
 		ensureVNodeHookState(instance, vnode);
-		if (parentComponent && isKeepAlive(parentComponent)) instance.shapeFlag = vnode.shapeFlag;
-		if (vnode.transition) setTransitionHooks$1(instance, vnode.transition);
-		if (parentSuspense) setParentSuspense(prevSuspense);
+		if (parentComponent && isKeepAlive(parentComponent)) {
+			enableKeepAlive();
+			instance.shapeFlag = vnode.shapeFlag;
+		}
+		if (vnode.transition) {
+			ensureTransitionHooksRegistered();
+			setTransitionHooks$1(instance, vnode.transition);
+		}
+		if (isSuspenseEnabled && parentSuspense) setParentSuspense(prevSuspense);
 		const rootEl = getRootElement(instance);
 		if (rootEl) vnode.el = rootEl;
 		onVnodeBeforeMount && onVnodeBeforeMount();
@@ -1513,24 +1574,47 @@ const vaporInteropImpl = {
 	unmount(vnode, doRemove) {
 		const container = doRemove ? vnode.anchor.parentNode : void 0;
 		const instance = vnode.component;
+		let slotStartAnchor = null;
 		if (instance) {
-			if (instance.block) unmountComponent(instance, container);
+			if (instance.block) {
+				const anchor = vnode.anchor;
+				unmountComponent(instance, container);
+				if (!doRemove) {
+					const blockContainer = shouldUseCurrentParent(instance.block) ? anchor && anchor.parentNode : void 0;
+					remove(instance.block, blockContainer);
+				}
+			}
 		} else if (vnode.vb) {
-			remove(vnode.vb, container);
+			const anchor = vnode.anchor;
+			if (vnode.el && vnode.el !== anchor && isComment(vnode.el, "[")) slotStartAnchor = vnode.el;
+			const blockContainer = container || (shouldUseCurrentParent(vnode.vb) ? anchor && anchor.parentNode : void 0);
+			remove(vnode.vb, blockContainer);
 			stopVaporSlotScope(vnode);
 		}
-		remove(vnode.anchor, container);
+		if (doRemove) {
+			if (slotStartAnchor) {
+				const parent = slotStartAnchor.parentNode;
+				if (parent) remove(slotStartAnchor, parent);
+			}
+			const anchor = vnode.anchor;
+			const parent = anchor.parentNode;
+			if (parent) remove(anchor, parent);
+		}
 	},
+	/**
+	* vapor slot in vdom
+	*/
 	slot(n1, n2, container, anchor, parentComponent, parentSuspense) {
 		if (!n1) {
 			const slotBlock = renderVaporSlot(n2, parentComponent, parentSuspense);
 			const selfAnchor = (isFragment(slotBlock) ? slotBlock.anchor : void 0) || /* @__PURE__ */ createTextNode();
 			insert(n2.el = n2.anchor = selfAnchor, container, anchor);
 			insert(n2.vb = slotBlock, container, selfAnchor);
-		} else if (n2.vs.slot !== n1.vs.slot) {
+		} else if (!n1.vs || !n2.vs || !n1.vs.slot || !n2.vs.slot || n2.vs.slot !== n1.vs.slot) {
 			const selfAnchor = n1.anchor;
 			const parent = selfAnchor.parentNode;
 			const nextSibling = selfAnchor.nextSibling;
+			const rangeStartAnchor = n1.el && n1.el !== selfAnchor && isComment(n1.el, "[") ? n1.el : void 0;
 			const oldBlockOwnsAnchor = isFragment(n1.vb) && n1.vb.anchor === selfAnchor;
 			remove(n1.vb, parent);
 			stopVaporSlotScope(n1);
@@ -1544,16 +1628,22 @@ const vaporInteropImpl = {
 				newAnchor = selfAnchor;
 				insertAnchor = selfAnchor;
 			}
-			insert(n2.el = n2.anchor = newAnchor, parent, insertAnchor);
+			insert(n2.anchor = newAnchor, parent, insertAnchor);
+			n2.el = rangeStartAnchor || newAnchor;
 			insert(n2.vb = slotBlock, parent, newAnchor);
 		} else {
-			n2.el = n2.anchor = n1.anchor;
+			const vs1 = n1.vs;
+			const vs2 = n2.vs;
+			n2.el = n1.el;
+			n2.anchor = n1.anchor;
 			n2.vb = n1.vb;
-			(n2.vs.ref = n1.vs.ref).value = n2.props;
-			n2.vs.scope = n1.vs.scope;
+			(vs2.ref = vs1.ref).value = n2.props;
+			vs2.scope = vs1.scope;
+			syncInteropVaporSlotState(n1, n2);
 		}
 	},
 	move(vnode, container, anchor, moveType) {
+		if (vnode.el && vnode.el !== vnode.anchor && isComment(vnode.el, "[")) move(vnode.el, container, anchor, moveType);
 		move(vnode.vb || vnode.component, container, anchor, moveType);
 		move(vnode.anchor, container, anchor, moveType);
 	},
@@ -1566,12 +1656,17 @@ const vaporInteropImpl = {
 		if (!isHydrating$1 && !isHydrating) return node;
 		hydrateNode(node, () => {
 			vnode.vb = renderVaporSlot(vnode, parentComponent, parentSuspense);
-			vnode.anchor = vnode.el = isFragment(vnode.vb) && vnode.vb.anchor ? vnode.vb.anchor : currentHydrationNode;
+			const anchor = isFragment(vnode.vb) && vnode.vb.anchor ? vnode.vb.anchor : currentHydrationNode;
+			if (isComment(node, "[") && isComment(anchor, "]")) {
+				vnode.el = node;
+				vnode.anchor = anchor;
+			} else vnode.anchor = vnode.el = anchor;
 			if (!!(process.env.NODE_ENV !== "production") && !vnode.anchor) throw new Error(`Failed to locate slot anchor. this is likely a Vue internal bug.`);
 		});
 		return isComment(node, "[") ? vnode.anchor.nextSibling : vnode.anchor;
 	},
 	setTransitionHooks(component, hooks) {
+		ensureTransitionHooksRegistered();
 		setTransitionHooks$1(component, hooks);
 	},
 	activate(vnode, container, anchor, parentComponent) {
@@ -1660,13 +1755,16 @@ function resolveVNodeRange(vnode) {
 	const { type, shapeFlag, el, anchor } = vnode;
 	if (shapeFlag & 64 && el && anchor && anchor !== el) return [el, anchor];
 	if ((type === Static || type === Fragment) && el && anchor && anchor !== el) return [el, anchor];
-	if (!(shapeFlag & 6)) return;
-	const subTree = vnode.component && vnode.component.subTree;
-	const subEl = subTree && subTree.el;
-	const subAnchor = subTree && subTree.anchor;
-	if (subTree && (subTree.type === Static || subTree.type === Fragment) && subEl && subAnchor && subAnchor !== subEl) return [subEl, subAnchor];
+	if (shapeFlag & 6) {
+		const subTree = vnode.component && vnode.component.subTree;
+		if (subTree) return resolveVNodeRange(subTree);
+	}
 }
 function resolveVNodeNodes(vnode) {
+	if (!isHydrating$1 && vnode.component && isVaporComponent(vnode.component)) {
+		const block = vnode.component.block;
+		if (block) return block;
+	}
 	const vnodeRange = resolveVNodeRange(vnode);
 	if (vnodeRange) {
 		const nodeRange = [];
@@ -1678,8 +1776,17 @@ function resolveVNodeNodes(vnode) {
 		}
 		return nodeRange;
 	}
+	if (vnode.shapeFlag & 6) {
+		const subTree = vnode.component && vnode.component.subTree;
+		if (subTree) return resolveVNodeNodes(subTree);
+	}
 	return vnode.el;
 }
+function removeAttachedNodes(block, parent) {
+	if (block instanceof Node) {
+		if (block.parentNode === parent) remove(block, parent);
+	} else if (isArray(block)) for (let i = 0; i < block.length; i++) removeAttachedNodes(block[i], parent);
+}
 function appendVnodeUpdatedHook(vnode, hook) {
 	const props = vnode.props || (vnode.props = {});
 	const existing = props.onVnodeUpdated;
@@ -1688,6 +1795,7 @@ function appendVnodeUpdatedHook(vnode, hook) {
 function trackFragmentVNodeUpdates(frag, vnode) {
 	const refresh = () => {
 		frag.nodes = resolveVNodeNodes(vnode);
+		frag.validityPending = false;
 		if (frag.onUpdated) frag.onUpdated.forEach((m) => m());
 	};
 	appendVnodeUpdatedHook(vnode, refresh);
@@ -1698,6 +1806,7 @@ function trackFragmentVNodeUpdates(frag, vnode) {
 function mountVNode(internals, vnode, parentComponent) {
 	const suspense = parentSuspense || parentComponent && parentComponent.suspense;
 	const frag = new VaporFragment([]);
+	frag.validityPending = !isHydrating$1;
 	frag.vnode = vnode;
 	frag.$key = vnode.key;
 	trackFragmentVNodeUpdates(frag, vnode);
@@ -1714,6 +1823,7 @@ function mountVNode(internals, vnode, parentComponent) {
 		onScopeDispose(unmount, true);
 		isMounted = true;
 		frag.nodes = resolveVNodeNodes(vnode);
+		frag.validityPending = false;
 	};
 	frag.insert = (parentNode, anchor, transition) => {
 		if (isHydrating$1) return;
@@ -1733,6 +1843,7 @@ function mountVNode(internals, vnode, parentComponent) {
 			simpleSetCurrentInstance(prev);
 		}
 		frag.nodes = resolveVNodeNodes(vnode);
+		frag.validityPending = false;
 		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
 	};
 	frag.remove = unmount;
@@ -1746,10 +1857,11 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 	const useBridge = shouldUseRendererBridge(component);
 	const comp = useBridge ? ensureRendererBridge(component) : component;
 	const frag = new VaporFragment([]);
+	frag.validityPending = !isHydrating$1;
 	const vnode = frag.vnode = createVNode(comp, rawProps && extend({}, new Proxy(rawProps, rawPropsProxyHandlers)));
 	frag.$key = vnode.key;
 	trackFragmentVNodeUpdates(frag, vnode);
-	if (currentKeepAliveCtx) {
+	if (isKeepAliveEnabled && currentKeepAliveCtx) {
 		currentKeepAliveCtx.processShapeFlag(frag);
 		if (component.__asyncLoader) {
 			const keepAliveCtx = currentKeepAliveCtx;
@@ -1788,21 +1900,35 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 	};
 	let rawRef = null;
 	let isMounted = false;
+	let isUnmounted = false;
+	let isDomRemoved = false;
+	const removeDom = (parentNode) => {
+		if (!parentNode || isDomRemoved) return;
+		removeAttachedNodes(resolveVNodeNodes(vnode), parentNode);
+		isDomRemoved = true;
+	};
 	const unmount = (parentNode, transition) => {
+		if (isUnmounted) {
+			if (!transition) removeDom(parentNode);
+			return;
+		}
 		if (rawRef) setRef(rawRef, null, null, vnode, true);
 		if (transition) setTransitionHooks(vnode, transition);
 		if (vnode.shapeFlag & 256) {
 			deactivate(vnode, parentComponent.ctx.getStorageContainer(), internals, parentComponent, null);
 			return;
 		}
+		isUnmounted = true;
+		isMounted = false;
 		internals.umt(vnode.component, null, !!parentNode);
+		if (!transition) removeDom(parentNode);
 	};
 	frag.hydrate = () => {
 		if (!isHydrating$1) return;
 		hydrateVNode(vnode, parentComponent);
-		onScopeDispose(unmount, true);
 		isMounted = true;
 		frag.nodes = resolveVNodeNodes(vnode);
+		frag.validityPending = false;
 	};
 	vnode.scopeId = getCurrentScopeId() || null;
 	vnode.slotScopeIds = currentSlotScopeIds;
@@ -1816,12 +1942,12 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 				if (transition) setTransitionHooks(vnode, transition);
 				internals.mt(vnode, parentNode, anchor, parentComponent, suspense, void 0, false);
 				if (rawRef) setRef(rawRef, null, null, vnode);
-				onScopeDispose(unmount, true);
 				isMounted = true;
 			} else internals.m(vnode, parentNode, anchor, 2, parentComponent);
 			simpleSetCurrentInstance(prev);
 		}
 		frag.nodes = resolveVNodeNodes(vnode);
+		frag.validityPending = false;
 		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
 	};
 	frag.remove = unmount;
@@ -1856,12 +1982,52 @@ function ensureRendererBridge(component) {
 	return bridge;
 }
 function trackSlotVNodeUpdates(frag, vnode) {
-	const refresh = () => {
+	trackSlotVNodeUpdatesWithRefresh(vnode, () => {
 		frag.nodes = resolveVNodeNodes(vnode);
 		if (frag.onUpdated) frag.onUpdated.forEach((m) => m());
-	};
+	});
+}
+function hasValidVNodeContent(vnode) {
+	return !!ensureValidVNode(vnode.type === Fragment && isArray(vnode.children) ? vnode.children : [vnode]);
+}
+function isSlotOutletOnlyVNode(vnode) {
+	if (vnode.type === VaporSlot) return true;
+	return vnode.type === Fragment && isArray(vnode.children) && vnode.children.every((child) => isVNode(child) && isSlotOutletOnlyVNode(child));
+}
+function hydrateForwardedEmptySlotFragment(vnode, parentComponent) {
+	if (vnode.type !== Fragment || !isArray(vnode.children)) return false;
+	const children = vnode.children;
+	const inheritedEmptySlotEndAnchor = isComment(currentHydrationNode, "]") && isComment(currentHydrationNode.previousSibling, "[") ? currentHydrationNode : null;
+	const slotEndAnchor = getCurrentSlotEndAnchor() || inheritedEmptySlotEndAnchor;
+	const slotStartAnchor = slotEndAnchor && slotEndAnchor.previousSibling;
+	const contentValid = hasValidVNodeContent(vnode);
+	if (!contentValid && currentHydrationNode === slotEndAnchor && slotStartAnchor && isComment(slotStartAnchor, "[")) {
+		vnode.el = slotStartAnchor;
+		vnode.anchor = slotEndAnchor;
+		advanceHydrationNode(slotEndAnchor);
+		return true;
+	}
+	const isEmptyFragmentStart = isComment(currentHydrationNode, "[");
+	const hasSlotOutletChildren = children.length > 0;
+	const slotOutletOnlyChildren = children.every((child) => isVNode(child) && isSlotOutletOnlyVNode(child));
+	if (!isEmptyFragmentStart || !contentValid || !hasSlotOutletChildren || !slotOutletOnlyChildren) return false;
+	const fragmentStartAnchor = currentHydrationNode;
+	const fragmentEndAnchor = locateEndAnchor(fragmentStartAnchor);
+	if (!fragmentEndAnchor || fragmentStartAnchor.nextSibling !== fragmentEndAnchor) return false;
+	vnode.el = fragmentStartAnchor;
+	withHydratingSlotBoundary(() => {
+		children.forEach((child) => {
+			hydrateVNode(child, parentComponent);
+		});
+	});
+	vnode.anchor = fragmentEndAnchor;
+	if (currentHydrationNode === fragmentEndAnchor) advanceHydrationNode(fragmentEndAnchor);
+	return true;
+}
+function trackSlotVNodeUpdatesWithRefresh(vnode, refresh) {
+	const onUpdated = () => refresh();
 	const track = (node) => {
-		appendVnodeUpdatedHook(node, refresh);
+		appendVnodeUpdatedHook(node, onUpdated);
 		if (node.type === Fragment && isArray(node.children)) node.children.forEach((child) => {
 			if (isVNode(child)) track(child);
 		});
@@ -1874,117 +2040,157 @@ function trackSlotVNodeUpdates(frag, vnode) {
 function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallback) {
 	const suspense = parentSuspense || parentComponent.suspense;
 	const frag = new VaporFragment([]);
+	trackSlotBoundaryDirtying(frag);
+	frag.validityPending = !isHydrating$1;
 	const instance = currentInstance;
-	const slotOwner = currentSlotOwner;
-	if (fallback && !frag.fallback) frag.fallback = fallback;
 	let isMounted = false;
-	let currentBlock = null;
-	let currentVNode = null;
+	const contentState = {
+		nodes: [],
+		valid: false,
+		rendered: null
+	};
 	let currentParentNode;
 	let currentAnchor;
-	let scope = effectScope();
+	let disposed = false;
+	const scope = effectScope();
+	const inheritedBoundary = frag.inheritedSlotBoundary;
+	const controller = new SlotFallbackController({
+		getParentBoundary: () => inheritedBoundary,
+		getLocalFallback: () => wrappedLocalFallback,
+		getContent: () => contentState.nodes,
+		getParentNode: () => {
+			if (currentParentNode) return currentParentNode;
+			const carrierAnchor = findFirstSlotFallbackCarrierNode(contentState.nodes);
+			return carrierAnchor ? carrierAnchor.parentNode : null;
+		},
+		getAnchor: () => currentAnchor || null,
+		isContentValid: () => contentState.valid,
+		runWithRenderCtx: (fn) => runWithFragmentRenderCtx(frag, fn),
+		isDisposed: () => disposed,
+		onValidityChange: () => {}
+	});
+	const wrappedLocalFallback = fallback ? controller.wrapFallback(() => fallback(internals, parentComponent)) : void 0;
+	const updateNodes = () => {
+		frag.nodes = controller.getEffectiveOutput();
+	};
+	const setRenderedContent = (rendered) => {
+		contentState.rendered = rendered;
+		if (isVNode(rendered)) {
+			contentState.nodes = resolveVNodeNodes(rendered);
+			contentState.valid = hasValidVNodeContent(rendered);
+		} else if (rendered) {
+			contentState.nodes = rendered;
+			contentState.valid = isValidBlock(rendered);
+		} else {
+			contentState.nodes = [];
+			contentState.valid = false;
+		}
+		frag.validityPending = false;
+	};
+	const notifyUpdated = () => {
+		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
+	};
+	const finishContentUpdate = (forceFallbackRecheck = false) => {
+		controller.recheck(forceFallbackRecheck);
+		updateNodes();
+		notifyUpdated();
+	};
 	frag.insert = (parentNode, anchor) => {
 		if (isHydrating$1) return;
-		currentParentNode = parentNode;
+		currentParentNode = parentNode || void 0;
 		currentAnchor = anchor;
 		if (!isMounted) {
 			scope.run(render);
 			isMounted = true;
-		} else if (currentVNode) internals.m(currentVNode, parentNode, anchor, 2, parentComponent);
-		else if (currentBlock) insert(currentBlock, parentNode, anchor);
-		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
+		} else {
+			if (isVNode(contentState.rendered)) internals.m(contentState.rendered, parentNode, anchor, 2, parentComponent);
+			else if (contentState.rendered) insert(contentState.rendered, parentNode, anchor);
+			controller.relocate();
+		}
+		notifyUpdated();
 	};
 	frag.remove = (parentNode) => {
+		currentParentNode = parentNode || currentParentNode || void 0;
+		currentAnchor = currentAnchor || null;
 		scope.stop();
-		if (currentBlock) remove(currentBlock, parentNode);
-		else if (currentVNode) internals.um(currentVNode, parentComponent, null, true);
+		disposed = true;
+		if (isVNode(contentState.rendered)) internals.um(contentState.rendered, parentComponent, null, !!parentNode);
+		else if (contentState.rendered) remove(contentState.rendered, parentNode);
+		controller.dispose();
 	};
 	const render = () => {
 		const prev = currentInstance;
 		simpleSetCurrentInstance(instance);
 		try {
 			renderEffect(() => {
-				const prevSlotOwner = setCurrentSlotOwner(slotOwner);
-				try {
-					const effectiveFallback = frag.fallback || fallback;
+				runWithFragmentRenderCtx(frag, () => withOwnedSlotBoundary(controller.boundary, () => {
 					let slotContent;
-					let isEmpty = true;
-					let emptyFrag = null;
+					let slotContentValid = false;
 					if (slotsRef.value) {
 						slotContent = renderSlot(slotsRef.value, isFunction(name) ? name() : name, props);
-						if (isVNode(slotContent)) {
+						if (isVNode(slotContent)) if (slotContent.type === Fragment) {
 							const children = slotContent.children;
-							ensureVaporSlotFallback(children, effectiveFallback);
-							isEmpty = children.length === 0;
-						} else {
-							if (effectiveFallback && slotContent) emptyFrag = attachSlotFallback(slotContent, () => effectiveFallback(internals, parentComponent));
-							isEmpty = !isValidBlock(slotContent);
-						}
+							ensureVaporSlotFallback(children, wrappedLocalFallback);
+							slotContentValid = hasValidVNodeContent(slotContent);
+						} else slotContentValid = true;
+						else if (slotContent) slotContentValid = isValidBlock(slotContent);
 					}
-					let resolved = slotContent;
-					if (isEmpty && effectiveFallback) if (isVNode(slotContent)) resolved = effectiveFallback(internals, parentComponent);
-					else if (slotContent) resolved = renderSlotFallback(slotContent, () => effectiveFallback(internals, parentComponent), emptyFrag);
-					else resolved = effectiveFallback(internals, parentComponent);
 					if (isHydrating$1) {
-						if (isVNode(resolved)) {
-							frag.vnode = resolved;
-							frag.$key = getVNodeKey(resolved);
-							trackSlotVNodeUpdates(frag, resolved);
-							hydrateVNode(resolved, parentComponent);
-							currentVNode = resolved;
-							currentBlock = null;
-							frag.nodes = resolveVNodeNodes(resolved);
-						} else if (resolved) {
-							currentBlock = resolved;
-							currentVNode = null;
-							frag.nodes = resolved;
+						const hydratedContent = slotContent && (slotContentValid || !controller.hasFallback()) ? slotContent : void 0;
+						if (isVNode(hydratedContent)) {
+							frag.vnode = hydratedContent;
+							frag.$key = getVNodeKey(hydratedContent);
+							trackSlotVNodeUpdates(frag, hydratedContent);
+							if (!hydrateForwardedEmptySlotFragment(hydratedContent, parentComponent)) hydrateVNode(hydratedContent, parentComponent);
+							setRenderedContent(hydratedContent);
+						} else if (hydratedContent) {
+							frag.vnode = null;
+							frag.$key = void 0;
+							setRenderedContent(hydratedContent);
 						} else {
-							currentBlock = null;
-							currentVNode = null;
-							frag.nodes = [];
+							frag.vnode = null;
+							frag.$key = void 0;
+							setRenderedContent(null);
 						}
+						finishContentUpdate(true);
 						return;
 					}
-					if (isVNode(resolved)) {
-						frag.vnode = resolved;
-						frag.$key = getVNodeKey(resolved);
-						trackSlotVNodeUpdates(frag, resolved);
-						if (currentBlock) {
-							remove(currentBlock, currentParentNode);
-							currentBlock = null;
-						}
-						internals.p(currentVNode, resolved, currentParentNode, currentAnchor, parentComponent, suspense, void 0, resolved.slotScopeIds);
-						currentVNode = resolved;
-						frag.nodes = resolveVNodeNodes(resolved);
+					if (isVNode(slotContent)) {
+						frag.vnode = slotContent;
+						frag.$key = getVNodeKey(slotContent);
+						trackSlotVNodeUpdatesWithRefresh(slotContent, () => {
+							const prevValid = contentState.valid;
+							const prevOutput = frag.nodes;
+							setRenderedContent(slotContent);
+							controller.recheck();
+							updateNodes();
+							if (contentState.valid !== prevValid || !isSameResolvedOutput(prevOutput, frag.nodes)) notifyUpdated();
+						});
+						const prevRendered = contentState.rendered;
+						if (prevRendered && !isVNode(prevRendered)) remove(prevRendered, currentParentNode);
+						internals.p(isVNode(prevRendered) ? prevRendered : null, slotContent, currentParentNode, currentAnchor, parentComponent, suspense, void 0, slotContent.slotScopeIds);
+						setRenderedContent(slotContent);
+						finishContentUpdate();
 						return;
 					}
-					if (resolved) {
+					if (slotContent) {
 						frag.vnode = null;
 						frag.$key = void 0;
-						if (currentVNode) {
-							internals.um(currentVNode, parentComponent, null, true);
-							currentVNode = null;
-						}
-						if (currentBlock) remove(currentBlock, currentParentNode);
-						insert(resolved, currentParentNode, currentAnchor);
-						currentBlock = resolved;
-						frag.nodes = resolved;
+						const prevRendered = contentState.rendered;
+						if (isVNode(prevRendered)) internals.um(prevRendered, parentComponent, null, true);
+						else if (prevRendered) remove(prevRendered, currentParentNode);
+						insert(slotContent, currentParentNode, currentAnchor);
+						setRenderedContent(slotContent);
+						finishContentUpdate();
 						return;
 					}
-					if (currentBlock) {
-						remove(currentBlock, currentParentNode);
-						currentBlock = null;
-					}
-					if (currentVNode) {
-						internals.um(currentVNode, parentComponent, null, true);
-						currentVNode = null;
-					}
+					if (isVNode(contentState.rendered)) internals.um(contentState.rendered, parentComponent, null, true);
+					else if (contentState.rendered) remove(contentState.rendered, currentParentNode);
 					frag.vnode = null;
 					frag.$key = void 0;
-					frag.nodes = [];
-				} finally {
-					setCurrentSlotOwner(prevSlotOwner);
-				}
+					setRenderedContent(null);
+					finishContentUpdate();
+				}));
 			});
 		} finally {
 			simpleSetCurrentInstance(prev);
@@ -1999,7 +2205,14 @@ function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallb
 	};
 	return frag;
 }
+function shouldUseCurrentParent(block) {
+	if (isVaporComponent(block)) return isKeepAlive(block) || shouldUseCurrentParent(block.block);
+	if (isArray(block)) return block.some(shouldUseCurrentParent);
+	if (isFragment(block)) return shouldUseCurrentParent(block.nodes);
+	return false;
+}
 const vaporInteropPlugin = (app) => {
+	enableSuspense();
 	setInteropEnabled();
 	const internals = ensureRenderer().internals;
 	app._context.vapor = extend(vaporInteropImpl, {
@@ -2021,40 +2234,188 @@ function hydrateVNode(vnode, parentComponent) {
 	if (nextNode) setCurrentHydrationNode(nextNode);
 	else advanceHydrationNode(node);
 }
-function createVaporFallback(fallback, parentComponent) {
+function createFallback(fallback, parentComponent, isVNodeFallback) {
 	const internals = ensureRenderer().internals;
 	return () => {
-		const block = createFallback(fallback)(internals, parentComponent);
-		if (isHydrating$1 && isFragment(block) && block.hydrate) block.hydrate();
-		return block;
+		if (isVNodeFallback()) {
+			const frag = createVNodeChildrenFragment(internals, () => fallback().map(normalizeVNode), parentComponent);
+			if (isHydrating$1 && frag.hydrate) frag.hydrate();
+			return frag;
+		}
+		return fallback();
 	};
 }
-const createFallback = (fallback) => (internals, parentComponent) => {
-	const fallbackNodes = fallback();
-	if (isArray(fallbackNodes) && fallbackNodes.every(isVNode)) return createVNodeChildrenFragment(internals, () => fallback(), parentComponent);
-	return fallbackNodes;
-};
+const renderEmptyVNodes = () => [];
+function runWithFragmentRenderCtx(fragment, fn) {
+	const prevSlotOwner = setCurrentSlotOwner(fragment.slotOwner);
+	let prevKeepAliveCtx = null;
+	if (isKeepAliveEnabled) prevKeepAliveCtx = setCurrentKeepAliveCtx(fragment.keepAliveCtx || null);
+	try {
+		return withOwnedSlotBoundary(fragment.inheritedSlotBoundary, fn);
+	} finally {
+		if (isKeepAliveEnabled) setCurrentKeepAliveCtx(prevKeepAliveCtx);
+		setCurrentSlotOwner(prevSlotOwner);
+	}
+}
+function composeInteropLocalFallback(localFallback, outletFallback) {
+	if (!localFallback) return outletFallback;
+	if (!outletFallback) return localFallback;
+	return (...args) => {
+		const local = localFallback(...args);
+		if (isValidBlock(local)) return local;
+		const outlet = outletFallback(...args);
+		return resolveSlotFallbackCarrierOwner(local) ? [outlet, local] : outlet;
+	};
+}
+function resolveInteropVaporSlotState(vnode) {
+	const slot = vnode.vs;
+	let state = slot.state;
+	if (!state) {
+		state = {
+			localFallback: shallowRef(slot.fallback),
+			outletFallback: shallowRef(slot.outletFallback)
+		};
+		slot.state = state;
+	}
+	return state;
+}
+function syncInteropVaporSlotState(n1, n2) {
+	const prevState = n1.vs.state;
+	if (!prevState) return;
+	n2.vs.state = prevState;
+	prevState.localFallback.value = n2.vs.fallback;
+	prevState.outletFallback.value = n2.vs.outletFallback;
+}
+function trackInteropFallbackChanges(scope, state, onChange) {
+	if (!scope) return;
+	let trackedLocalFallback;
+	let trackedOutletFallback;
+	let initialized = false;
+	scope.run(() => {
+		renderEffect(() => {
+			const nextLocalFallback = state.localFallback.value;
+			const nextOutletFallback = state.outletFallback.value;
+			if (!initialized) {
+				trackedLocalFallback = nextLocalFallback;
+				trackedOutletFallback = nextOutletFallback;
+				initialized = true;
+				return;
+			}
+			if (trackedLocalFallback === nextLocalFallback && trackedOutletFallback === nextOutletFallback) return;
+			trackedLocalFallback = nextLocalFallback;
+			trackedOutletFallback = nextOutletFallback;
+			onChange();
+		}, true);
+	});
+}
 function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 	const prev = currentInstance;
 	let prevSuspense = null;
 	simpleSetCurrentInstance(parentComponent);
-	if (parentSuspense) prevSuspense = setParentSuspense(parentSuspense);
+	if (isSuspenseEnabled && parentSuspense) prevSuspense = setParentSuspense(parentSuspense);
 	try {
-		const { fallback } = vnode.vs;
-		if (isHydrating$1 && fallback) {
-			const frag = new SlotFragment();
-			frag.updateSlot(() => invokeVaporSlot(vnode), createVaporFallback(fallback, parentComponent));
+		if (!vnode.vs || !vnode.vs.slot) return [];
+		const slotState = resolveInteropVaporSlotState(vnode);
+		const frag = new VaporFragment([]);
+		frag.validityPending = !isHydrating$1;
+		const inheritedBoundary = frag.inheritedSlotBoundary;
+		let contentNodes = [];
+		let isResolvingContent = false;
+		let wrappedLocalFallback;
+		let wrappedOutletFallback;
+		let currentParentNode = null;
+		let currentAnchor = null;
+		let slotScope;
+		let disposed = false;
+		const controller = new SlotFallbackController({
+			getParentBoundary: () => inheritedBoundary,
+			getLocalFallback: () => composeInteropLocalFallback(slotState.localFallback.value ? wrappedLocalFallback : void 0, slotState.outletFallback.value ? wrappedOutletFallback : void 0),
+			getContent: () => contentNodes,
+			getParentNode: () => {
+				if (currentParentNode) return currentParentNode;
+				const carrierAnchor = findFirstSlotFallbackCarrierNode(contentNodes);
+				return carrierAnchor ? carrierAnchor.parentNode : null;
+			},
+			getAnchor: () => currentAnchor,
+			runWithRenderCtx: (fn) => runWithFragmentRenderCtx(frag, fn),
+			isBusy: () => isResolvingContent,
+			isDisposed: () => disposed,
+			syncEffectiveOutput: () => {
+				frag.nodes = controller.getEffectiveOutput();
+				frag.validityPending = false;
+			},
+			onValidityChange: () => {
+				if (inheritedBoundary) inheritedBoundary.markDirty();
+			}
+		});
+		const dispose = (parentNode) => {
+			if (disposed) return;
+			currentParentNode = parentNode || currentParentNode;
+			disposed = true;
+			controller.dispose();
+			slotScope = void 0;
+			currentParentNode = null;
+			currentAnchor = null;
+		};
+		try {
+			wrappedLocalFallback = controller.wrapFallback(createFallback(() => (slotState.localFallback.value || renderEmptyVNodes)(), parentComponent, () => !!slotState.localFallback.value && !!slotState.localFallback.value.__vdom));
+			wrappedOutletFallback = controller.wrapFallback(createFallback(() => (slotState.outletFallback.value || renderEmptyVNodes)(), parentComponent, () => !!slotState.outletFallback.value && !!slotState.outletFallback.value.__vdom));
+			const preferSlotFragmentOwnership = !!slotState.localFallback.value || !!slotState.outletFallback.value;
+			controller.clearPendingRecheck();
+			const finalizeResolvedContent = (resolvedContent) => {
+				if (preferSlotFragmentOwnership && resolvedContent instanceof SlotFragment) return resolvedContent;
+				contentNodes = resolvedContent || [];
+				controller.recheck(controller.takePendingRecheck());
+				return resolvedContent;
+			};
+			let resolvedContent;
+			isResolvingContent = true;
+			try {
+				if (isHydrating$1) resolvedContent = withHydratingSlotBoundary(() => finalizeResolvedContent(runWithFragmentRenderCtx(frag, () => {
+					const renderSlot = () => withOwnedSlotBoundary(controller.boundary, () => invokeVaporSlot(vnode));
+					return controller.hasFallback() ? withHydratingSlotFallbackActive(renderSlot) : renderSlot();
+				})));
+				else resolvedContent = finalizeResolvedContent(runWithFragmentRenderCtx(frag, () => withOwnedSlotBoundary(controller.boundary, () => invokeVaporSlot(vnode))));
+			} finally {
+				isResolvingContent = false;
+			}
+			const nextScope = vnode.vs.scope;
+			if (nextScope && slotScope !== nextScope && !disposed) {
+				slotScope = nextScope;
+				nextScope.run(() => {
+					onScopeDispose(() => dispose(), true);
+				});
+			}
+			if (preferSlotFragmentOwnership && resolvedContent instanceof SlotFragment) {
+				dispose();
+				return resolvedContent;
+			}
+			controller.clearPendingRecheck();
+			frag.insert = (parentNode, anchor) => {
+				currentParentNode = parentNode;
+				currentAnchor = anchor;
+				if (controller.getActiveFallback()) {
+					controller.relocate();
+					mutateSlotFallbackCarrier(contentNodes, (block) => insert(block, parentNode, anchor));
+				} else insert(frag.nodes, parentNode, anchor);
+			};
+			frag.remove = (parentNode) => {
+				if (controller.getActiveFallback()) mutateSlotFallbackCarrier(contentNodes, (block) => remove(block, parentNode));
+				else remove(frag.nodes, parentNode);
+				dispose(parentNode);
+			};
+			trackInteropFallbackChanges(vnode.vs.scope, slotState, () => {
+				controller.recheck(true);
+				controller.syncActiveFallback();
+			});
 			return frag;
+		} catch (e) {
+			dispose();
+			stopVaporSlotScope(vnode);
+			throw e;
 		}
-		if (!fallback) return invokeVaporSlot(vnode);
-		let slotBlock = invokeVaporSlot(vnode);
-		const vaporFallback = createVaporFallback(fallback, parentComponent);
-		if (!slotBlock) return vaporFallback();
-		const emptyFrag = attachSlotFallback(slotBlock, vaporFallback);
-		if (!isValidBlock(slotBlock)) slotBlock = renderSlotFallback(slotBlock, vaporFallback, emptyFrag);
-		return slotBlock;
 	} finally {
-		if (parentSuspense) setParentSuspense(prevSuspense);
+		if (isSuspenseEnabled && parentSuspense) setParentSuspense(prevSuspense);
 		simpleSetCurrentInstance(prev);
 	}
 }
@@ -2118,38 +2479,60 @@ function ensureVNodeHookState(instance, vnode) {
 function createVNodeChildrenFragment(internals, render, parentComponent) {
 	const suspense = parentSuspense || parentComponent && parentComponent.suspense;
 	const frag = new VaporFragment([]);
+	frag.validityPending = !isHydrating$1;
 	let currentVNode = null;
 	let currentChildren = [];
 	let currentParentNode = null;
 	let currentAnchor = null;
 	let isMounted = false;
 	const scope = effectScope();
+	const syncResolvedNodes = (children = currentChildren) => {
+		const prevValid = frag.validityPending ? true : isValidBlock(frag.nodes);
+		if (children.length === 0) frag.nodes = [];
+		else if (children.length === 1) frag.nodes = resolveVNodeNodes(children[0]);
+		else frag.nodes = children.map(resolveVNodeNodes);
+		frag.validityPending = false;
+		return prevValid !== isValidBlock(frag.nodes);
+	};
+	const notifyUpdated = (validityChanged = false) => {
+		if (validityChanged && frag.inheritedSlotBoundary) frag.inheritedSlotBoundary.markDirty();
+		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((hook) => hook());
+	};
 	const renderContent = () => {
 		const prev = currentInstance;
 		simpleSetCurrentInstance(parentComponent);
 		try {
 			renderEffect(() => {
-				const nextChildren = render();
-				if (isHydrating$1) {
-					nextChildren.forEach((vnode) => hydrateVNode(vnode, parentComponent));
-					currentChildren = nextChildren;
-					currentVNode = createVNode(Fragment, null, nextChildren);
-					currentParentNode = currentHydrationNode.parentNode;
-					currentAnchor = currentHydrationNode;
-				} else if (!currentVNode) {
-					currentChildren = nextChildren;
-					currentVNode = createVNode(Fragment, null, nextChildren);
-					if (nextChildren.length) internals.mc(nextChildren, currentParentNode, currentAnchor, parentComponent, suspense, void 0, null, false);
-				} else {
-					const nextVNode = createVNode(Fragment, null, nextChildren);
-					internals.pc(currentVNode, nextVNode, currentParentNode, currentAnchor, parentComponent, suspense, void 0, null, false);
-					currentChildren = nextChildren;
-					currentVNode = nextVNode;
-				}
-				if (currentChildren.length === 0) frag.nodes = [];
-				else if (currentChildren.length === 1) frag.nodes = resolveVNodeNodes(currentChildren[0]);
-				else frag.nodes = currentChildren.map(resolveVNodeNodes);
-				if (isMounted && frag.onUpdated) frag.onUpdated.forEach((hook) => hook());
+				runWithFragmentRenderCtx(frag, () => {
+					const nextChildren = render();
+					if (isHydrating$1) {
+						nextChildren.forEach((vnode) => hydrateVNode(vnode, parentComponent));
+						currentChildren = nextChildren;
+						currentVNode = createVNode(Fragment, null, nextChildren);
+						currentParentNode = currentHydrationNode.parentNode;
+						currentAnchor = currentHydrationNode;
+						if (frag.inheritedSlotBoundary && currentAnchor && isHydrationAnchor(currentAnchor) && currentAnchor !== getCurrentSlotEndAnchor() && currentAnchor.nextSibling) currentAnchor = currentAnchor.nextSibling;
+					} else if (!currentVNode) {
+						currentChildren = nextChildren;
+						currentVNode = createVNode(Fragment, null, nextChildren);
+						trackSlotVNodeUpdatesWithRefresh(currentVNode, () => {
+							notifyUpdated(syncResolvedNodes(nextChildren));
+						});
+						if (nextChildren.length) internals.mc(nextChildren, currentParentNode, currentAnchor, parentComponent, suspense, void 0, null, false);
+					} else {
+						const nextVNode = createVNode(Fragment, null, nextChildren);
+						trackSlotVNodeUpdatesWithRefresh(nextVNode, () => {
+							notifyUpdated(syncResolvedNodes(nextChildren));
+						});
+						internals.pc(currentVNode, nextVNode, currentParentNode, currentAnchor, parentComponent, suspense, void 0, null, false);
+						currentChildren = nextChildren;
+						currentVNode = nextVNode;
+					}
+					const validityChanged = syncResolvedNodes();
+					if (isHydrating$1) {
+						if (isMounted && frag.onUpdated) frag.onUpdated.forEach((hook) => hook());
+					} else notifyUpdated(validityChanged);
+				});
 			});
 		} finally {
 			simpleSetCurrentInstance(prev);
@@ -2179,6 +2562,9 @@ function createVNodeChildrenFragment(internals, render, parentComponent) {
 	};
 	return frag;
 }
+function isSameResolvedOutput(prev, next) {
+	return prev === next || isArray(prev) && isArray(next) && prev.length === next.length && prev.every((node, index) => node === next[index]);
+}
 //#endregion
 //#region packages/runtime-vapor/src/componentEmits.ts
 /**
@@ -2219,10 +2605,10 @@ function resolveFunctionSource(source) {
 	if (source._cache) return source._cache.value;
 	const parent = currentInstance && currentInstance.parent;
 	if (parent) {
-		source._cache = computed(() => {
+		source._cache = computed((oldValue) => {
 			const prev = setCurrentInstance(parent);
 			try {
-				return source();
+				return stabilizeDynamicSourceValue(oldValue, source());
 			} finally {
 				setCurrentInstance(...prev);
 			}
@@ -2232,12 +2618,23 @@ function resolveFunctionSource(source) {
 	}
 	return source();
 }
+function stabilizeDynamicSourceValue(oldValue, value) {
+	if (!isPlainObject(oldValue) || !isPlainObject(value)) return value;
+	const oldKeys = Object.keys(oldValue);
+	const newKeys = Object.keys(value);
+	if (oldKeys.length !== newKeys.length) return value;
+	for (let i = 0; i < newKeys.length; i++) {
+		const key = newKeys[i];
+		if (!hasOwn(oldValue, key) || !Object.is(oldValue[key], value[key])) return value;
+	}
+	return oldValue;
+}
 function getPropsProxyHandlers(comp, once) {
 	if (comp.__propsHandlers) return comp.__propsHandlers;
 	const propsOptions = normalizePropsOptions(comp)[0];
 	const emitsOptions = normalizeEmitsOptions(comp);
 	const isProp = propsOptions ? (key) => isString(key) && hasOwn(propsOptions, camelize(key)) : NO;
-	const isAttr = propsOptions ? (key) => isString(key) && key !== "$" && !isProp(key) && !isEmitListener(emitsOptions, key) : (key) => isString(key);
+	const isAttr = propsOptions || emitsOptions ? (key) => isString(key) && key !== "$" && !isProp(key) && !isEmitListener(emitsOptions, key) : (key) => isString(key);
 	const getProp = (instance, key) => {
 		if (key === "__v_isReactive") return true;
 		if (!isProp(key)) return;
@@ -2567,18 +2964,19 @@ function withVaporCtx(fn) {
 function createSlot(name, rawProps, fallback, noSlotted, once) {
 	const _insertionParent = insertionParent;
 	const _insertionAnchor = insertionAnchor;
-	const _isLastInsertion = isLastInsertion;
 	if (!isHydrating$1) resetInsertionState();
+	let hydrationCursor = null;
 	const instance = getScopeOwner();
 	const rawSlots = instance.rawSlots;
 	const slotProps = rawProps ? new Proxy(rawProps, rawPropsProxyHandlers) : EMPTY_OBJ;
 	let fragment;
 	if (isRef(rawSlots._) && isInteropEnabled) {
-		if (isHydrating$1) locateHydrationNode();
+		if (isHydrating$1) hydrationCursor = enterHydrationCursor();
 		fragment = instance.appContext.vapor.vdomSlot(rawSlots._, name, slotProps, instance, fallback);
 	} else {
-		fragment = new SlotFragment();
-		fragment.forwarded = currentSlotOwner != null && currentSlotOwner !== currentInstance;
+		if (isHydrating$1) hydrationCursor = captureHydrationCursor();
+		const slotFragment = fragment = new SlotFragment();
+		slotFragment.forwarded = currentSlotOwner != null && currentSlotOwner !== currentInstance;
 		const isDynamicName = isFunction(name);
 		const slotScopeIds = [];
 		if (!noSlotted) {
@@ -2592,14 +2990,18 @@ function createSlot(name, rawProps, fallback, noSlotted, once) {
 				renderEffect(() => {
 					setDynamicProps(el, [slotProps, slotName !== "default" ? { name: slotName } : {}]);
 				});
-				if (fallback) insert(fallback(), el);
+				if (fallback) withOwnedSlotBoundary(slotFragment.parentSlotBoundary, () => {
+					const fallbackBlock = fallback();
+					slotFragment.customElementFallback = fallbackBlock;
+					insert(fallbackBlock, el);
+				});
 				fragment.nodes = el;
 				return;
 			}
 			const slot = getSlot(rawSlots, slotName);
 			if (slot) {
 				const boundMap = slot._boundMap || (slot._boundMap = /* @__PURE__ */ new WeakMap());
-				let bound = boundMap.get(fragment);
+				let bound = boundMap.get(slotFragment);
 				if (!bound) {
 					bound = () => {
 						const prevSlotScopeIds = setCurrentSlotScopeIds(slotScopeIds.length > 0 ? slotScopeIds : null);
@@ -2612,10 +3014,10 @@ function createSlot(name, rawProps, fallback, noSlotted, once) {
 							setCurrentSlotScopeIds(prevSlotScopeIds);
 						}
 					};
-					boundMap.set(fragment, bound);
+					boundMap.set(slotFragment, bound);
 				}
-				fragment.updateSlot(bound, fallback);
-			} else fragment.updateSlot(void 0, fallback);
+				slotFragment.updateSlot(bound, fallback);
+			} else slotFragment.updateSlot(void 0, fallback);
 		};
 		if (!once && (isDynamicName || rawSlots.$)) renderEffect(renderSlot);
 		else renderSlot();
@@ -2628,7 +3030,7 @@ function createSlot(name, rawProps, fallback, noSlotted, once) {
 		if (_insertionParent) insert(fragment, _insertionParent, _insertionAnchor);
 	} else {
 		if (fragment.insert) fragment.hydrate();
-		if (_isLastInsertion) advanceHydrationNode(_insertionParent);
+		exitHydrationCursor(hydrationCursor);
 	}
 	return fragment;
 }
@@ -2692,7 +3094,7 @@ function setBlockKey(block, key) {
 	if (block instanceof Node) block.$key = key;
 	else if (isVaporComponent(block)) {
 		block.$key = key;
-		if (block.block) setBlockKey(block.block, key);
+		if ((!isKeepAliveEnabled || !isKeepAlive(block)) && block.block) setBlockKey(block.block, key);
 	} else if (isArray(block)) {
 		if (block.length === 1) setBlockKey(block[0], key);
 	} else {
@@ -2706,24 +3108,32 @@ function setBlockKey(block, key) {
 var VaporFragment = class {
 	constructor(nodes) {
 		this.vnode = null;
+		this.renderInstance = currentInstance;
 		this.slotOwner = currentSlotOwner;
-		this.keepAliveCtx = currentKeepAliveCtx;
+		this.inheritedSlotBoundary = currentSlotBoundary;
 		this.nodes = nodes;
+		if (isKeepAliveEnabled) this.keepAliveCtx = currentKeepAliveCtx;
 	}
-	runWithRenderCtx(fn) {
+	runWithRenderCtx(fn, scope) {
+		const prevInstance = setCurrentInstance(this.renderInstance, scope);
 		const prevSlotOwner = setCurrentSlotOwner(this.slotOwner);
-		const prevKeepAliveCtx = setCurrentKeepAliveCtx(this.keepAliveCtx);
+		let prevKeepAliveCtx = null;
+		if (isKeepAliveEnabled) prevKeepAliveCtx = setCurrentKeepAliveCtx(this.keepAliveCtx || null);
+		const prevBoundary = setCurrentSlotBoundary(this.inheritedSlotBoundary);
 		try {
 			return fn();
 		} finally {
-			setCurrentKeepAliveCtx(prevKeepAliveCtx);
+			setCurrentSlotBoundary(prevBoundary);
+			if (isKeepAliveEnabled) setCurrentKeepAliveCtx(prevKeepAliveCtx);
 			setCurrentSlotOwner(prevSlotOwner);
+			setCurrentInstance(...prevInstance);
 		}
 	}
 };
 var ForFragment = class extends VaporFragment {
 	constructor(nodes) {
 		super(nodes);
+		trackSlotBoundaryDirtying(this);
 	}
 };
 var ForBlock = class extends VaporFragment {
@@ -2741,7 +3151,6 @@ var DynamicFragment = class extends VaporFragment {
 		super([]);
 		this.hydrate = (isEmpty = false, isSlot = false) => {
 			if (!isHydrating$1) return;
-			if (this.isAnchorPending) return;
 			let advanceAfterRestore = null;
 			let exitHydrationBoundary;
 			try {
@@ -2751,6 +3160,40 @@ var DynamicFragment = class extends VaporFragment {
 						advanceHydrationNode(currentHydrationNode);
 						return;
 					}
+					if (this.anchorLabel && currentHydrationNode && isComment(currentHydrationNode, "teleport anchor")) {
+						const parentNode$1 = /* @__PURE__ */ parentNode(currentHydrationNode);
+						const anchor = markHydrationAnchor(currentHydrationNode);
+						if (parentNode$1) {
+							queuePostFlushCb(() => {
+								parentNode$1.insertBefore(this.anchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment(this.anchorLabel) : /* @__PURE__ */ createTextNode()), anchor.parentNode === parentNode$1 ? anchor : null);
+							});
+							return;
+						}
+					}
+					if (!isSlot && this.anchorLabel && currentHydrationNode && !isHydratingSlotFallbackActive() && !isComment(currentHydrationNode, "]")) {
+						const parentNode$3 = /* @__PURE__ */ parentNode(currentHydrationNode);
+						const anchor = locateNextNode(currentHydrationNode);
+						const reusableAnchor = anchor && anchor.nodeType === 8 && isReusableDynamicFragmentAnchor(anchor, this.anchorLabel) && /* @__PURE__ */ parentNode(anchor) ? anchor : null;
+						if (parentNode$3) {
+							this.nodes = [];
+							if (reusableAnchor) {
+								this.anchor = markHydrationAnchor(reusableAnchor);
+								exitHydrationBoundary = enterHydrationBoundary(this.anchor);
+								advanceAfterRestore = this.anchor;
+							} else {
+								if (anchor) exitHydrationBoundary = enterHydrationBoundary(anchor);
+								else {
+									cleanupHydrationTail(currentHydrationNode);
+									setCurrentHydrationNode(null);
+								}
+								queuePostFlushCb(() => {
+									const nextNode = anchor && anchor.parentNode === parentNode$3 ? anchor : null;
+									parentNode$3.insertBefore(this.anchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment(this.anchorLabel) : /* @__PURE__ */ createTextNode()), nextNode);
+								});
+							}
+							return;
+						}
+					}
 				}
 				if (this.anchorLabel && !isValidBlock(this.nodes) && this.nodes instanceof Comment && isReusableDynamicFragmentAnchor(this.nodes, this.anchorLabel) && /* @__PURE__ */ parentNode(this.nodes)) {
 					this.anchor = markHydrationAnchor(this.nodes);
@@ -2762,9 +3205,9 @@ var DynamicFragment = class extends VaporFragment {
 					return;
 				}
 				if (this.anchorLabel && !isValidBlock(this.nodes) && this.nodes instanceof Comment && !/* @__PURE__ */ parentNode(this.nodes) && currentHydrationNode) {
-					const parentNode$2 = /* @__PURE__ */ parentNode(currentHydrationNode);
+					const parentNode$4 = /* @__PURE__ */ parentNode(currentHydrationNode);
 					const nextNode = locateNextNode(currentHydrationNode);
-					if (parentNode$2) {
+					if (parentNode$4) {
 						this.nodes = [];
 						if (nextNode) exitHydrationBoundary = enterHydrationBoundary(nextNode);
 						else {
@@ -2772,18 +3215,20 @@ var DynamicFragment = class extends VaporFragment {
 							setCurrentHydrationNode(null);
 						}
 						queuePostFlushCb(() => {
-							parentNode$2.insertBefore(this.anchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment(this.anchorLabel) : /* @__PURE__ */ createTextNode()), nextNode);
+							parentNode$4.insertBefore(this.anchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment(this.anchorLabel) : /* @__PURE__ */ createTextNode()), nextNode);
 						});
 						return;
 					}
 				}
-				if (this.anchorLabel === "if" && currentSlotEndAnchor) {
-					if (currentEmptyFragment !== void 0 && (!isValidBlock(this.nodes) || currentEmptyFragment === this)) {
-						const endAnchor = currentSlotEndAnchor;
-						this.isAnchorPending = true;
-						queuePostFlushCb(() => endAnchor.parentNode.insertBefore(this.anchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment(this.anchorLabel) : /* @__PURE__ */ createTextNode()), endAnchor));
-						return;
-					}
+				const currentSlotEndAnchor = getCurrentSlotEndAnchor();
+				if (this.anchorLabel === "if" && currentSlotEndAnchor && isHydratingSlotFallbackActive() && !isValidBlock(this.nodes)) {
+					const endAnchor = currentSlotEndAnchor;
+					queuePostFlushCb(() => {
+						const parentNode = endAnchor.parentNode;
+						if (!parentNode) return;
+						parentNode.insertBefore(this.anchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment(this.anchorLabel) : /* @__PURE__ */ createTextNode()), endAnchor);
+					});
+					return;
 				}
 				const forwardedSlot = this.forwarded;
 				const slotAnchor = isSlot ? currentSlotEndAnchor : null;
@@ -2796,20 +3241,23 @@ var DynamicFragment = class extends VaporFragment {
 						return;
 					} else if (!!(process.env.NODE_ENV !== "production")) throw new Error(`Failed to locate ${this.anchorLabel} fragment anchor. this is likely a Vue internal bug.`);
 				}
-				let parentNode$1;
+				let parentNode$2;
 				let nextNode;
 				if (forwardedSlot) {
 					const anchor = markHydrationAnchor(slotAnchor);
-					parentNode$1 = anchor.parentNode;
+					parentNode$2 = anchor.parentNode;
 					nextNode = anchor.nextSibling;
+				} else if (this.anchorLabel === "if" && !isValidBlock(this.nodes) && currentSlotEndAnchor && currentHydrationNode === currentSlotEndAnchor) {
+					parentNode$2 = currentSlotEndAnchor.parentNode;
+					nextNode = currentSlotEndAnchor;
 				} else {
 					const node = findBlockNode(this.nodes);
-					parentNode$1 = node.parentNode;
+					parentNode$2 = node.parentNode;
 					nextNode = node.nextNode;
 				}
 				queuePostFlushCb(() => {
-					const anchor = nextNode && nextNode.parentNode === parentNode$1 ? nextNode : null;
-					parentNode$1.insertBefore(this.anchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment(this.anchorLabel) : /* @__PURE__ */ createTextNode()), anchor);
+					const anchor = nextNode && nextNode.parentNode === parentNode$2 ? nextNode : null;
+					parentNode$2.insertBefore(this.anchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment(this.anchorLabel) : /* @__PURE__ */ createTextNode()), anchor);
 				});
 			} finally {
 				exitHydrationBoundary && exitHydrationBoundary();
@@ -2817,6 +3265,7 @@ var DynamicFragment = class extends VaporFragment {
 			}
 		};
 		this.keyed = keyed;
+		if (isTransitionEnabled && currentInstance && isVaporTransition(currentInstance.type)) this.inTransition = true;
 		if (isHydrating$1) {
 			this.anchorLabel = anchorLabel;
 			if (locate) locateHydrationNode();
@@ -2824,13 +3273,19 @@ var DynamicFragment = class extends VaporFragment {
 			this.anchor = !!(process.env.NODE_ENV !== "production") && anchorLabel ? /* @__PURE__ */ createComment(anchorLabel) : /* @__PURE__ */ createTextNode();
 			if (!!(process.env.NODE_ENV !== "production")) this.anchorLabel = anchorLabel;
 		}
+		this.registerSlotBoundaryDirty();
+	}
+	registerSlotBoundaryDirty() {
+		const boundary = this.inheritedSlotBoundary;
+		if (!boundary) return;
+		(this.onUpdated || (this.onUpdated = [])).push(() => boundary.markDirty());
 	}
 	update(render, key = render) {
 		if (key === this.current) {
 			if (isHydrating$1 && this.anchorLabel !== "slot") this.hydrate(true);
 			return;
 		}
-		const transition = this.$transition;
+		const transition = isTransitionEnabled ? this.$transition : void 0;
 		if (transition && transition.state.isLeaving) {
 			this.current = key;
 			this.pending = {
@@ -2843,14 +3298,18 @@ var DynamicFragment = class extends VaporFragment {
 		const prevSub = setActiveSub();
 		const parent = isHydrating$1 ? null : this.anchor.parentNode;
 		if (this.scope) {
-			let retainScope = false;
-			const keepAliveCtx = this.keepAliveCtx;
-			const cacheKey = keepAliveCtx ? this.keyed ? withCurrentCacheKey(this.current, () => keepAliveCtx.processShapeFlag(this.nodes)) : keepAliveCtx.processShapeFlag(this.nodes) : false;
-			if (cacheKey !== false) {
-				keepAliveCtx.cacheScope(cacheKey, this.current, this.scope);
-				retainScope = true;
-			}
-			if (!retainScope) this.scope.stop();
+			if (isKeepAliveEnabled) {
+				let retainScope = false;
+				const keepAliveCtx = this.keepAliveCtx;
+				if (keepAliveCtx) {
+					const cacheKey = this.keyed ? withCurrentCacheKey(this.current, () => keepAliveCtx.processShapeFlag(this.nodes)) : keepAliveCtx.processShapeFlag(this.nodes);
+					if (cacheKey !== false) {
+						keepAliveCtx.cacheScope(cacheKey, this.current, this.scope);
+						retainScope = true;
+					}
+				}
+				if (!retainScope) this.scope.stop();
+			} else this.scope.stop();
 			const mode = transition && transition.mode;
 			if (mode && (mode !== "in-out" || mode === "in-out" && render) && (mode !== "out-in" || isValidBlock(this.nodes))) {
 				applyTransitionLeaveHooks(this.nodes, transition, () => {
@@ -2873,7 +3332,8 @@ var DynamicFragment = class extends VaporFragment {
 			} else parent && remove(this.nodes, parent);
 		}
 		if (isHydrating$1 && render && this.anchorLabel !== "slot" && !isValidBlock(this.nodes)) {
-			const anchor = this.anchor || (currentHydrationNode === currentSlotEndAnchor ? currentSlotEndAnchor : null);
+			let slotEndAnchor = null;
+			const anchor = this.anchor || (currentHydrationNode === (slotEndAnchor = getCurrentSlotEndAnchor()) ? slotEndAnchor : null);
 			if (anchor) setCurrentHydrationNode(markHydrationAnchor(anchor));
 		}
 		this.renderBranch(render, transition, parent, key);
@@ -2883,7 +3343,7 @@ var DynamicFragment = class extends VaporFragment {
 	renderBranch(render, transition, parent, key) {
 		this.current = key;
 		if (render) {
-			const keepAliveCtx = this.keepAliveCtx;
+			const keepAliveCtx = isKeepAliveEnabled ? this.keepAliveCtx : null;
 			const scope = keepAliveCtx && keepAliveCtx.getScope(this.current);
 			if (scope) this.scope = scope;
 			else this.scope = new EffectScope$1();
@@ -2892,8 +3352,8 @@ var DynamicFragment = class extends VaporFragment {
 					this.nodes = this.runWithRenderCtx(() => this.scope.run(render) || []);
 				} finally {
 					const key = this.keyed ? this.current : this.$key;
-					if (key !== void 0) setBlockKey(this.nodes, key);
-					if (transition) this.$transition = applyTransitionHooks(this.nodes, transition);
+					if (key !== void 0 && (transition || this.inTransition || keepAliveCtx)) setBlockKey(this.nodes, key);
+					if (isTransitionEnabled && transition) this.$transition = applyTransitionHooks(this.nodes, transition);
 					if (keepAliveCtx) keepAliveCtx.processShapeFlag(this.nodes);
 				}
 			};
@@ -2908,461 +3368,438 @@ var DynamicFragment = class extends VaporFragment {
 				}
 				insert(this.nodes, parent, this.anchor);
 				if (keepAliveCtx && transition && transition.mode === "out-in") keepAliveCtx.cacheBlock();
-				if (this.onUpdated) this.onUpdated.forEach((hook) => hook(this.nodes));
 			}
 		} else {
 			this.scope = void 0;
 			this.nodes = [];
 		}
+		if (parent && this.onUpdated) this.onUpdated.forEach((hook) => hook(this.nodes));
 	}
 };
-function isReusableDynamicFragmentAnchor(node, anchorLabel) {
-	return isComment(node, anchorLabel) || isComment(node, "") && (anchorLabel === "dynamic-component" || anchorLabel === "async component" || anchorLabel === "keyed");
+let currentSlotBoundary = null;
+function getCurrentSlotBoundary() {
+	return currentSlotBoundary;
 }
-let currentSlotEndAnchor = null;
-function setCurrentSlotEndAnchor(end) {
+function setCurrentSlotBoundary(b) {
 	try {
-		return currentSlotEndAnchor;
+		return currentSlotBoundary;
 	} finally {
-		currentSlotEndAnchor = end;
+		currentSlotBoundary = b;
 	}
 }
-let currentEmptyFragment;
-var SlotFragment = class extends DynamicFragment {
-	constructor() {
-		super(isHydrating$1 || !!(process.env.NODE_ENV !== "production") ? "slot" : void 0, false, false);
-		this.forwarded = false;
+function withOwnedSlotBoundary(boundary, fn) {
+	const prev = setCurrentSlotBoundary(boundary);
+	try {
+		return fn();
+	} finally {
+		setCurrentSlotBoundary(prev);
 	}
-	updateSlot(render, fallback, key = render || fallback) {
-		let prevEndAnchor = null;
-		let pushedEndAnchor = false;
-		let exitHydrationBoundary;
-		let deferHydrationBoundary = false;
-		if (isHydrating$1) {
-			locateHydrationNode();
-			if (isComment(currentHydrationNode, "[")) {
-				const endAnchor = locateEndAnchor(currentHydrationNode);
-				setCurrentHydrationNode(currentHydrationNode.nextSibling);
-				prevEndAnchor = setCurrentSlotEndAnchor(endAnchor);
-				pushedEndAnchor = true;
-				exitHydrationBoundary = enterHydrationBoundary(endAnchor);
-			}
-		}
-		try {
-			if (!render || !fallback) this.update(render || fallback, key);
-			else {
-				const wrapped = () => {
-					const prev = currentEmptyFragment;
-					if (isHydrating$1) currentEmptyFragment = null;
-					try {
-						let block = render();
-						const emptyFrag = attachSlotFallback(block, fallback);
-						if (!isValidBlock(block)) {
-							if (isHydrating$1 && emptyFrag instanceof DynamicFragment) currentEmptyFragment = emptyFrag;
-							block = renderSlotFallback(block, fallback, emptyFrag);
-						}
-						return block;
-					} finally {
-						if (isHydrating$1) currentEmptyFragment = prev;
-					}
-				};
-				this.update(wrapped, key);
-			}
-			if (isHydrating$1) {
-				this.hydrate(render == null, true);
-				deferHydrationBoundary = !!exitHydrationBoundary && currentEmptyFragment !== void 0 && !isValidBlock(this.nodes);
-			}
-		} finally {
-			if (isHydrating$1) {
-				if (pushedEndAnchor) setCurrentSlotEndAnchor(prevEndAnchor);
-				if (deferHydrationBoundary) this.deferredHydrationBoundary = exitHydrationBoundary;
-				else exitHydrationBoundary && exitHydrationBoundary();
-			}
-		}
+}
+const slotFallbackBoundaryCache = /* @__PURE__ */ new WeakMap();
+function withSlotFallbackBoundary(boundary, fn) {
+	let fallbackBoundary = slotFallbackBoundaryCache.get(boundary);
+	if (!fallbackBoundary) slotFallbackBoundaryCache.set(boundary, fallbackBoundary = {
+		get parent() {
+			return boundary.parent;
+		},
+		getLocalFallback: () => void 0,
+		markDirty: () => boundary.markDirty()
+	});
+	return withOwnedSlotBoundary(fallbackBoundary, fn);
+}
+function trackSlotBoundaryDirtying(fragment) {
+	const boundary = currentSlotBoundary;
+	if (!boundary) return;
+	(fragment.onUpdated || (fragment.onUpdated = [])).push(() => boundary.markDirty());
+}
+function walkSlotFallbackBlock(block, node, fragment) {
+	if (block instanceof Node) return node(block);
+	if (isVaporComponent(block)) return walkSlotFallbackBlock(block.block, node, fragment);
+	if (isArray(block)) {
+		for (const child of block) if (walkSlotFallbackBlock(child, node, fragment)) return true;
+		return false;
 	}
-};
-function isFragment(val) {
-	return val instanceof VaporFragment;
+	return fragment(block, (block) => walkSlotFallbackBlock(block, node, fragment));
 }
-function isDynamicFragment(val) {
-	return val instanceof DynamicFragment;
+function resolveSlotFallbackCarrierOwner(block) {
+	let owner = null;
+	walkSlotFallbackBlock(block, () => false, (block) => {
+		owner = block;
+		return true;
+	});
+	return owner;
 }
-function renderSlotFallback(block, fallback, emptyFragment) {
-	const frag = emptyFragment || findDeepestEmptyFragment(block);
-	if (frag) {
-		if (frag instanceof ForFragment) frag.nodes[0] = [fallback() || []];
-		else if (frag instanceof DynamicFragment) {
-			frag.update(fallback);
-			if (isHydrating$1 && frag instanceof SlotFragment) {
-				const deferredHydrationBoundary = frag.deferredHydrationBoundary;
-				if (deferredHydrationBoundary) {
-					frag.deferredHydrationBoundary = void 0;
-					deferredHydrationBoundary();
-				}
-			}
+function findFirstSlotFallbackCarrierNode(block) {
+	let node = null;
+	walkSlotFallbackBlock(block, (value) => {
+		node = value;
+		return true;
+	}, (block, walk) => {
+		if (walk(block.nodes)) return true;
+		if (block.anchor) {
+			node = block.anchor;
+			return true;
 		}
-		return block;
-	}
-	return fallback();
+		return false;
+	});
+	return node;
 }
-function attachSlotFallback(block, fallback) {
-	const state = { emptyFrag: null };
-	traverseForFallback(block, fallback, state);
-	return state.emptyFrag;
+function collectBlockNodes(block, nodes = [], includeComments = false) {
+	walkSlotFallbackBlock(block, (block) => {
+		if (includeComments || !(block instanceof Comment)) nodes.push(block);
+		return false;
+	}, (block) => {
+		collectBlockNodes(block.nodes, nodes, true);
+		if (block.anchor) nodes.push(block.anchor);
+		return false;
+	});
+	return nodes;
 }
-const slotFallbackState = /* @__PURE__ */ new WeakMap();
-function traverseForFallback(block, fallback, state, forOwner) {
-	if (isVaporComponent(block)) {
-		if (block.block) traverseForFallback(block.block, fallback, state, forOwner);
-		return;
+function mutateSlotFallbackCarrier(block, apply) {
+	walkSlotFallbackBlock(block, (block) => {
+		if (!(block instanceof Comment)) apply(block);
+		return false;
+	}, (block) => {
+		apply(block);
+		return false;
+	});
+}
+function hasSlotFallback(boundary) {
+	while (boundary) {
+		if (boundary.getLocalFallback()) return true;
+		boundary = boundary.parent;
 	}
-	if (isArray(block)) {
-		for (const item of block) traverseForFallback(item, fallback, state, forOwner);
-		return;
+	return false;
+}
+function renderSlotFallback(boundary, ...args) {
+	const [block, hasFallback] = renderSlotFallbackBlock(boundary || null, args);
+	return hasFallback ? block : void 0;
+}
+function renderSlotFallbackBlock(boundary, args) {
+	if (!boundary) return [[], false];
+	const localFallback = boundary.getLocalFallback();
+	if (!localFallback) return renderSlotFallbackBlock(boundary.parent, args);
+	const local = withSlotFallbackBoundary(boundary, () => localFallback(...args));
+	if (isValidBlock(local)) return [local, true];
+	const [inherited] = renderSlotFallbackBlock(boundary.parent, args);
+	return [resolveSlotFallbackCarrierOwner(local) ? [inherited, local] : inherited, true];
+}
+var SlotFallbackController = class {
+	constructor(host) {
+		this.host = host;
+		this.activeFallback = null;
+		this.pendingRecheck = false;
+		this.isRenderingFallback = false;
+		this.rerunRecheckAfterFallbackRender = host.rerunRecheckAfterFallbackRender !== false;
+		this.boundary = {
+			get parent() {
+				return host.getParentBoundary();
+			},
+			getLocalFallback: host.getLocalFallback,
+			markDirty: () => {
+				if (host.isDisposed && host.isDisposed()) return;
+				if (this.isRenderingFallback) {
+					if (isHydrating$1) this.pendingRecheck = true;
+					return;
+				}
+				if (host.isBusy && host.isBusy()) {
+					this.pendingRecheck = true;
+					return;
+				}
+				this.recheck(true);
+			}
+		};
 	}
-	if (block instanceof ForFragment) {
-		block.fallback = chainFallback(block.fallback, fallback);
-		if (!isValidBlock(block.nodes)) state.emptyFrag = block;
-		traverseForFallback(block.nodes, fallback, state, block);
-		return;
+	getEffectiveOutput() {
+		return this.activeFallback || this.host.getContent();
 	}
-	if (block instanceof ForBlock) {
-		traverseForFallback(block.nodes, fallback, state, forOwner);
-		return;
+	getActiveFallback() {
+		return this.activeFallback;
 	}
-	if (block instanceof VaporFragment && block.insert) {
-		block.fallback = chainFallback(block.fallback, fallback);
-		if (!isValidBlock(block.nodes)) state.emptyFrag = block;
-		traverseForFallback(block.nodes, fallback, state, forOwner);
-		return;
+	hasFallback() {
+		return hasSlotFallback(this.boundary);
 	}
-	if (block instanceof DynamicFragment) {
-		let slotState = slotFallbackState.get(block);
-		if (slotState) slotState.fallback = chainFallback(slotState.fallback, fallback);
-		else slotFallbackState.set(block, slotState = {
-			fallback,
-			wrapped: false,
-			forOwner
-		});
-		slotState.forOwner = forOwner || slotState.forOwner;
-		if (!slotState.wrapped) {
-			slotState.wrapped = true;
-			const original = block.update.bind(block);
-			block.update = (render, key) => {
-				original(render, key);
-				const emptyFrag = attachSlotFallback(block.nodes, slotState.fallback);
-				if (render !== slotState.fallback && !isValidBlock(block.nodes) && (!slotState.forOwner || !isValidBlock(slotState.forOwner.nodes))) renderSlotFallback(block, slotState.fallback, emptyFrag);
-			};
-		}
-		if (!isValidBlock(block.nodes)) state.emptyFrag = block;
-		traverseForFallback(block.nodes, fallback, state, forOwner);
+	wrapFallback(fallback) {
+		return (...args) => this.host.runWithRenderCtx(() => withSlotFallbackBoundary(this.boundary, () => fallback(...args)));
 	}
-}
-function findDeepestEmptyFragment(block) {
-	let emptyFrag = null;
-	traverseForEmptyFragment(block, (frag) => emptyFrag = frag);
-	return emptyFrag;
-}
-function traverseForEmptyFragment(block, onFound) {
-	if (isVaporComponent(block)) {
-		if (block.block) traverseForEmptyFragment(block.block, onFound);
-		return;
+	clearPendingRecheck() {
+		this.pendingRecheck = false;
 	}
-	if (isArray(block)) {
-		for (const item of block) traverseForEmptyFragment(item, onFound);
-		return;
+	takePendingRecheck() {
+		const shouldRecheck = this.pendingRecheck;
+		this.pendingRecheck = false;
+		return shouldRecheck;
 	}
-	if (isFragment(block)) {
-		if (!isValidBlock(block.nodes)) onFound(block);
-		traverseForEmptyFragment(block.nodes, onFound);
+	dispose() {
+		this.clearActiveFallback();
+		this.pendingRecheck = false;
 	}
-}
-function chainFallback(existing, next) {
-	if (!existing) return next;
-	return (...args) => {
-		const res = existing(...args);
-		return !isValidBlock(res) ? next(...args) : res;
-	};
-}
-//#endregion
-//#region packages/runtime-vapor/src/components/Teleport.ts
-const VaporTeleportImpl = {
-	name: "VaporTeleport",
-	__isTeleport: true,
-	__vapor: true,
-	process(props, slots) {
-		return new TeleportFragment(props, slots);
+	relocate() {
+		if (isHydrating$1 || !this.activeFallback) return;
+		const parentNode = this.host.getParentNode();
+		if (!parentNode) return;
+		const carrierAnchor = findFirstSlotFallbackCarrierNode(this.host.getContent());
+		insert(this.activeFallback, parentNode, carrierAnchor && carrierAnchor.parentNode === parentNode ? carrierAnchor : this.host.getAnchor());
 	}
-};
-var TeleportFragment = class extends VaporFragment {
-	constructor(props, slots) {
-		super([]);
-		this.__isTeleportFragment = true;
-		this.isMounted = false;
-		this.childrenInitialized = false;
-		this.ownerInstance = currentInstance$1;
-		this.insert = (container, anchor) => {
-			if (isHydrating$1) return;
-			if (!this.placeholder) this.placeholder = !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("teleport start") : /* @__PURE__ */ createTextNode();
-			insert(this.placeholder, container, anchor);
-			insert(this.anchor, container, anchor);
-			this.handlePropsUpdate();
-		};
-		this.remove = (parent = this.parent) => {
-			if (this.mountToTargetJob) {
-				this.mountToTargetJob.flags |= 4;
-				this.mountToTargetJob = void 0;
-			}
-			if (this.nodes && this.mountContainer) {
-				remove(this.nodes, this.mountContainer);
-				this.nodes = [];
-			}
-			this.isMounted = false;
-			if (this.targetStart) {
-				remove(this.targetStart, /* @__PURE__ */ parentNode(this.targetStart));
-				this.targetStart = void 0;
-			}
-			if (this.targetAnchor) {
-				remove(this.targetAnchor, /* @__PURE__ */ parentNode(this.targetAnchor));
-				this.targetAnchor = void 0;
-			}
-			if (this.anchor) {
-				remove(this.anchor, /* @__PURE__ */ parentNode(this.anchor));
-				this.anchor = void 0;
-			}
-			if (this.placeholder) {
-				remove(this.placeholder, parent);
-				this.placeholder = void 0;
-			}
-			this.mountContainer = void 0;
-			this.mountAnchor = void 0;
-		};
-		this.hydrate = () => {
-			if (!isHydrating$1) return;
-			const target = this.target = resolveTeleportTarget(this.resolvedProps, querySelector);
-			const disabled = isTeleportDisabled(this.resolvedProps);
-			this.placeholder = currentHydrationNode;
-			if (target) {
-				const targetNode = target._lpa || target.firstChild;
-				if (disabled) this.hydrateDisabledTeleport(target, targetNode);
-				else {
-					this.anchor = markHydrationAnchor(locateTeleportEndAnchor(currentHydrationNode.nextSibling));
-					this.mountContainer = target;
-					this.hydrateTargetAnchors(target, targetNode);
-					this.mountAnchor = this.targetAnchor;
-					if (targetNode) setCurrentHydrationNode(targetNode.nextSibling);
-					if (!this.targetAnchor) this.mountChildren(target);
-					else this.initChildren();
-				}
-			} else if (disabled) this.hydrateDisabledTeleport(null, null);
-			else this.anchor = markHydrationAnchor(locateTeleportEndAnchor(currentHydrationNode.nextSibling));
-			if (target || disabled) updateCssVars(this);
-			advanceHydrationNode(this.anchor);
-		};
-		this.rawProps = props;
-		this.rawSlots = slots;
-		this.parentComponent = getScopeOwner();
-		this.anchor = isHydrating$1 ? void 0 : !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("teleport end") : /* @__PURE__ */ createTextNode();
-		renderEffect(() => {
-			const prevTo = this.resolvedProps && this.resolvedProps.to;
-			const wasDisabled = this.isDisabled;
-			this.resolvedProps = extend({}, new Proxy(this.rawProps, rawPropsProxyHandlers));
-			this.isDisabled = isTeleportDisabled(this.resolvedProps);
-			if (wasDisabled !== this.isDisabled || !this.isDisabled && prevTo !== this.resolvedProps.to) this.handlePropsUpdate();
+	syncActiveFallback() {
+		if (!this.activeFallback) return;
+		const activeFallback = this.activeFallback;
+		queuePostFlushCb(() => {
+			this.syncActiveFallbackOrder(activeFallback);
 		});
 	}
-	get parent() {
-		return this.anchor ? /* @__PURE__ */ parentNode(this.anchor) : null;
+	recheck(force = false) {
+		const prevValid = this.activeFallback ? isValidBlock(this.activeFallback) : this.isContentValid();
+		if (this.isContentValid()) this.clearActiveFallback();
+		else if (!this.ensureFallback(force)) this.clearActiveFallback();
+		const nextValid = this.activeFallback ? isValidBlock(this.activeFallback) : this.isContentValid();
+		if (this.host.syncEffectiveOutput) this.host.syncEffectiveOutput();
+		if (prevValid !== nextValid) this.host.onValidityChange();
+	}
+	isContentValid() {
+		return this.host.isContentValid ? this.host.isContentValid() : isValidBlock(this.host.getContent());
+	}
+	clearActiveFallback() {
+		if (this.activeFallback) {
+			const parentNode = this.host.getParentNode();
+			if (parentNode) remove(this.activeFallback, parentNode);
+			this.activeFallback = null;
+		}
+		if (this.fallbackScope) {
+			this.fallbackScope.stop();
+			this.fallbackScope = void 0;
+		}
 	}
-	initChildren() {
-		const prevInstance = setCurrentInstance(this.ownerInstance);
+	ensureFallback(force) {
+		if (force) this.clearActiveFallback();
+		if (this.activeFallback) return true;
+		const scope = new EffectScope$1();
+		let renderedFallback;
+		this.isRenderingFallback = true;
 		try {
-			this.childrenInitialized = true;
-			renderEffect(() => this.runWithRenderCtx(() => this.handleChildrenUpdate(this.rawSlots && this.rawSlots.default ? this.rawSlots.default() : [])));
-			this.bindChildren(this.nodes);
+			renderedFallback = this.host.runWithRenderCtx(() => scope.run(() => renderSlotFallback(this.boundary)) || void 0) || void 0;
+		} catch (err) {
+			scope.stop();
+			throw err;
 		} finally {
-			setCurrentInstance(...prevInstance);
+			this.isRenderingFallback = false;
+		}
+		if (!renderedFallback) {
+			scope.stop();
+			return false;
+		}
+		this.fallbackScope = scope;
+		this.activeFallback = renderedFallback;
+		this.ensureActiveFallbackOrderHook(renderedFallback);
+		if (this.pendingRecheck && this.rerunRecheckAfterFallbackRender) {
+			this.pendingRecheck = false;
+			this.recheck(true);
+			return true;
 		}
+		this.relocate();
+		return true;
 	}
-	ensureChildrenInitialized() {
-		if (!this.childrenInitialized) this.initChildren();
+	syncActiveFallbackOrder(block) {
+		if (!isFragment(block) || !isArray(block.nodes) || block.nodes.length < 2) return;
+		const carrierNodes = collectBlockNodes(this.host.getContent(), [], true);
+		const fallbackNodes = collectBlockNodes(block, [], true);
+		const lastNode = fallbackNodes[fallbackNodes.length - 1];
+		if (!carrierNodes.length || !lastNode) return;
+		const parentNode = carrierNodes[0].parentNode;
+		if (!parentNode || lastNode.parentNode !== parentNode) return;
+		let inOrder = true;
+		let nextNode = lastNode.nextSibling;
+		for (const carrierNode of carrierNodes) {
+			if (carrierNode.parentNode !== parentNode) return;
+			if (carrierNode !== nextNode) {
+				inOrder = false;
+				break;
+			}
+			nextNode = carrierNode.nextSibling;
+		}
+		if (inOrder) return;
+		let anchor = lastNode.nextSibling;
+		for (let i = carrierNodes.length - 1; i >= 0; i--) {
+			const carrierNode = carrierNodes[i];
+			parentNode.insertBefore(carrierNode, anchor);
+			anchor = carrierNode;
+		}
 	}
-	registerUpdateCssVars(block) {
-		if (isFragment(block)) {
-			(block.onUpdated || (block.onUpdated = [])).push(() => updateCssVars(this));
-			this.registerUpdateCssVars(block.nodes);
-		} else if (isVaporComponent(block)) this.registerUpdateCssVars(block.block);
-		else if (isArray(block)) block.forEach((node) => this.registerUpdateCssVars(node));
+	ensureActiveFallbackOrderHook(block) {
+		if (!isFragment(block)) return;
+		const fragment = block;
+		if (fragment.hasSlotFallbackOrderHook) return;
+		(fragment.onUpdated || (fragment.onUpdated = [])).push(() => this.syncActiveFallbackOrder(fragment));
+		fragment.hasSlotFallbackOrderHook = true;
 	}
-	bindChildren(block) {
-		if (this.parentComponent && this.parentComponent.ut) this.registerUpdateCssVars(block);
-		if (!!(process.env.NODE_ENV !== "production")) {
-			if (isVaporComponent(block)) block.parentTeleport = this;
-			else if (isArray(block)) block.forEach((node) => isVaporComponent(node) && (node.parentTeleport = this));
-		}
+};
+let currentHydratingSlotBoundaryState = null;
+function setCurrentHydratingSlotBoundaryState(state) {
+	try {
+		return currentHydratingSlotBoundaryState;
+	} finally {
+		currentHydratingSlotBoundaryState = state;
 	}
-	handleChildrenUpdate(children) {
-		if (isHydrating$1 || !this.parent || !this.mountContainer) {
-			this.nodes = children;
-			return;
-		}
-		remove(this.nodes, this.mountContainer);
-		insert(this.nodes = children, this.mountContainer, this.mountAnchor);
-		this.bindChildren(this.nodes);
-		updateCssVars(this);
+}
+function getCurrentSlotEndAnchor() {
+	return currentHydratingSlotBoundaryState ? currentHydratingSlotBoundaryState.endAnchor : null;
+}
+function withHydratingSlotBoundary(fn) {
+	let endAnchor = getCurrentSlotEndAnchor();
+	let exitHydrationBoundary;
+	locateHydrationNode();
+	if (isComment(currentHydrationNode, "[")) {
+		endAnchor = locateEndAnchor(currentHydrationNode);
+		setCurrentHydrationNode(currentHydrationNode.nextSibling);
+		exitHydrationBoundary = enterHydrationBoundary(endAnchor);
+	}
+	const prevState = setCurrentHydratingSlotBoundaryState({
+		endAnchor,
+		fallbackActive: false
+	});
+	try {
+		return fn();
+	} finally {
+		setCurrentHydratingSlotBoundaryState(prevState);
+		exitHydrationBoundary && exitHydrationBoundary();
 	}
-	mount(parent, anchor) {
-		if (this.$transition && !this.isMounted) applyTransitionHooks(this.nodes, this.$transition);
-		if (this.isMounted) move(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor, 2);
-		else {
-			insert(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor);
-			this.isMounted = true;
-		}
-		updateCssVars(this);
+}
+function isHydratingSlotFallbackActive() {
+	return !!(currentHydratingSlotBoundaryState && currentHydratingSlotBoundaryState.fallbackActive);
+}
+function setCurrentHydratingSlotFallbackActive(active) {
+	try {
+		return isHydratingSlotFallbackActive();
+	} finally {
+		if (currentHydratingSlotBoundaryState) currentHydratingSlotBoundaryState.fallbackActive = active;
 	}
-	mountToTarget() {
-		const target = this.target = resolveTeleportTarget(this.resolvedProps, querySelector);
-		if (target) {
-			if (!this.targetAnchor || /* @__PURE__ */ parentNode(this.targetAnchor) !== target) {
-				if (this.targetStart) remove(this.targetStart, /* @__PURE__ */ parentNode(this.targetStart));
-				if (this.targetAnchor) remove(this.targetAnchor, /* @__PURE__ */ parentNode(this.targetAnchor));
-				insert(this.targetStart = /* @__PURE__ */ createTextNode(""), target);
-				insert(this.targetAnchor = /* @__PURE__ */ createTextNode(""), target);
+}
+function withHydratingSlotFallbackActive(fn) {
+	const prevState = setCurrentHydratingSlotFallbackActive(true);
+	try {
+		return fn();
+	} finally {
+		setCurrentHydratingSlotFallbackActive(prevState);
+	}
+}
+function isReusableDynamicFragmentAnchor(node, anchorLabel) {
+	return isComment(node, anchorLabel) || isComment(node, "") && (anchorLabel === "dynamic-component" || anchorLabel === "async component" || anchorLabel === "keyed");
+}
+var SlotFragment = class extends DynamicFragment {
+	constructor() {
+		super(isHydrating$1 || !!(process.env.NODE_ENV !== "production") ? "slot" : void 0, false, false);
+		this.forwarded = false;
+		this.parentSlotBoundary = getCurrentSlotBoundary();
+		this.isUpdatingSlot = false;
+		this.controller = new SlotFallbackController({
+			getParentBoundary: () => this.parentSlotBoundary,
+			getLocalFallback: () => this.localFallback,
+			getContent: () => this.nodes,
+			getParentNode: () => this.anchor ? this.anchor.parentNode : null,
+			getAnchor: () => this.anchor || null,
+			runWithRenderCtx: (fn) => this.runWithRenderCtx(fn),
+			isBusy: () => this.isUpdatingSlot,
+			rerunRecheckAfterFallbackRender: false,
+			onValidityChange: () => {
+				if (this.parentSlotBoundary) this.parentSlotBoundary.markDirty();
 			}
-			this.ensureChildrenInitialized();
-			if (this.parentComponent && this.parentComponent.isCE) (this.parentComponent.ce._teleportTargets || (this.parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
-			this.mount(target, this.targetAnchor);
-		} else if (!!(process.env.NODE_ENV !== "production")) warn(`Invalid Teleport target on ${this.targetAnchor ? "update" : "mount"}:`, target, `(${typeof target})`);
+		});
+		this.slotFallbackBoundary = this.controller.boundary;
+		if (!isHydrating$1) this.insert = (parent, anchor) => this.insertSlot(parent, anchor);
+		this.remove = (parent) => this.removeSlot(parent);
 	}
-	clearMainViewChildren() {
-		if (!this.placeholder || !this.anchor) return;
-		let node = this.placeholder.nextSibling;
-		while (node && node !== this.anchor) {
-			const next = node.nextSibling;
-			remove(node, /* @__PURE__ */ parentNode(node));
-			node = next;
-		}
-		this.isMounted = false;
-		this.mountContainer = null;
+	registerSlotBoundaryDirty() {}
+	get fallbackBlock() {
+		return this.controller.getActiveFallback();
 	}
-	handlePropsUpdate() {
-		if (!this.parent || isHydrating$1) return;
-		if (this.isDisabled) {
-			this.ensureChildrenInitialized();
-			this.mount(this.parent, this.anchor);
-		} else {
-			if (this.placeholder && this.anchor && this.placeholder.nextSibling !== this.anchor) this.clearMainViewChildren();
-			if (isTeleportDeferred(this.resolvedProps) || !this.parent.isConnected) {
-				if (!this.mountToTargetJob || this.mountToTargetJob.flags & 4) this.mountToTargetJob = () => {
-					this.mountToTargetJob = void 0;
-					if (this.isDisabled || !this.anchor) return;
-					this.mountToTarget();
-				};
-				queuePostFlushCb(this.mountToTargetJob);
-			} else this.mountToTarget();
-		}
+	getEffectiveOutput() {
+		return this.controller.getEffectiveOutput();
 	}
-	hydrateTargetAnchors(target, targetNode) {
-		let targetAnchor = targetNode;
-		while (targetAnchor) {
-			if (targetAnchor.nodeType === 8) {
-				if (targetAnchor.data === "teleport start anchor") this.targetStart = targetAnchor;
-				else if (targetAnchor.data === "teleport anchor") {
-					this.targetAnchor = markHydrationAnchor(targetAnchor);
-					target._lpa = this.targetAnchor.nextSibling;
-					break;
-				}
-			}
-			targetAnchor = targetAnchor.nextSibling;
+	insertSlot(parent, anchor) {
+		if (this.fallbackBlock) {
+			insert(this.fallbackBlock, parent, anchor);
+			mutateSlotFallbackCarrier(this.nodes, (block) => insert(block, parent, anchor));
+			return;
 		}
+		insert(this.nodes, parent, anchor);
 	}
-	hydrateDisabledTeleport(target, targetNode) {
-		if (!isHydrating$1) return;
-		let nextNode = this.placeholder.nextSibling;
-		setCurrentHydrationNode(nextNode);
-		this.mountAnchor = this.anchor = markHydrationAnchor(locateTeleportEndAnchor(nextNode));
-		this.mountContainer = /* @__PURE__ */ parentNode(this.anchor);
-		if (target) this.hydrateTargetAnchors(target, targetNode);
-		else {
-			this.targetStart = targetNode;
-			this.targetAnchor = targetNode && targetNode.nextSibling;
-		}
-		this.initChildren();
+	removeSlot(parent) {
+		if (this.fallbackBlock) mutateSlotFallbackCarrier(this.nodes, (block) => remove(block, parent));
+		else remove(this.nodes, parent);
+		this.controller.dispose();
 	}
-	mountChildren(target) {
-		if (!isHydrating$1) return;
-		target.appendChild(this.targetStart = /* @__PURE__ */ createTextNode(""));
-		target.appendChild(this.mountAnchor = this.targetAnchor = markHydrationAnchor(/* @__PURE__ */ createTextNode("")));
-		if (!isMismatchAllowed(target, 1)) {
-			if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_HYDRATION_MISMATCH_DETAILS__) warn(`Hydration children mismatch on`, target, `\nServer rendered element contains fewer child nodes than client nodes.`);
-			logMismatchError();
+	updateSlot(render, fallback, key = render || fallback) {
+		const prevLocalFallback = this.localFallback;
+		this.localFallback = fallback;
+		const fallbackChanged = prevLocalFallback !== fallback;
+		const slotRender = render ? () => withOwnedSlotBoundary(this.slotFallbackBoundary, render) : () => [];
+		const slotKey = key === void 0 ? slotRender : key;
+		this.isUpdatingSlot = true;
+		this.controller.clearPendingRecheck();
+		try {
+			const shouldForce = fallbackChanged || this.controller.takePendingRecheck();
+			if (isHydrating$1) withHydratingSlotBoundary(() => {
+				const prev = isHydratingSlotFallbackActive();
+				try {
+					if (this.controller.hasFallback()) setCurrentHydratingSlotFallbackActive(true);
+					this.update(slotRender, slotKey);
+					const contentValid = isValidBlock(this.nodes);
+					this.controller.recheck(shouldForce);
+					if (!this.controller.hasFallback() || contentValid) setCurrentHydratingSlotFallbackActive(prev);
+					this.hydrate(!isValidBlock(this.getEffectiveOutput()), true);
+				} finally {
+					setCurrentHydratingSlotFallbackActive(prev);
+				}
+			});
+			else {
+				this.update(slotRender, slotKey);
+				this.controller.recheck(shouldForce);
+			}
+		} finally {
+			this.controller.clearPendingRecheck();
+			this.isUpdatingSlot = false;
 		}
-		runWithoutHydration(this.initChildren.bind(this));
 	}
 };
-const VaporTeleport = VaporTeleportImpl;
-/**
-* Use duck typing to check for VaporTeleport instead of direct reference
-* to VaporTeleportImpl, allowing tree-shaking when Teleport is not used.
-*/
+function isFragment(val) {
+	return val instanceof VaporFragment;
+}
+function isDynamicFragment(val) {
+	return val instanceof DynamicFragment;
+}
+//#endregion
+//#region packages/runtime-vapor/src/teleport.ts
+let isTeleportEnabled = false;
+function enableTeleport(value) {
+	isTeleportEnabled = true;
+	return value;
+}
 function isVaporTeleport(value) {
 	return !!(value && value.__isTeleport && value.__vapor);
 }
-/**
-* Use duck typing to check for TeleportFragment instead of instanceof,
-* allowing tree-shaking when Teleport is not used.
-*/
 function isTeleportFragment(value) {
 	return !!(value && value.__isTeleportFragment);
 }
-function locateTeleportEndAnchor(node = currentHydrationNode) {
-	let depth = 0;
-	while (node) {
-		if (isComment(node, "teleport start")) depth++;
-		else if (isComment(node, "teleport end")) if (depth === 0) return node;
-		else depth--;
-		node = node.nextSibling;
-	}
-	return null;
-}
-function updateCssVars(frag) {
-	const ctx = frag.parentComponent;
-	if (ctx && ctx.ut) {
-		let node, anchor;
-		if (frag.isDisabled) {
-			node = frag.placeholder;
-			anchor = frag.anchor;
-		} else {
-			node = frag.targetStart;
-			anchor = frag.targetAnchor;
-		}
-		while (node && node !== anchor) {
-			if (node.nodeType === 1) node.setAttribute("data-v-owner", String(ctx.uid));
-			node = node.nextSibling;
-		}
-		pauseTracking();
-		try {
-			ctx.ut();
-		} finally {
-			resetTracking();
-		}
-	}
-}
-//#endregion
-//#region packages/runtime-vapor/src/block.ts
-function isBlock(val) {
-	return val instanceof Node || isArray(val) || isVaporComponent(val) || isFragment(val);
+//#endregion
+//#region packages/runtime-vapor/src/block.ts
+function isBlock(val) {
+	return val instanceof Node || isArray(val) || isVaporComponent(val) || isFragment(val);
 }
 function isValidBlock(block) {
-	if (block instanceof Node) return !(block instanceof Comment);
+	if (!block) return false;
+	else if (block instanceof Node) return !(block instanceof Comment);
 	else if (isVaporComponent(block)) return isValidBlock(block.block);
 	else if (isArray(block)) return block.length > 0 && block.some(isValidBlock);
-	else return isValidBlock(block.nodes);
+	else if (block.validityPending) return true;
+	else {
+		const getEffectiveOutput = block.getEffectiveOutput;
+		return isValidBlock(getEffectiveOutput ? getEffectiveOutput.call(block) : block.nodes);
+	}
 }
 function insert(block, parent, anchor = null, parentSuspense) {
 	anchor = anchor === 0 ? parent.$fc || /* @__PURE__ */ _child(parent) : anchor;
 	if (block instanceof Node) {
-		if (!isHydrating$1) if (block instanceof Element && block.$transition && !block.$transition.disabled) performTransitionEnter(block, block.$transition, () => parent.insertBefore(block, anchor), parentSuspense);
+		if (!isHydrating$1) if (isTransitionEnabled && block instanceof Element && block.$transition && !block.$transition.disabled) performTransitionEnter(block, block.$transition, () => parent.insertBefore(block, anchor), parentSuspense);
 		else parent.insertBefore(block, anchor);
 	} else if (isVaporComponent(block)) if (block.isMounted && !block.isDeactivated) insert(block.block, parent, anchor);
 	else mountComponent(block, parent, anchor);
@@ -3378,7 +3815,7 @@ function insert(block, parent, anchor = null, parentSuspense) {
 }
 function move(block, parent, anchor = null, moveType = 1, parentComponent, parentSuspense) {
 	anchor = anchor === 0 ? parent.$fc || /* @__PURE__ */ _child(parent) : anchor;
-	if (block instanceof Node) if (block instanceof Element && block.$transition && !block.$transition.disabled && moveType !== 2) if (moveType === 0) performTransitionEnter(block, block.$transition, () => parent.insertBefore(block, anchor), parentSuspense, true);
+	if (block instanceof Node) if (isTransitionEnabled && block instanceof Element && block.$transition && !block.$transition.disabled && moveType !== 2) if (moveType === 0) performTransitionEnter(block, block.$transition, () => parent.insertBefore(block, anchor), parentSuspense, true);
 	else performTransitionLeave(block, block.$transition, () => {
 		if (moveType === 1 && parentComponent && parentComponent.isUnmounted) block.remove();
 		else parent.insertBefore(block, anchor);
@@ -3401,7 +3838,7 @@ function prepend(parent, ...blocks) {
 	while (i--) insert(blocks[i], parent, 0);
 }
 function remove(block, parent) {
-	if (block instanceof Node) if (block.$transition && block instanceof Element) performTransitionLeave(block, block.$transition, () => parent && parent.removeChild(block));
+	if (block instanceof Node) if (isTransitionEnabled && block.$transition && block instanceof Element) performTransitionLeave(block, block.$transition, () => parent && parent.removeChild(block));
 	else parent && parent.removeChild(block);
 	else if (isVaporComponent(block)) unmountComponent(block, parent);
 	else if (isArray(block)) for (let i = 0; i < block.length; i++) remove(block[i], parent);
@@ -3421,7 +3858,7 @@ function normalizeBlock(block) {
 	if (block instanceof Node) nodes.push(block);
 	else if (isArray(block)) block.forEach((child) => nodes.push(...normalizeBlock(child)));
 	else if (isVaporComponent(block)) nodes.push(...normalizeBlock(block.block));
-	else if (isTeleportFragment(block)) nodes.push(block.placeholder, block.anchor);
+	else if (isTeleportEnabled && isTeleportFragment(block)) nodes.push(block.placeholder, block.anchor);
 	else {
 		nodes.push(...normalizeBlock(block.nodes));
 		block.anchor && nodes.push(block.anchor);
@@ -3468,7 +3905,7 @@ function hmrRerender(instance) {
 	insert(instance.block, parent, anchor);
 }
 function hmrReload(instance, newComp) {
-	if (instance.parent && isKeepAlive(instance.parent)) {
+	if (isKeepAliveEnabled && instance.parent && isKeepAlive(instance.parent)) {
 		instance.parent.hmrRerender();
 		return;
 	}
@@ -3528,8 +3965,8 @@ function replaceBlockInstance(block, instance, newInstance) {
 function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appContext = currentInstance && currentInstance.appContext || emptyContext, managedMount = false) {
 	const _insertionParent = insertionParent;
 	const _insertionAnchor = insertionAnchor;
-	const _isLastInsertion = isLastInsertion;
 	let hydrationClose = null;
+	let hydrationCursor = null;
 	let exitHydrationBoundary;
 	let deferHydrationBoundary = false;
 	const finalizeHydrationBoundary = () => {
@@ -3537,7 +3974,7 @@ function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appC
 		if (hydrationClose && currentHydrationNode === hydrationClose) advanceHydrationNode(hydrationClose);
 	};
 	if (isHydrating$1) {
-		locateHydrationNode();
+		hydrationCursor = enterHydrationCursor();
 		if (component.__multiRoot && isComment(currentHydrationNode, "[")) {
 			hydrationClose = locateEndAnchor(currentHydrationNode);
 			exitHydrationBoundary = enterHydrationBoundary(hydrationClose && markHydrationAnchor(hydrationClose));
@@ -3546,13 +3983,13 @@ function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appC
 	} else resetInsertionState();
 	try {
 		let prevSuspense = null;
-		if (currentInstance && currentInstance.suspense) prevSuspense = setParentSuspense(currentInstance.suspense);
-		if ((isSingleRoot || currentInstance && isVaporTransition(currentInstance.type)) && component.inheritAttrs !== false && isVaporComponent(currentInstance) && currentInstance.hasFallthrough) {
+		if (isSuspenseEnabled && currentInstance && currentInstance.suspense) prevSuspense = setParentSuspense(currentInstance.suspense);
+		if ((isSingleRoot || (isTransitionEnabled ? currentInstance && isVaporTransition(currentInstance.type) : false)) && component.inheritAttrs !== false && isVaporComponent(currentInstance) && currentInstance.hasFallthrough) {
 			const attrs = currentInstance.attrs;
 			if (rawProps && rawProps !== EMPTY_OBJ) (rawProps.$ || (rawProps.$ = [])).push(() => attrs);
 			else rawProps = { $: [() => attrs] };
 		}
-		if (currentInstance && currentInstance.vapor && isKeepAlive(currentInstance)) {
+		if (isKeepAliveEnabled && currentInstance && currentInstance.vapor && isKeepAlive(currentInstance)) {
 			const cached = currentInstance.ctx.getCachedComponent(component);
 			if (cached) return cached;
 		}
@@ -3560,24 +3997,19 @@ function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appC
 			const frag = appContext.vapor.vdomMount(component, currentInstance, rawProps, rawSlots);
 			if (!isHydrating$1) {
 				if (_insertionParent) insert(frag, _insertionParent, _insertionAnchor);
-			} else {
-				frag.hydrate();
-				if (_isLastInsertion) advanceHydrationNode(_insertionParent);
-			}
+			} else frag.hydrate();
 			return frag;
 		}
-		if (isVaporTeleport(component)) {
+		if (isTeleportEnabled && isVaporTeleport(component)) {
 			const frag = component.process(rawProps, rawSlots);
+			if (_insertionParent) onScopeDispose$1(() => frag.dispose(), true);
 			if (!isHydrating$1) {
 				if (_insertionParent) insert(frag, _insertionParent, _insertionAnchor);
-			} else {
-				frag.hydrate();
-				if (_isLastInsertion) advanceHydrationNode(_insertionParent);
-			}
+			} else frag.hydrate();
 			return frag;
 		}
 		const instance = new VaporComponentInstance(component, rawProps, rawSlots, appContext, once);
-		if (currentKeepAliveCtx && !isAsyncWrapper(instance)) {
+		if (isKeepAliveEnabled && currentKeepAliveCtx && !isAsyncWrapper(instance)) {
 			currentKeepAliveCtx.processShapeFlag(instance);
 			setCurrentKeepAliveCtx(null);
 		}
@@ -3598,21 +4030,24 @@ function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appC
 			popWarningContext();
 			endMeasure(instance, "init");
 		}
-		if (currentInstance && currentInstance.suspense) setParentSuspense(prevSuspense);
+		if (isSuspenseEnabled && currentInstance && currentInstance.suspense) setParentSuspense(prevSuspense);
 		setCurrentSlotOwner(prevSlotOwner);
 		onScopeDispose$1(() => unmountComponent(instance), true);
 		if (!managedMount && (_insertionParent || isHydrating$1)) mountComponent(instance, _insertionParent, _insertionAnchor);
-		if (isHydrating$1 && _insertionAnchor !== void 0) advanceHydrationNode(_insertionParent);
-		if (isHydrating$1 && hydrationClose && instance.suspense && instance.asyncDep && !instance.asyncResolved && instance.restoreAsyncContext) {
+		if (isSuspenseEnabled && isHydrating$1 && hydrationClose && instance.suspense && instance.asyncDep && !instance.asyncResolved && instance.restoreAsyncContext) {
 			deferHydrationBoundary = true;
 			instance.deferredHydrationBoundary = () => {
 				if (instance.block && hydrationClose && findBlockNode(instance.block).nextNode === hydrationClose.nextSibling) setCurrentHydrationNode(hydrationClose);
 				finalizeHydrationBoundary();
 			};
+			exitHydrationCursor(hydrationCursor);
 		}
 		return instance;
 	} finally {
-		if (isHydrating$1 && !deferHydrationBoundary) finalizeHydrationBoundary();
+		if (isHydrating$1 && !deferHydrationBoundary) {
+			finalizeHydrationBoundary();
+			exitHydrationCursor(hydrationCursor);
+		}
 	}
 }
 function setupComponent(instance, component) {
@@ -3649,22 +4084,30 @@ function createDevSetupStateProxy(instance) {
 		return Reflect.get(target, key, receiver);
 	} });
 }
-/**
-* dev only
-*/
-function devRender(instance) {
-	instance.block = (instance.type.render ? callWithErrorHandling(instance.type.render, instance, 1, [
-		instance.setupState,
+function callRender(render, instance, setupState) {
+	return callWithErrorHandling(render, instance, 1, [
+		setupState,
 		instance.props,
 		instance.emit,
 		instance.attrs,
 		instance.slots
-	]) : callWithErrorHandling(isFunction(instance.type) ? instance.type : instance.type.setup, instance, 0, [instance.props, {
-		slots: instance.slots,
-		attrs: instance.attrs,
-		emit: instance.emit,
-		expose: instance.expose
-	}])) || [];
+	]);
+}
+/**
+* dev only
+*/
+function devRender(instance) {
+	const prev = setCurrentRenderingInstance(instance);
+	try {
+		instance.block = (instance.type.render ? callRender(instance.type.render, instance, instance.setupState) : callWithErrorHandling(isFunction(instance.type) ? instance.type : instance.type.setup, instance, 0, [instance.props, {
+			slots: instance.slots,
+			attrs: instance.attrs,
+			emit: instance.emit,
+			expose: instance.expose
+		}])) || [];
+	} finally {
+		setCurrentRenderingInstance(prev);
+	}
 }
 const emptyContext = {
 	app: null,
@@ -3699,8 +4142,12 @@ var VaporComponentInstance = class {
 		this.expose = expose.bind(null, this);
 		this.refs = EMPTY_OBJ;
 		this.emitted = this.exposed = this.exposeProxy = this.propsDefaults = null;
-		this.suspense = parentSuspense;
-		this.suspenseId = parentSuspense ? parentSuspense.pendingId : 0;
+		this.suspense = null;
+		this.suspenseId = 0;
+		if (isSuspenseEnabled) {
+			this.suspense = parentSuspense;
+			this.suspenseId = parentSuspense ? parentSuspense.pendingId : 0;
+		}
 		this.asyncDep = null;
 		this.asyncResolved = false;
 		this.isMounted = this.isUnmounted = this.isUpdating = this.isDeactivated = false;
@@ -3763,8 +4210,8 @@ function isReusableNullComponentAnchor(node) {
 function createPlainElement(comp, rawProps, rawSlots, isSingleRoot, once) {
 	const _insertionParent = insertionParent;
 	const _insertionAnchor = insertionAnchor;
-	const _isLastInsertion = isLastInsertion;
-	if (isHydrating$1) locateHydrationNode();
+	let hydrationCursor = null;
+	if (isHydrating$1) hydrationCursor = enterHydrationCursor();
 	else resetInsertionState();
 	const el = isHydrating$1 ? adoptTemplate(currentHydrationNode, `<${comp}/>`) : /* @__PURE__ */ createElement(comp);
 	el.$root = isSingleRoot;
@@ -3798,11 +4245,11 @@ function createPlainElement(comp, rawProps, rawSlots, isSingleRoot, once) {
 	}
 	if (!isHydrating$1) {
 		if (_insertionParent) insert(el, _insertionParent, _insertionAnchor);
-	} else if (_isLastInsertion) advanceHydrationNode(_insertionParent);
+	} else exitHydrationCursor(hydrationCursor);
 	return el;
 }
 function mountComponent(instance, parent, anchor) {
-	if (instance.suspense && instance.asyncDep && !instance.asyncResolved) {
+	if (isSuspenseEnabled && instance.suspense && instance.asyncDep && !instance.asyncResolved) {
 		const component = instance.type;
 		instance.suspense.registerDep(instance, (setupResult) => {
 			const reset = instance.restoreAsyncContext && instance.restoreAsyncContext();
@@ -3818,7 +4265,7 @@ function mountComponent(instance, parent, anchor) {
 		});
 		return;
 	}
-	if (instance.shapeFlag & 512) {
+	if (isKeepAliveEnabled && instance.shapeFlag & 512) {
 		instance.parent.ctx.activate(instance, parent, anchor);
 		return;
 	}
@@ -3831,12 +4278,12 @@ function mountComponent(instance, parent, anchor) {
 		setComponentScopeId(instance);
 	}
 	if (instance.m) queuePostFlushCb(instance.m);
-	if (instance.shapeFlag & 256 && instance.a) queuePostFlushCb(instance.a);
+	if (isKeepAliveEnabled && instance.shapeFlag & 256 && instance.a) queuePostFlushCb(instance.a);
 	instance.isMounted = true;
 	if (!!(process.env.NODE_ENV !== "production")) endMeasure(instance, `mount`);
 }
 function unmountComponent(instance, parentNode) {
-	if (instance.shapeFlag & 256 && instance.parent && instance.parent.vapor && instance.parent.ctx) {
+	if (isKeepAliveEnabled && instance.shapeFlag & 256 && instance.parent && instance.parent.vapor && instance.parent.ctx) {
 		if (parentNode) instance.parent.ctx.deactivate(instance);
 		return;
 	}
@@ -3857,7 +4304,7 @@ function getExposed(instance) {
 function getRootElement(block, onDynamicFragment, recurse = true) {
 	if (block instanceof Element) return block;
 	if (recurse && isVaporComponent(block)) return getRootElement(block.block, onDynamicFragment, recurse);
-	if (isFragment(block) && !isTeleportFragment(block)) {
+	if (isFragment(block) && !(isTeleportEnabled && isTeleportFragment(block))) {
 		if (block instanceof DynamicFragment && onDynamicFragment) onDynamicFragment(block);
 		const { nodes } = block;
 		if (nodes instanceof Element && nodes.$root) return nodes;
@@ -3878,9 +4325,6 @@ function getRootElement(block, onDynamicFragment, recurse = true) {
 		return hasComment ? singleRoot : void 0;
 	}
 }
-function isVaporTransition(component) {
-	return getComponentName(component) === "VaporTransition";
-}
 function handleSetupResult(setupResult, component, instance) {
 	if (!!(process.env.NODE_ENV !== "production")) pushWarningContext(instance);
 	if (!!(process.env.NODE_ENV !== "production") && !isBlock(setupResult)) if (isFunction(component)) {
@@ -3895,158 +4339,413 @@ function handleSetupResult(setupResult, component, instance) {
 		if (!!(process.env.NODE_ENV !== "production")) instance.setupState = createDevSetupStateProxy(instance);
 		devRender(instance);
 	}
-	else if (setupResult === EMPTY_OBJ && component.render) instance.block = callWithErrorHandling(component.render, instance, 1);
-	else instance.block = setupResult;
-	if (instance.hasFallthrough && component.inheritAttrs !== false && Object.keys(instance.attrs).length) {
-		const root = getRootElement(instance.block, (frag) => frag.attrs = instance.attrs, false);
-		if (root) renderEffect(() => {
-			const attrs = isFunction(component) && !isVaporTransition(component) ? getFunctionalFallthrough(instance.attrs) : instance.attrs;
-			if (attrs) applyFallthroughProps(root, attrs);
-		});
-		else if (!!(process.env.NODE_ENV !== "production") && (!instance.accessedAttrs && isArray(instance.block) && instance.block.length || isTeleportFragment(instance.block))) warnExtraneousAttributes(instance.attrs);
+	else if (setupResult === EMPTY_OBJ && component.render) instance.block = callRender(component.render, instance, setupResult);
+	else instance.block = setupResult;
+	if (instance.hasFallthrough && component.inheritAttrs !== false && Object.keys(instance.attrs).length) {
+		const root = getRootElement(instance.block, (frag) => frag.attrs = instance.attrs, false);
+		if (root) renderEffect(() => {
+			const attrs = isFunction(component) && !(isTransitionEnabled ? isVaporTransition(component) : false) ? getFunctionalFallthrough(instance.attrs) : instance.attrs;
+			if (attrs) applyFallthroughProps(root, attrs);
+		});
+		else if (!!(process.env.NODE_ENV !== "production") && (!instance.accessedAttrs && isArray(instance.block) && instance.block.length || isTeleportEnabled && isTeleportFragment(instance.block))) warnExtraneousAttributes(instance.attrs);
+	}
+	if (!!(process.env.NODE_ENV !== "production")) popWarningContext();
+}
+function getCurrentScopeId() {
+	const scopeOwner = getScopeOwner();
+	return scopeOwner ? scopeOwner.type.__scopeId : void 0;
+}
+//#endregion
+//#region packages/runtime-vapor/src/apiCreateApp.ts
+let _createApp;
+const mountApp = (app, container) => {
+	optimizePropertyLookup();
+	if (container.nodeType === 1) {
+		if (!!(process.env.NODE_ENV !== "production") && container.childNodes.length) warn("mount target container is not empty and will be cleared.");
+		container.textContent = "";
+	}
+	const instance = app._ceComponent || createComponent(app._component, app._props, null, false, false, app._context);
+	mountComponent(instance, container);
+	flushOnAppMount();
+	return instance;
+};
+let _hydrateApp;
+const hydrateApp = (app, container) => {
+	optimizePropertyLookup();
+	let instance;
+	withHydration(container, () => {
+		instance = app._ceComponent || createComponent(app._component, app._props, null, false, false, app._context, true);
+		mountComponent(instance, container);
+		flushOnAppMount();
+	});
+	return instance;
+};
+const unmountApp = (app) => {
+	unmountComponent(app._instance, app._container);
+};
+function prepareApp() {
+	initFeatureFlags();
+	const target = getGlobalThis();
+	target.__VUE__ = true;
+	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
+}
+function postPrepareApp(app) {
+	app.vapor = true;
+	const mount = app.mount;
+	app.mount = (container, ...args) => {
+		container = normalizeContainer(container);
+		const proxy = mount(container, ...args);
+		if (container instanceof Element) {
+			container.removeAttribute("v-cloak");
+			container.setAttribute("data-v-app", "");
+		}
+		return proxy;
+	};
+}
+const createVaporApp = (comp, props) => {
+	prepareApp();
+	if (!_createApp) _createApp = createAppAPI(mountApp, unmountApp, getExposed);
+	const app = _createApp(comp, props);
+	postPrepareApp(app);
+	return app;
+};
+const createVaporSSRApp = (comp, props) => {
+	setIsHydratingEnabled(true);
+	prepareApp();
+	if (!_hydrateApp) _hydrateApp = createAppAPI(hydrateApp, unmountApp, getExposed);
+	const app = _hydrateApp(comp, props);
+	postPrepareApp(app);
+	return app;
+};
+//#endregion
+//#region packages/runtime-vapor/src/apiDefineAsyncComponent.ts
+function defineVaporAsyncComponent(source) {
+	const { load, getResolvedComp, setPendingRequest, source: { loadingComponent, errorComponent, delay, hydrate: hydrateStrategy, timeout, suspensible = true } } = createAsyncComponentContext(source);
+	return /* @__PURE__ */ defineVaporComponent({
+		name: "VaporAsyncComponentWrapper",
+		__asyncLoader: load,
+		__asyncHydrate(el, instance, hydrate) {
+			if (!isHydrating$1) return;
+			if (isComment(el, "[")) {
+				const end = /* @__PURE__ */ _next(locateEndAnchor(el));
+				const block = instance.block = [el];
+				let cur = el;
+				while (true) {
+					let n = /* @__PURE__ */ _next(cur);
+					if (n && n !== end) block.push(cur = n);
+					else break;
+				}
+			} else instance.block = el;
+			instance.isMounted = true;
+			setCurrentHydrationNode(isComment(el, "[") ? locateEndAnchor(el) : el.nextSibling);
+			performAsyncHydrate(el, instance, () => hydrateNode(el, hydrate), getResolvedComp, load, hydrateStrategy);
+		},
+		get __asyncResolved() {
+			return getResolvedComp();
+		},
+		setup() {
+			const instance = currentInstance;
+			markAsyncBoundary(instance);
+			const frag = !!(process.env.NODE_ENV !== "production") || isHydrating$1 ? new DynamicFragment("async component") : new DynamicFragment();
+			let resolvedComp = getResolvedComp();
+			if (resolvedComp) {
+				frag.update(() => createInnerComp(resolvedComp, instance));
+				return frag;
+			}
+			const onError = (err) => {
+				setPendingRequest(null);
+				handleError(err, instance, 13, !errorComponent);
+			};
+			if (suspensible && instance.suspense) return load().then(() => {
+				resolvedComp = getResolvedComp();
+				if (resolvedComp) frag.update(() => createInnerComp(resolvedComp, instance));
+				return frag;
+			}).catch((err) => {
+				onError(err);
+				if (errorComponent) frag.update(() => createInnerComp(errorComponent, instance, { error: () => err }, {}));
+				return frag;
+			});
+			const { loaded, error, delayed } = useAsyncComponentState(delay, timeout, onError);
+			load().then(() => {
+				loaded.value = true;
+			}).catch((err) => {
+				onError(err);
+				error.value = err;
+			});
+			renderEffect(() => {
+				resolvedComp = getResolvedComp();
+				let render;
+				if (loaded.value && resolvedComp) render = () => createInnerComp(resolvedComp, instance);
+				else if (error.value && errorComponent) render = () => createComponent(errorComponent, { error: () => error.value });
+				else if (loadingComponent && !delayed.value) render = () => createComponent(loadingComponent);
+				frag.update(render);
+				if (isKeepAliveEnabled && frag.keepAliveCtx) frag.keepAliveCtx.cacheBlock();
+			});
+			return frag;
+		}
+	});
+}
+function createInnerComp(comp, parent, rawProps = parent.rawProps, rawSlots = parent.rawSlots) {
+	const prevInstance = setCurrentInstance(parent);
+	try {
+		return createComponent(comp, rawProps, rawSlots, void 0, void 0, parent.appContext);
+	} finally {
+		setCurrentInstance(...prevInstance);
+	}
+}
+//#endregion
+//#region packages/runtime-vapor/src/components/Teleport.ts
+const VaporTeleportImpl = {
+	name: "VaporTeleport",
+	__isTeleport: true,
+	__vapor: true,
+	process(props, slots) {
+		return new TeleportFragment(props, slots);
+	}
+};
+var TeleportFragment = class extends VaporFragment {
+	constructor(props, slots) {
+		super([]);
+		this.__isTeleportFragment = true;
+		this.isMounted = false;
+		this.childrenInitialized = false;
+		this.ownerInstance = currentInstance$1;
+		this.childrenScope = getCurrentScope();
+		this.insert = (container, anchor) => {
+			if (isHydrating$1) return;
+			if (!this.placeholder) this.placeholder = !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("teleport start") : /* @__PURE__ */ createTextNode();
+			insert(this.placeholder, container, anchor);
+			insert(this.anchor, container, anchor);
+			this.handlePropsUpdate();
+		};
+		this.dispose = () => {
+			if (this.mountToTargetJob) {
+				this.mountToTargetJob.flags |= 4;
+				this.mountToTargetJob = void 0;
+			}
+			if (this.nodes && this.mountContainer) {
+				remove(this.nodes, this.mountContainer);
+				this.nodes = [];
+			}
+			this.isMounted = false;
+			if (this.targetStart) {
+				remove(this.targetStart, /* @__PURE__ */ parentNode(this.targetStart));
+				this.targetStart = void 0;
+			}
+			if (this.targetAnchor) {
+				remove(this.targetAnchor, /* @__PURE__ */ parentNode(this.targetAnchor));
+				this.targetAnchor = void 0;
+			}
+			this.target = void 0;
+			this.mountContainer = void 0;
+			this.mountAnchor = void 0;
+		};
+		this.remove = (_parent) => {
+			this.dispose();
+			if (this.anchor) {
+				remove(this.anchor, /* @__PURE__ */ parentNode(this.anchor));
+				this.anchor = void 0;
+			}
+			if (this.placeholder) {
+				remove(this.placeholder, /* @__PURE__ */ parentNode(this.placeholder));
+				this.placeholder = void 0;
+			}
+		};
+		this.hydrate = () => {
+			if (!isHydrating$1) return;
+			const target = this.target = resolveTeleportTarget(this.resolvedProps, querySelector);
+			const disabled = isTeleportDisabled(this.resolvedProps);
+			this.placeholder = currentHydrationNode;
+			if (target) {
+				const targetNode = target._lpa || target.firstChild;
+				if (disabled) this.hydrateDisabledTeleport(target, targetNode);
+				else {
+					this.anchor = markHydrationAnchor(locateTeleportEndAnchor(currentHydrationNode.nextSibling));
+					this.mountContainer = target;
+					this.hydrateTargetAnchors(target, targetNode);
+					this.mountAnchor = this.targetAnchor;
+					if (targetNode) setCurrentHydrationNode(targetNode.nextSibling);
+					if (!this.targetAnchor) this.mountChildren(target);
+					else this.initChildren();
+				}
+			} else if (disabled) this.hydrateDisabledTeleport(null, null);
+			else this.anchor = markHydrationAnchor(locateTeleportEndAnchor(currentHydrationNode.nextSibling));
+			if (target || disabled) updateCssVars(this);
+			advanceHydrationNode(this.anchor);
+		};
+		this.rawProps = props;
+		this.rawSlots = slots;
+		this.parentComponent = getScopeOwner();
+		this.anchor = isHydrating$1 ? void 0 : !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("teleport end") : /* @__PURE__ */ createTextNode();
+		renderEffect(() => {
+			const prevTo = this.resolvedProps && this.resolvedProps.to;
+			const wasDisabled = this.isDisabled;
+			this.resolvedProps = extend({}, new Proxy(this.rawProps, rawPropsProxyHandlers));
+			this.isDisabled = isTeleportDisabled(this.resolvedProps);
+			if (wasDisabled !== this.isDisabled || !this.isDisabled && prevTo !== this.resolvedProps.to) this.handlePropsUpdate();
+		});
+	}
+	get parent() {
+		return this.anchor ? /* @__PURE__ */ parentNode(this.anchor) : null;
+	}
+	initChildren() {
+		const prevInstance = setCurrentInstance(this.ownerInstance, this.childrenScope);
+		try {
+			this.childrenInitialized = true;
+			renderEffect(() => this.runWithRenderCtx(() => this.handleChildrenUpdate(this.rawSlots && this.rawSlots.default ? this.rawSlots.default() : []), this.childrenScope));
+			this.bindChildren(this.nodes);
+		} finally {
+			setCurrentInstance(...prevInstance);
+		}
+	}
+	ensureChildrenInitialized() {
+		if (!this.childrenInitialized) this.initChildren();
+	}
+	registerUpdateCssVars(block) {
+		if (isFragment(block)) {
+			(block.onUpdated || (block.onUpdated = [])).push(() => updateCssVars(this));
+			this.registerUpdateCssVars(block.nodes);
+		} else if (isVaporComponent(block)) this.registerUpdateCssVars(block.block);
+		else if (isArray(block)) block.forEach((node) => this.registerUpdateCssVars(node));
+	}
+	bindChildren(block) {
+		if (this.parentComponent && this.parentComponent.ut) this.registerUpdateCssVars(block);
+		if (!!(process.env.NODE_ENV !== "production")) {
+			if (isVaporComponent(block)) block.parentTeleport = this;
+			else if (isArray(block)) block.forEach((node) => isVaporComponent(node) && (node.parentTeleport = this));
+		}
+	}
+	handleChildrenUpdate(children) {
+		if (isHydrating$1 || !this.parent || !this.mountContainer) {
+			this.nodes = children;
+			return;
+		}
+		remove(this.nodes, this.mountContainer);
+		insert(this.nodes = children, this.mountContainer, this.mountAnchor);
+		this.bindChildren(this.nodes);
+		updateCssVars(this);
+	}
+	mount(parent, anchor) {
+		if (isTransitionEnabled && this.$transition && !this.isMounted) applyTransitionHooks(this.nodes, this.$transition);
+		if (this.isMounted) move(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor, 2);
+		else {
+			insert(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor);
+			this.isMounted = true;
+		}
+		updateCssVars(this);
+	}
+	mountToTarget() {
+		const target = this.target = resolveTeleportTarget(this.resolvedProps, querySelector);
+		if (target) {
+			if (!this.targetAnchor || /* @__PURE__ */ parentNode(this.targetAnchor) !== target) {
+				if (this.targetStart) remove(this.targetStart, /* @__PURE__ */ parentNode(this.targetStart));
+				if (this.targetAnchor) remove(this.targetAnchor, /* @__PURE__ */ parentNode(this.targetAnchor));
+				insert(this.targetStart = /* @__PURE__ */ createTextNode(""), target);
+				insert(this.targetAnchor = /* @__PURE__ */ createTextNode(""), target);
+			}
+			this.ensureChildrenInitialized();
+			if (this.parentComponent && this.parentComponent.isCE) (this.parentComponent.ce._teleportTargets || (this.parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
+			this.mount(target, this.targetAnchor);
+		} else if (!!(process.env.NODE_ENV !== "production")) warn(`Invalid Teleport target on ${this.targetAnchor ? "update" : "mount"}:`, target, `(${typeof target})`);
+	}
+	clearMainViewChildren() {
+		if (!this.placeholder || !this.anchor) return;
+		let node = this.placeholder.nextSibling;
+		while (node && node !== this.anchor) {
+			const next = node.nextSibling;
+			remove(node, /* @__PURE__ */ parentNode(node));
+			node = next;
+		}
+		this.isMounted = false;
+		this.mountContainer = null;
+	}
+	handlePropsUpdate() {
+		if (!this.parent || isHydrating$1) return;
+		if (this.isDisabled) {
+			this.ensureChildrenInitialized();
+			this.mount(this.parent, this.anchor);
+		} else {
+			if (this.placeholder && this.anchor && this.placeholder.nextSibling !== this.anchor) this.clearMainViewChildren();
+			if (isTeleportDeferred(this.resolvedProps) || !this.parent.isConnected) {
+				if (!this.mountToTargetJob || this.mountToTargetJob.flags & 4) this.mountToTargetJob = () => {
+					this.mountToTargetJob = void 0;
+					if (this.isDisabled || !this.anchor) return;
+					this.mountToTarget();
+				};
+				queuePostFlushCb(this.mountToTargetJob);
+			} else this.mountToTarget();
+		}
+	}
+	hydrateTargetAnchors(target, targetNode) {
+		let targetAnchor = targetNode;
+		while (targetAnchor) {
+			if (targetAnchor.nodeType === 8) {
+				if (targetAnchor.data === "teleport start anchor") this.targetStart = targetAnchor;
+				else if (targetAnchor.data === "teleport anchor") {
+					this.targetAnchor = markHydrationAnchor(targetAnchor);
+					target._lpa = this.targetAnchor.nextSibling;
+					break;
+				}
+			}
+			targetAnchor = targetAnchor.nextSibling;
+		}
+	}
+	hydrateDisabledTeleport(target, targetNode) {
+		if (!isHydrating$1) return;
+		let nextNode = this.placeholder.nextSibling;
+		setCurrentHydrationNode(nextNode);
+		this.mountAnchor = this.anchor = markHydrationAnchor(locateTeleportEndAnchor(nextNode));
+		this.mountContainer = /* @__PURE__ */ parentNode(this.anchor);
+		if (target) this.hydrateTargetAnchors(target, targetNode);
+		else {
+			this.targetStart = targetNode;
+			this.targetAnchor = targetNode && targetNode.nextSibling;
+		}
+		this.initChildren();
 	}
-	if (!!(process.env.NODE_ENV !== "production")) popWarningContext();
-}
-function getCurrentScopeId() {
-	const scopeOwner = getScopeOwner();
-	return scopeOwner ? scopeOwner.type.__scopeId : void 0;
-}
-//#endregion
-//#region packages/runtime-vapor/src/apiCreateApp.ts
-let _createApp;
-const mountApp = (app, container) => {
-	optimizePropertyLookup();
-	if (container.nodeType === 1) {
-		if (!!(process.env.NODE_ENV !== "production") && container.childNodes.length) warn("mount target container is not empty and will be cleared.");
-		container.textContent = "";
+	mountChildren(target) {
+		if (!isHydrating$1) return;
+		target.appendChild(this.targetStart = /* @__PURE__ */ createTextNode(""));
+		target.appendChild(this.mountAnchor = this.targetAnchor = markHydrationAnchor(/* @__PURE__ */ createTextNode("")));
+		if (!isMismatchAllowed(target, 1)) {
+			if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_HYDRATION_MISMATCH_DETAILS__) warn(`Hydration children mismatch on`, target, `\nServer rendered element contains fewer child nodes than client nodes.`);
+			logMismatchError();
+		}
+		runWithoutHydration(this.initChildren.bind(this));
 	}
-	const instance = app._ceComponent || createComponent(app._component, app._props, null, false, false, app._context);
-	mountComponent(instance, container);
-	flushOnAppMount();
-	return instance;
-};
-let _hydrateApp;
-const hydrateApp = (app, container) => {
-	optimizePropertyLookup();
-	let instance;
-	withHydration(container, () => {
-		instance = app._ceComponent || createComponent(app._component, app._props, null, false, false, app._context, true);
-		mountComponent(instance, container);
-		flushOnAppMount();
-	});
-	return instance;
-};
-const unmountApp = (app) => {
-	unmountComponent(app._instance, app._container);
 };
-function prepareApp() {
-	initFeatureFlags();
-	const target = getGlobalThis();
-	target.__VUE__ = true;
-	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
+const VaporTeleport = /* @__PURE__ */ enableTeleport(VaporTeleportImpl);
+function locateTeleportEndAnchor(node = currentHydrationNode) {
+	let depth = 0;
+	while (node) {
+		if (isComment(node, "teleport start")) depth++;
+		else if (isComment(node, "teleport end")) if (depth === 0) return node;
+		else depth--;
+		node = node.nextSibling;
+	}
+	return null;
 }
-function postPrepareApp(app) {
-	app.vapor = true;
-	const mount = app.mount;
-	app.mount = (container, ...args) => {
-		container = normalizeContainer(container);
-		const proxy = mount(container, ...args);
-		if (container instanceof Element) {
-			container.removeAttribute("v-cloak");
-			container.setAttribute("data-v-app", "");
+function updateCssVars(frag) {
+	const ctx = frag.parentComponent;
+	if (ctx && ctx.ut) {
+		let node, anchor;
+		if (frag.isDisabled) {
+			node = frag.placeholder;
+			anchor = frag.anchor;
+		} else {
+			node = frag.targetStart;
+			anchor = frag.targetAnchor;
 		}
-		return proxy;
-	};
-}
-const createVaporApp = (comp, props) => {
-	prepareApp();
-	if (!_createApp) _createApp = createAppAPI(mountApp, unmountApp, getExposed);
-	const app = _createApp(comp, props);
-	postPrepareApp(app);
-	return app;
-};
-const createVaporSSRApp = (comp, props) => {
-	setIsHydratingEnabled(true);
-	prepareApp();
-	if (!_hydrateApp) _hydrateApp = createAppAPI(hydrateApp, unmountApp, getExposed);
-	const app = _hydrateApp(comp, props);
-	postPrepareApp(app);
-	return app;
-};
-//#endregion
-//#region packages/runtime-vapor/src/apiDefineAsyncComponent.ts
-function defineVaporAsyncComponent(source) {
-	const { load, getResolvedComp, setPendingRequest, source: { loadingComponent, errorComponent, delay, hydrate: hydrateStrategy, timeout, suspensible = true } } = createAsyncComponentContext(source);
-	return /* @__PURE__ */ defineVaporComponent({
-		name: "VaporAsyncComponentWrapper",
-		__asyncLoader: load,
-		__asyncHydrate(el, instance, hydrate) {
-			if (!isHydrating$1) return;
-			if (isComment(el, "[")) {
-				const end = /* @__PURE__ */ _next(locateEndAnchor(el));
-				const block = instance.block = [el];
-				let cur = el;
-				while (true) {
-					let n = /* @__PURE__ */ _next(cur);
-					if (n && n !== end) block.push(cur = n);
-					else break;
-				}
-			} else instance.block = el;
-			instance.isMounted = true;
-			setCurrentHydrationNode(isComment(el, "[") ? locateEndAnchor(el) : el.nextSibling);
-			performAsyncHydrate(el, instance, () => hydrateNode(el, hydrate), getResolvedComp, load, hydrateStrategy);
-		},
-		get __asyncResolved() {
-			return getResolvedComp();
-		},
-		setup() {
-			const instance = currentInstance;
-			markAsyncBoundary(instance);
-			const frag = !!(process.env.NODE_ENV !== "production") || isHydrating$1 ? new DynamicFragment("async component") : new DynamicFragment();
-			let resolvedComp = getResolvedComp();
-			if (resolvedComp) {
-				frag.update(() => createInnerComp(resolvedComp, instance));
-				return frag;
-			}
-			const onError = (err) => {
-				setPendingRequest(null);
-				handleError(err, instance, 13, !errorComponent);
-			};
-			if (suspensible && instance.suspense) return load().then(() => {
-				resolvedComp = getResolvedComp();
-				if (resolvedComp) frag.update(() => createInnerComp(resolvedComp, instance));
-				return frag;
-			}).catch((err) => {
-				onError(err);
-				if (errorComponent) frag.update(() => createInnerComp(errorComponent, instance, { error: () => err }, {}));
-				return frag;
-			});
-			const { loaded, error, delayed } = useAsyncComponentState(delay, timeout, onError);
-			load().then(() => {
-				loaded.value = true;
-			}).catch((err) => {
-				onError(err);
-				error.value = err;
-			});
-			renderEffect(() => {
-				resolvedComp = getResolvedComp();
-				let render;
-				if (loaded.value && resolvedComp) render = () => createInnerComp(resolvedComp, instance);
-				else if (error.value && errorComponent) render = () => createComponent(errorComponent, { error: () => error.value });
-				else if (loadingComponent && !delayed.value) render = () => createComponent(loadingComponent);
-				frag.update(render);
-				if (frag.keepAliveCtx) frag.keepAliveCtx.cacheBlock();
-			});
-			return frag;
+		while (node && node !== anchor) {
+			if (node.nodeType === 1) node.setAttribute("data-v-owner", String(ctx.uid));
+			node = node.nextSibling;
+		}
+		pauseTracking();
+		try {
+			ctx.ut();
+		} finally {
+			resetTracking();
 		}
-	});
-}
-function createInnerComp(comp, parent, rawProps = parent.rawProps, rawSlots = parent.rawSlots) {
-	const prevInstance = setCurrentInstance(parent);
-	try {
-		return createComponent(comp, rawProps, rawSlots, void 0, void 0, parent.appContext);
-	} finally {
-		setCurrentInstance(...prevInstance);
 	}
 }
 //#endregion
@@ -4116,15 +4815,14 @@ var VaporElement = class extends VueElementBase {
 		}
 		if (!isFragment(block)) return;
 		const { nodes } = block;
-		if (Array.isArray(nodes)) {
-			const newNodes = [];
-			for (const node of nodes) if (node instanceof HTMLSlotElement) newNodes.push(...replacements.get(node));
-			else {
-				this._updateFragmentNodes(node, replacements);
-				newNodes.push(node);
-			}
-			block.nodes = newNodes;
-		} else if (nodes instanceof HTMLSlotElement) block.nodes = replacements.get(nodes);
+		if (nodes instanceof HTMLSlotElement) {
+			const replacement = replacements.get(nodes);
+			if (!replacement) return;
+			if (replacement.usedFallback && block instanceof SlotFragment && block.customElementFallback) {
+				this._updateFragmentNodes(block.customElementFallback, replacements);
+				block.nodes = block.customElementFallback;
+			} else block.nodes = replacement.nodes;
+		} else if (Array.isArray(nodes)) nodes.forEach((item) => this._updateFragmentNodes(item, replacements));
 		else this._updateFragmentNodes(nodes, replacements);
 	}
 	_createComponent() {
@@ -4140,25 +4838,33 @@ var VaporElement = class extends VueElementBase {
 //#region packages/runtime-vapor/src/dom/template.ts
 let t;
 /* @__NO_SIDE_EFFECTS__ */
-function template(html, root, ns) {
+function template(html, root, isStatic, ns) {
 	let node;
 	return () => {
 		if (isHydrating$1) {
-			const adopted = adoptTemplate(currentHydrationNode, html);
+			let adopted = null;
+			if (isStatic) {
+				adopted = resolveHydrationTarget(currentHydrationNode);
+				node = adopted.cloneNode(true);
+				advanceHydrationNode(adopted);
+			} else adopted = adoptTemplate(currentHydrationNode, html);
 			if (root) adopted.$root = true;
 			return adopted;
 		}
+		if (node) {
+			const ret = node.cloneNode(true);
+			if (root) ret.$root = true;
+			return ret;
+		}
 		if (html[0] !== "<") return /* @__PURE__ */ createTextNode(html);
-		if (!node) {
-			t = t || document.createElement("template");
-			if (ns) {
-				const tag = ns === 1 ? "svg" : "math";
-				t.innerHTML = `<${tag}>${html}</${tag}>`;
-				node = /* @__PURE__ */ _child(/* @__PURE__ */ _child(t.content));
-			} else {
-				t.innerHTML = html;
-				node = /* @__PURE__ */ _child(t.content);
-			}
+		t = t || document.createElement("template");
+		if (ns) {
+			const tag = ns === 1 ? "svg" : "math";
+			t.innerHTML = `<${tag}>${html}</${tag}>`;
+			node = /* @__PURE__ */ _child(/* @__PURE__ */ _child(t.content));
+		} else {
+			t.innerHTML = html;
+			node = /* @__PURE__ */ _child(t.content);
 		}
 		const ret = node.cloneNode(true);
 		if (root) ret.$root = true;
@@ -4170,25 +4876,38 @@ function template(html, root, ns) {
 function createIf(condition, b1, b2, blockShape, once, index) {
 	const _insertionParent = insertionParent;
 	const _insertionAnchor = insertionAnchor;
-	const _isLastInsertion = isLastInsertion;
 	if (!isHydrating$1) resetInsertionState();
+	let hydrationCursor = null;
+	let branchShape;
 	let frag;
 	if (once) {
 		const ok = condition();
-		if (isHydrating$1) locateHydrationNode(decodeIfShape(blockShape, ok) === 2);
+		if (isHydrating$1) {
+			branchShape = decodeIfShape(blockShape, ok);
+			hydrationCursor = enterHydrationCursor(branchShape === 2);
+		}
 		frag = ok ? b1() : b2 ? b2() : [!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("if") : /* @__PURE__ */ createTextNode()];
 	} else {
 		const keyed = index != null;
 		frag = isHydrating$1 || !!(process.env.NODE_ENV !== "production") ? new DynamicFragment("if", keyed, false) : new DynamicFragment(void 0, keyed, false);
 		renderEffect(() => {
 			const ok = condition();
-			if (isHydrating$1) locateHydrationNode(decodeIfShape(blockShape, ok) === 2);
+			if (isHydrating$1) {
+				branchShape = decodeIfShape(blockShape, ok);
+				hydrationCursor = enterHydrationCursor(branchShape === 2);
+			}
 			frag.update(ok ? b1 : b2, keyed ? `${index}${ok ? 0 : 1}` : void 0);
 		});
 	}
 	if (!isHydrating$1) {
 		if (_insertionParent) insert(frag, _insertionParent, _insertionAnchor);
-	} else if (_isLastInsertion) advanceHydrationNode(_insertionParent);
+	} else {
+		if (branchShape === 0 && hydrationCursor) {
+			const start = hydrationCursor.start;
+			if (start && currentHydrationNode === start && start.nodeType === 8 && start.data === "") advanceHydrationNode(start);
+		}
+		exitHydrationCursor(hydrationCursor);
+	}
 	return frag;
 }
 function decodeIfShape(shape, ok) {
@@ -4209,23 +4928,27 @@ function decodeIfShape(shape, ok) {
 function createKeyedFragment(key, render) {
 	const _insertionParent = insertionParent;
 	const _insertionAnchor = insertionAnchor;
-	const _isLastInsertion = isLastInsertion;
 	if (!isHydrating$1) resetInsertionState();
+	const hydrationCursor = isHydrating$1 ? captureHydrationCursor() : null;
 	const frag = !!(process.env.NODE_ENV !== "production") ? new DynamicFragment("keyed", true) : new DynamicFragment(void 0, true);
 	renderEffect(() => frag.update(render, key()));
 	if (!isHydrating$1) {
 		if (_insertionParent) insert(frag, _insertionParent, _insertionAnchor);
-	} else if (_isLastInsertion) advanceHydrationNode(_insertionParent);
+	} else exitHydrationCursor(hydrationCursor);
 	return frag;
 }
 //#endregion
 //#region packages/runtime-vapor/src/apiCreateFor.ts
+let resolveForHydrationAnchor;
+function setForHydrationAnchorResolver(resolver) {
+	resolveForHydrationAnchor = resolver;
+}
 const createFor = (src, renderItem, getKey, flags = 0, setup) => {
 	const _insertionParent = insertionParent;
 	const _insertionAnchor = insertionAnchor;
 	const _insertionIndex = insertionIndex;
-	const _isLastInsertion = isLastInsertion;
-	if (isHydrating$1) locateHydrationNode(true);
+	let hydrationCursor = null;
+	if (isHydrating$1) hydrationCursor = enterHydrationCursor(true);
 	else resetInsertionState();
 	let isMounted = false;
 	let oldBlocks = [];
@@ -4247,57 +4970,15 @@ const createFor = (src, renderItem, getKey, flags = 0, setup) => {
 		const newLength = source.values.length;
 		const oldLength = oldBlocks.length;
 		newBlocks = new Array(newLength);
-		let isFallback = false;
 		const prevSub = setActiveSub();
 		if (!isMounted) {
 			isMounted = true;
-			if (isHydrating$1) {
-				const hydrationStart = currentHydrationNode;
-				let exitHydrationBoundary;
-				let nextNode;
-				const emptyLocalRange = isComment(hydrationStart, "]") && isComment(hydrationStart.previousSibling, "[");
-				const slotFallbackRange = currentEmptyFragment !== void 0 && currentSlotEndAnchor;
-				try {
-					if (emptyLocalRange && newLength) {
-						parentAnchor = markHydrationAnchor(hydrationStart);
-						exitHydrationBoundary = enterHydrationBoundary(parentAnchor);
-						for (let i = 0; i < newLength; i++) mount(source, i);
-						setCurrentHydrationNode(parentAnchor);
-					} else {
-						for (let i = 0; i < newLength; i++) {
-							if (isComment(currentHydrationNode, "]")) {
-								nextNode = markHydrationAnchor(currentHydrationNode);
-								setCurrentHydrationNode(nextNode);
-							} else nextNode = locateNextNode(currentHydrationNode);
-							mount(source, i);
-							if (nextNode) setCurrentHydrationNode(nextNode);
-						}
-						if (slotFallbackRange && !isValidBlock(newBlocks)) {
-							const anchor = currentHydrationNode !== hydrationStart ? currentHydrationNode : hydrationStart !== currentSlotEndAnchor ? hydrationStart.nextSibling : currentSlotEndAnchor;
-							parentAnchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("for") : /* @__PURE__ */ createTextNode());
-							pendingHydrationAnchor = true;
-							if (currentHydrationNode === hydrationStart || currentHydrationNode === currentSlotEndAnchor) setCurrentHydrationNode(hydrationStart);
-							queuePostFlushCb(() => anchor.parentNode.insertBefore(parentAnchor, anchor));
-						} else {
-							parentAnchor = markHydrationAnchor(locateHydrationBoundaryClose(currentHydrationNode));
-							exitHydrationBoundary = enterHydrationBoundary(parentAnchor);
-							if (!!(process.env.NODE_ENV !== "production") && !isComment(parentAnchor, "]")) throw new Error(`v-for fragment anchor node was not found. this is likely a Vue internal bug.`);
-							if (_insertionParent && isComment(parentAnchor, "]")) {
-								parentAnchor.$idx = _insertionIndex || 0;
-								_insertionParent.$llc = parentAnchor;
-							}
-						}
-					}
-				} finally {
-					exitHydrationBoundary && exitHydrationBoundary();
-				}
-			} else for (let i = 0; i < newLength; i++) mount(source, i);
+			if (isHydrating$1) hydrateList(source, newLength);
+			else for (let i = 0; i < newLength; i++) mount(source, i);
 		} else {
-			parent = parent || parentAnchor.parentNode;
-			if (!oldLength) {
-				if (frag.fallback && frag.nodes[0].length > 0) remove(frag.nodes[0], parent);
-				for (let i = 0; i < newLength; i++) mount(source, i);
-			} else if (!newLength) {
+			parent = parentAnchor.parentNode;
+			if (!oldLength) for (let i = 0; i < newLength; i++) mount(source, i);
+			else if (!newLength) {
 				for (const selector of selectors) selector.cleanup();
 				const doRemove = !canUseFastRemove;
 				for (let i = 0; i < oldLength; i++) unmount(oldBlocks[i], doRemove, false);
@@ -4305,10 +4986,6 @@ const createFor = (src, renderItem, getKey, flags = 0, setup) => {
 					parent.textContent = "";
 					parent.appendChild(parentAnchor);
 				}
-				if (frag.fallback) {
-					insert(frag.nodes[0] = frag.fallback(), parent, parentAnchor);
-					isFallback = true;
-				}
 			} else if (!getKey) {
 				const commonLength = Math.min(newLength, oldLength);
 				for (let i = 0; i < commonLength; i++) update(newBlocks[i] = oldBlocks[i], getItem(source, i)[0]);
@@ -4450,10 +5127,8 @@ const createFor = (src, renderItem, getKey, flags = 0, setup) => {
 				}
 			}
 		}
-		if (!isFallback) {
-			frag.nodes = [oldBlocks = newBlocks];
-			if (parentAnchor) frag.nodes.push(parentAnchor);
-		} else oldBlocks = [];
+		frag.nodes = [oldBlocks = newBlocks];
+		if (parentAnchor) frag.nodes.push(parentAnchor);
 		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
 		setActiveSub(prevSub);
 	};
@@ -4472,10 +5147,59 @@ const createFor = (src, renderItem, getKey, flags = 0, setup) => {
 			nodes = scope.run(() => renderItem(itemRef, keyRef, indexRef));
 		}
 		const block = newBlocks[idx] = new ForBlock(nodes, scope, itemRef, keyRef, indexRef, key2);
-		if (frag.$transition) applyTransitionHooks(block.nodes, frag.$transition);
+		if (isTransitionEnabled && frag.$transition) applyTransitionHooks(block.nodes, frag.$transition);
 		if (parent) insert(block.nodes, parent, anchor);
 		return block;
 	};
+	function hydrateList(source, newLength) {
+		const hydrationStart = currentHydrationNode;
+		let exitHydrationBoundary;
+		let nextNode;
+		const emptyLocalRange = isComment(hydrationStart, "]") && isComment(hydrationStart.previousSibling, "[");
+		const slotEndAnchor = getCurrentSlotEndAnchor();
+		const slotFallbackRange = isHydratingSlotFallbackActive() && slotEndAnchor;
+		try {
+			if (emptyLocalRange && newLength) {
+				parentAnchor = markHydrationAnchor(hydrationStart);
+				exitHydrationBoundary = enterHydrationBoundary(parentAnchor);
+				for (let i = 0; i < newLength; i++) mount(source, i);
+				setCurrentHydrationNode(parentAnchor);
+			} else {
+				for (let i = 0; i < newLength; i++) {
+					if (isComment(currentHydrationNode, "]")) {
+						nextNode = markHydrationAnchor(currentHydrationNode);
+						setCurrentHydrationNode(nextNode);
+					} else nextNode = locateNextNode(currentHydrationNode);
+					mount(source, i);
+					if (nextNode) setCurrentHydrationNode(nextNode);
+				}
+				const resolvedAnchor = resolveForHydrationAnchor && resolveForHydrationAnchor(hydrationStart, newLength ? nextNode : currentHydrationNode);
+				if (resolvedAnchor) {
+					parentAnchor = resolvedAnchor;
+					pendingHydrationAnchor = true;
+				} else if (slotFallbackRange && !isValidBlock(newBlocks)) {
+					const anchor = currentHydrationNode !== hydrationStart ? currentHydrationNode : hydrationStart !== slotEndAnchor ? hydrationStart.nextSibling : slotEndAnchor;
+					parentAnchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("for") : /* @__PURE__ */ createTextNode());
+					pendingHydrationAnchor = true;
+					if (currentHydrationNode === hydrationStart || currentHydrationNode === slotEndAnchor) setCurrentHydrationNode(hydrationStart);
+					queuePostFlushCb(() => {
+						const parentNode = anchor.parentNode;
+						if (parentNode) parentNode.insertBefore(parentAnchor, anchor);
+					});
+				} else {
+					parentAnchor = markHydrationAnchor(locateHydrationBoundaryClose(currentHydrationNode));
+					exitHydrationBoundary = enterHydrationBoundary(parentAnchor);
+					if (!!(process.env.NODE_ENV !== "production") && !isComment(parentAnchor, "]")) throw new Error(`v-for fragment anchor node was not found. this is likely a Vue internal bug.`);
+					if (_insertionParent && isComment(parentAnchor, "]")) {
+						parentAnchor.$idx = _insertionIndex || 0;
+						_insertionParent.$llc = parentAnchor;
+					}
+				}
+			}
+		} finally {
+			exitHydrationBoundary && exitHydrationBoundary();
+		}
+	}
 	const update = ({ itemRef, keyRef, indexRef }, newItem, newKey, newIndex) => {
 		if (newItem !== itemRef.value) itemRef.value = newItem;
 		if (keyRef && newKey !== void 0 && newKey !== keyRef.value) keyRef.value = newKey;
@@ -4499,7 +5223,10 @@ const createFor = (src, renderItem, getKey, flags = 0, setup) => {
 	});
 	if (!isHydrating$1) {
 		if (_insertionParent) insert(frag, _insertionParent, _insertionAnchor);
-	} else if (!pendingHydrationAnchor) advanceHydrationNode(_isLastInsertion ? _insertionParent : parentAnchor);
+	} else {
+		if (!pendingHydrationAnchor && currentHydrationNode === parentAnchor) advanceHydrationNode(parentAnchor);
+		exitHydrationCursor(hydrationCursor);
+	}
 	return frag;
 	function createSelector(source) {
 		let operMap = /* @__PURE__ */ new Map();
@@ -4755,7 +5482,7 @@ const getRefValue = (el) => {
 			return getRefValue(el.block.nodes);
 		}
 		return getExposed(el) || el;
-	} else if (isTeleportFragment(el)) return null;
+	} else if (isTeleportEnabled && isTeleportFragment(el)) return null;
 	else if (isDynamicFragment(el)) {
 		if (isArray(el.nodes)) return null;
 		return getRefValue(el.nodes);
@@ -4782,7 +5509,7 @@ function setVarsOnBlock(block, vars) {
 	if (block instanceof Node) setVarsOnNode(block, vars);
 	else if (isArray(block)) block.forEach((child) => setVarsOnBlock(child, vars));
 	else if (isVaporComponent(block)) setVarsOnBlock(block.block, vars);
-	else if (isTeleportFragment(block)) return;
+	else if (isTeleportEnabled && isTeleportFragment(block)) return;
 	else setVarsOnBlock(block.nodes, vars);
 }
 //#endregion
@@ -4790,8 +5517,8 @@ function setVarsOnBlock(block, vars) {
 function createDynamicComponent(getter, rawProps, rawSlots, isSingleRoot, once) {
 	const _insertionParent = insertionParent;
 	const _insertionAnchor = insertionAnchor;
-	const _isLastInsertion = isLastInsertion;
 	if (!isHydrating$1) resetInsertionState();
+	const hydrationCursor = isHydrating$1 ? captureHydrationCursor() : null;
 	const frag = isHydrating$1 || !!(process.env.NODE_ENV !== "production") ? new DynamicFragment("dynamic-component") : new DynamicFragment();
 	const scopeOwner = getScopeOwner();
 	const renderFn = () => {
@@ -4801,6 +5528,7 @@ function createDynamicComponent(getter, rawProps, rawSlots, isSingleRoot, once)
 			if (isBlock(value)) return value;
 			if (isInteropEnabled && appContext.vapor && isVNode(value)) {
 				if (isKeepAlive(currentInstance)) {
+					enableKeepAlive();
 					const frag = currentInstance.ctx.getCachedComponent(value.type, value.key);
 					if (frag) return frag;
 				}
@@ -4808,7 +5536,6 @@ function createDynamicComponent(getter, rawProps, rawSlots, isSingleRoot, once)
 				if (isHydrating$1) {
 					locateHydrationNode(shouldConsumeFragmentStart(value));
 					frag.hydrate();
-					if (_isLastInsertion) advanceHydrationNode(_insertionParent);
 				}
 				return frag;
 			}
@@ -4819,7 +5546,7 @@ function createDynamicComponent(getter, rawProps, rawSlots, isSingleRoot, once)
 	else renderEffect(renderFn);
 	if (!isHydrating$1) {
 		if (_insertionParent) insert(frag, _insertionParent, _insertionAnchor);
-	} else if (_isLastInsertion) advanceHydrationNode(_insertionParent);
+	} else exitHydrationCursor(hydrationCursor);
 	return frag;
 }
 function withScopeOwner(owner, fn) {
@@ -4912,6 +5639,21 @@ function withVaporDirectives(node, dirs) {
 //#region packages/runtime-vapor/src/components/TransitionGroup.ts
 const positionMap = /* @__PURE__ */ new WeakMap();
 const newPositionMap = /* @__PURE__ */ new WeakMap();
+let isForHydrationAnchorResolverRegistered = false;
+let currentForHydrationContainer;
+function ensureForHydrationAnchorResolver() {
+	if (isForHydrationAnchorResolverRegistered) return;
+	isForHydrationAnchorResolverRegistered = true;
+	setForHydrationAnchorResolver((hydrationStart, anchorNode) => {
+		const container = currentForHydrationContainer;
+		if (!container) return;
+		if (hydrationStart !== container && hydrationStart.parentNode !== container) return;
+		const anchor = anchorNode && anchorNode !== container && anchorNode.parentNode === container ? anchorNode : null;
+		const parentAnchor = markHydrationAnchor(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("for") : /* @__PURE__ */ createTextNode());
+		container.insertBefore(parentAnchor, anchor);
+		return parentAnchor;
+	});
+}
 const decorate = (t) => {
 	delete t.props.mode;
 	return t;
@@ -4975,17 +5717,35 @@ const VaporTransitionGroup = /* @__PURE__ */ decorate(/* @__PURE__ */ defineVapo
 			const tag = props.tag;
 			const slot = slots.default;
 			if (isMounted && tag === currentTag && slot === currentSlot) return;
-			const container = tag ? /* @__PURE__ */ createElement(tag) : void 0;
+			const container = tag ? isHydrating$1 ? adoptTemplate(currentHydrationNode, `<${tag}/>`) : /* @__PURE__ */ createElement(tag) : void 0;
+			let nextNode = null;
+			let prevForHydrationContainer;
+			if (isHydrating$1 && container) {
+				ensureForHydrationAnchorResolver();
+				prevForHydrationContainer = currentForHydrationContainer;
+				currentForHydrationContainer = container;
+				nextNode = locateNextNode(container);
+				setCurrentHydrationNode(container.firstChild || container);
+			}
 			let block = slottedBlock;
-			frag.update(() => {
-				block = slot && slot() || [];
-				applyGroupTransitionHooks(block, propsProxy, state, instance);
-				if (container) {
-					insert(block, container);
-					return container;
+			let transitionBlocks = [];
+			try {
+				frag.update(() => {
+					block = slot && slot() || [];
+					transitionBlocks = applyGroupTransitionHooks(block, propsProxy, state, instance);
+					if (container) {
+						if (!isHydrating$1) insert(block, container);
+						return container;
+					}
+					return block;
+				});
+				if (isHydrating$1 && container && currentHydrationNode && currentHydrationNode.parentNode === container && !transitionBlocks.some((child) => child === currentHydrationNode)) cleanupHydrationTail(currentHydrationNode, container);
+			} finally {
+				if (isHydrating$1 && container) {
+					currentForHydrationContainer = prevForHydrationContainer;
+					setCurrentHydrationNode(nextNode);
 				}
-				return block;
-			});
+			}
 			slottedBlock = block;
 			currentTag = tag;
 			currentSlot = slot;
@@ -5009,6 +5769,7 @@ function applyGroupTransitionHooks(block, props, state, instance) {
 		hooks.applyGroup = applyGroupTransitionHooks;
 		frag.$transition = hooks;
 	});
+	return children;
 }
 function inheritKey(children, key) {
 	if (key === void 0 || children.length === 0) return;