vue 3.6.0-beta.13 → 3.6.0-beta.15

package/dist/vue.runtime-with-vapor.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-  * vue v3.6.0-beta.13
+  * vue v3.6.0-beta.15
   * (c) 2018-present Yuxi (Evan) You and Vue contributors
   * @license MIT
   **/
@@ -2196,8 +2196,9 @@ var WatcherEffect = class extends ReactiveEffect {
 		if (once && cb) {
 			const _cb = cb;
 			cb = (...args) => {
-				_cb(...args);
+				const res = _cb(...args);
 				this.stop();
+				return res;
 			};
 		}
 		this.cb = cb;
@@ -2211,7 +2212,7 @@ var WatcherEffect = class extends ReactiveEffect {
 		if (!this.cb) return;
 		const { immediate, deep, call } = this.options;
 		if (initialRun && !immediate) return;
-		if (deep || this.forceTrigger || (this.isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
+		if (initialRun || deep || this.forceTrigger || (this.isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
 			cleanup(this);
 			const currentWatcher = activeWatcher;
 			activeWatcher = this;
@@ -2645,6 +2646,7 @@ function flushJobs(seen) {
 		}
 		flushIndex = 0;
 		jobsLength = 0;
+		jobs.length = 0;
 		flushPostFlushCbs(seen);
 		currentFlushPromise = null;
 		if (jobsLength || postJobs.length) flushJobs(seen);
@@ -2702,6 +2704,14 @@ function createRecord(id, initialDef) {
 function normalizeClassComponent(component) {
 	return isClassComponent(component) ? component.__vccOpts : component;
 }
+function hasDirtyAncestor(instance, dirtyInstances) {
+	let parent = instance.parent;
+	while (parent) {
+		if (dirtyInstances.has(parent)) return true;
+		parent = parent.parent;
+	}
+	return false;
+}
 function rerender(id, newRender) {
 	const record = map.get(id);
 	if (!record) return;
@@ -2733,42 +2743,69 @@ function reload(id, newComp) {
 	const isVapor = record.initialDef.__vapor;
 	updateComponentDef(record.initialDef, newComp);
 	const instances = [...record.instances];
-	if (isVapor && newComp.__vapor && !instances.some((i) => i.ceReload)) {
+	if (isVapor && newComp.__vapor && !instances.some((instance) => instance.parent && !instance.parent.vapor) && !instances.some((i) => i.ceReload)) {
 		for (const instance of instances) if (instance.root && instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(instance.type);
-		for (const instance of instances) instance.hmrReload(newComp);
-	} else for (const instance of instances) {
-		const oldComp = normalizeClassComponent(instance.type);
-		let dirtyInstances = hmrDirtyComponents.get(oldComp);
-		if (!dirtyInstances) {
-			if (oldComp !== record.initialDef) updateComponentDef(oldComp, newComp);
-			hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
-		}
-		dirtyInstances.add(instance);
-		hmrDirtyComponentsMode.set(oldComp, !!isVapor);
-		instance.appContext.propsCache.delete(instance.type);
-		instance.appContext.emitsCache.delete(instance.type);
-		instance.appContext.optionsCache.delete(instance.type);
-		if (instance.ceReload) {
-			dirtyInstances.add(instance);
-			instance.ceReload(newComp.styles);
-			dirtyInstances.delete(instance);
-		} else if (instance.parent) queueJob(() => {
-			isHmrUpdating = true;
+		const dirtyInstances = new Set(instances);
+		const rerenderedParents = /* @__PURE__ */ new Set();
+		for (const instance of instances) {
 			const parent = instance.parent;
-			if (parent.vapor) parent.hmrRerender();
-			else if (!(parent.effect.flags & 1024)) {
-				parent.renderCache = [];
-				parent.effect.run();
+			if (parent) {
+				if (!hasDirtyAncestor(instance, dirtyInstances) && !rerenderedParents.has(parent)) {
+					rerenderedParents.add(parent);
+					parent.hmrRerender();
+				}
+			} else instance.hmrReload(newComp);
+		}
+	} else {
+		const parentUpdates = /* @__PURE__ */ new Map();
+		const dirtyInstanceSet = new Set(instances);
+		for (const instance of instances) {
+			const oldComp = normalizeClassComponent(instance.type);
+			let dirtyInstances = hmrDirtyComponents.get(oldComp);
+			if (!dirtyInstances) {
+				if (oldComp !== record.initialDef) updateComponentDef(oldComp, newComp);
+				hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
 			}
-			nextTick(() => {
-				isHmrUpdating = false;
+			dirtyInstances.add(instance);
+			hmrDirtyComponentsMode.set(oldComp, !!isVapor);
+			instance.appContext.propsCache.delete(instance.type);
+			instance.appContext.emitsCache.delete(instance.type);
+			instance.appContext.optionsCache.delete(instance.type);
+			if (instance.ceReload) {
+				dirtyInstances.add(instance);
+				instance.ceReload(newComp.styles);
+				dirtyInstances.delete(instance);
+			} else if (instance.parent) {
+				const parent = instance.parent;
+				if (!hasDirtyAncestor(instance, dirtyInstanceSet)) {
+					let updates = parentUpdates.get(parent);
+					if (!updates) parentUpdates.set(parent, updates = []);
+					updates.push([instance, dirtyInstances]);
+				}
+			} else if (instance.appContext.reload) instance.appContext.reload();
+			else if (typeof window !== "undefined") window.location.reload();
+			else console.warn("[HMR] Root or manually mounted instance modified. Full reload required.");
+			if (instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(oldComp);
+		}
+		parentUpdates.forEach((updates, parent) => {
+			queueJob(() => {
+				isHmrUpdating = true;
+				if (parent.vapor) parent.hmrRerender();
+				else {
+					const i = parent;
+					if (!(i.effect.flags & 1024)) {
+						i.renderCache = [];
+						i.effect.run();
+					}
+				}
+				nextTick(() => {
+					isHmrUpdating = false;
+				});
+				updates.forEach(([instance, dirtyInstances]) => {
+					dirtyInstances.delete(instance);
+				});
 			});
-			dirtyInstances.delete(instance);
 		});
-		else if (instance.appContext.reload) instance.appContext.reload();
-		else if (typeof window !== "undefined") window.location.reload();
-		else console.warn("[HMR] Root or manually mounted instance modified. Full reload required.");
-		if (instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(oldComp);
 	}
 	queuePostFlushCb(() => {
 		hmrDirtyComponents.clear();
@@ -3148,7 +3185,7 @@ const TeleportImpl = {
 				if (parentComponent && parentComponent.isCE) (parentComponent.ce._teleportTargets || (parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
 				if (!disabled) {
 					mount(vnode, target, targetAnchor);
-					updateCssVars$1(vnode, false);
+					updateCssVars(vnode, false);
 				}
 			} else if (!disabled) warn$1("Invalid Teleport target on mount:", target, `(${typeof target})`);
 		};
@@ -3158,7 +3195,7 @@ const TeleportImpl = {
 				pendingMounts.delete(vnode);
 				if (isTeleportDisabled(vnode.props)) {
 					mount(vnode, parentNode(vnode.el) || container, vnode.anchor);
-					updateCssVars$1(vnode, true);
+					updateCssVars(vnode, true);
 				}
 				mountToTarget(vnode);
 			};
@@ -3176,7 +3213,7 @@ const TeleportImpl = {
 			}
 			if (disabled) {
 				mount(n2, container, mainAnchor);
-				updateCssVars$1(n2, true);
+				updateCssVars(n2, true);
 			}
 			mountToTarget();
 		} else {
@@ -3209,7 +3246,7 @@ const TeleportImpl = {
 				if (nextTarget) moveTeleport(n2, nextTarget, null, internals, parentComponent, 0);
 				else warn$1("Invalid Teleport target on update:", target, `(${typeof target})`);
 			} else if (wasDisabled) moveTeleport(n2, target, targetAnchor, internals, parentComponent, 1);
-			updateCssVars$1(n2, disabled);
+			updateCssVars(n2, disabled);
 		}
 	},
 	remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
@@ -3273,7 +3310,7 @@ function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScope
 			if (!vnode.targetAnchor) prepareAnchor(target, vnode, createText, insert);
 			hydrateChildren(targetNode && nextSibling(targetNode), vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized);
 		}
-		updateCssVars$1(vnode, disabled);
+		updateCssVars(vnode, disabled);
 	} else if (disabled) {
 		if (vnode.shapeFlag & 16) {
 			hydrateDisabledTeleport(node, vnode);
@@ -3284,7 +3321,7 @@ function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScope
 	return vnode.anchor && nextSibling(vnode.anchor);
 }
 const Teleport = TeleportImpl;
-function updateCssVars$1(vnode, isDisabled) {
+function updateCssVars(vnode, isDisabled) {
 	const ctx = vnode.ctx;
 	if (ctx && ctx.ut) {
 		let node, anchor;
@@ -4269,11 +4306,16 @@ function defineAsyncComponent(source) {
 				onError(err);
 				return () => errorComponent ? createVNode(errorComponent, { error: err }) : null;
 			});
-			const { loaded, error, delayed } = useAsyncComponentState(delay, timeout, onError);
+			const { loaded, error, delayed } = useAsyncComponentState(delay, timeout, onError, instance);
 			load().then(() => {
+				if (instance.isUnmounted) return;
 				loaded.value = true;
 				if (instance.parent && instance.parent.vnode && isKeepAlive(instance.parent.vnode)) instance.parent.update();
 			}).catch((err) => {
+				if (instance.isUnmounted) {
+					setPendingRequest(null);
+					return;
+				}
 				onError(err);
 				error.value = err;
 			});
@@ -4331,14 +4373,22 @@ function createAsyncComponentContext(source) {
 		setPendingRequest: (request) => pendingRequest = request
 	};
 }
-const useAsyncComponentState = (delay, timeout, onError) => {
+const useAsyncComponentState = (delay, timeout, onError, instance = currentInstance) => {
 	const loaded = /* @__PURE__ */ ref(false);
 	const error = /* @__PURE__ */ ref();
 	const delayed = /* @__PURE__ */ ref(!!delay);
-	if (delay) setTimeout(() => {
+	let timeoutTimer;
+	let delayTimer;
+	if (instance) onUnmounted(() => {
+		if (timeoutTimer != null) clearTimeout(timeoutTimer);
+		if (delayTimer != null) clearTimeout(delayTimer);
+	}, instance);
+	if (delay) delayTimer = setTimeout(() => {
+		if (instance && instance.isUnmounted) return;
 		delayed.value = false;
 	}, delay);
-	if (timeout != null) setTimeout(() => {
+	if (timeout != null) timeoutTimer = setTimeout(() => {
+		if (instance && instance.isUnmounted) return;
 		if (!loaded.value && !error.value) {
 			const err = /* @__PURE__ */ new Error(`Async component timed out after ${timeout}ms.`);
 			onError(err);
@@ -4741,6 +4791,7 @@ function renderSlot(slots, name, props = {}, fallback, noSlotted) {
 			slot: vaporSlot,
 			fallback
 		};
+		if (!noSlotted && ret.scopeId) ret.slotScopeIds = [ret.scopeId + "-s"];
 		return ret;
 	}
 	if (currentRenderingInstance && (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce)) {
@@ -5594,12 +5645,13 @@ function useModel(props, name, options = EMPTY_OBJ) {
 					for (const key of rawPropKeys) if (key === name || key === camelizedName || key === hyphenatedName) parentPassedModelValue = true;
 					else if (key === `onUpdate:${name}` || key === `onUpdate:${camelizedName}` || key === `onUpdate:${hyphenatedName}`) parentPassedModelUpdater = true;
 				}
-				if (!parentPassedModelValue || !parentPassedModelUpdater) {
+				const hasVModel = parentPassedModelValue && parentPassedModelUpdater;
+				if (!hasVModel) {
 					localValue = value;
 					trigger();
 				}
 				i.emit(`update:${name}`, emittedValue);
-				if (hasChanged(value, emittedValue) && hasChanged(value, prevSetValue) && !hasChanged(emittedValue, prevEmittedValue)) trigger();
+				if (hasChanged(value, prevSetValue) && (hasChanged(value, emittedValue) && !hasChanged(emittedValue, prevEmittedValue) || hasVModel && prevSetValue !== EMPTY_OBJ && !hasChanged(emittedValue, localValue))) trigger();
 				prevSetValue = value;
 				prevEmittedValue = emittedValue;
 			}
@@ -8468,7 +8520,7 @@ function isMemoSame(cached, memo) {
 }
 //#endregion
 //#region packages/runtime-core/src/index.ts
-const version = "3.6.0-beta.13";
+const version = "3.6.0-beta.15";
 const warn = warn$1;
 /**
 * Runtime error messages. Only exposed in dev or esm builds.
@@ -9619,7 +9671,7 @@ const TransitionGroup = /* @__PURE__ */ decorate$2({
 			prevChildren = [];
 			if (children) for (let i = 0; i < children.length; i++) {
 				const child = children[i];
-				if (child.el && child.el instanceof Element) {
+				if (child.el && child.el instanceof Element && !child.el[vShowHidden]) {
 					prevChildren.push(child);
 					setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));
 					positionMap$1.set(child, getPosition(child.el));
@@ -10580,7 +10632,7 @@ var RenderEffect = class extends ReactiveEffect {
 				this.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
 				this.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
 			}
-			if (instance.type.ce) (instance.renderEffects || (instance.renderEffects = [])).push(this);
+			(instance.renderEffects || (instance.renderEffects = [])).push(this);
 			job.i = instance;
 		}
 		this.job = job;
@@ -10648,7 +10700,10 @@ function resolveFunctionSource(source) {
 }
 function snapshotRawProps(rawProps) {
 	const snapshot = Object.create(null);
-	for (const key in rawProps) if (key !== "$") snapshot[key] = resolveSource(rawProps[key]);
+	for (const key in rawProps) if (key !== "$") {
+		const value = resolveSource(rawProps[key]);
+		snapshot[key] = () => value;
+	}
 	const dynamicSources = rawProps.$;
 	if (dynamicSources) {
 		const snapshotSources = [];
@@ -10660,7 +10715,10 @@ function snapshotRawProps(rawProps) {
 				for (const key in resolved) value[key] = resolved[key];
 				snapshotSources[i] = () => value;
 			} else {
-				for (const key in source) value[key] = resolveSource(source[key]);
+				for (const key in source) {
+					const resolved = resolveSource(source[key]);
+					value[key] = () => resolved;
+				}
 				snapshotSources[i] = value;
 			}
 		}
@@ -10960,14 +11018,16 @@ const delegatedEventHandler = (e) => {
 	});
 	while (node !== null) {
 		const handlers = node[`$evt${e.type}`];
-		if (handlers) if (isArray(handlers)) {
-			for (const handler of handlers) if (!node.disabled) {
-				handler(e);
+		if (handlers) {
+			if (isArray(handlers)) {
+				for (const handler of handlers) if (!node.disabled) {
+					handler(e);
+					if (e.cancelBubble) return;
+				}
+			} else if (!node.disabled) {
+				handlers(e);
 				if (e.cancelBubble) return;
 			}
-		} else {
-			handlers(e);
-			if (e.cancelBubble) return;
 		}
 		node = node.host && node.host !== node && node.host instanceof Node ? node.host : node.parentNode;
 	}
@@ -11334,22 +11394,77 @@ function setScopeId(block, scopeIds) {
 	if (block instanceof Element) for (const id of scopeIds) block.setAttribute(id, "");
 	else if (isVaporComponent(block)) setScopeId(block.block, scopeIds);
 	else if (isArray(block)) for (const b of block) setScopeId(b, scopeIds);
-	else if (isFragment(block)) setScopeId(block.nodes, scopeIds);
+	else if (isFragment(block)) {
+		trackScopeIdFragment(block, scopeIds, false);
+		setScopeId(block.nodes, scopeIds);
+	}
+}
+const trackedScopeIdFragments = /* @__PURE__ */ new WeakMap();
+function trackScopeIdFragment(frag, scopeIds, recursive = true) {
+	if (isInteropEnabled && isInteropFragment(frag)) setInteropFragmentScopeIds(frag, scopeIds);
+	else if (trackFragmentScopeIds(frag, scopeIds)) (frag.onBeforeInsert || (frag.onBeforeInsert = [])).push((nodes) => setScopeId(nodes, scopeIds));
+	if (recursive) trackScopeIdsInBlock(frag.nodes, scopeIds);
+}
+function trackFragmentScopeIds(frag, scopeIds) {
+	const key = scopeIds.join(" ");
+	let trackedScopeIds = trackedScopeIdFragments.get(frag);
+	if (!trackedScopeIds) {
+		trackedScopeIds = /* @__PURE__ */ new Set();
+		trackedScopeIdFragments.set(frag, trackedScopeIds);
+	} else if (trackedScopeIds.has(key)) return false;
+	trackedScopeIds.add(key);
+	return true;
+}
+function setInteropFragmentScopeIds(frag, scopeIds) {
+	const vnode = frag.vnode;
+	if (!vnode) return;
+	const existing = vnode.slotScopeIds;
+	if (!existing) {
+		vnode.slotScopeIds = scopeIds;
+		return;
+	}
+	for (let i = 0; i < scopeIds.length; i++) if (!existing.includes(scopeIds[i])) existing.push(scopeIds[i]);
+}
+function trackScopeIdsInBlock(block, scopeIds) {
+	if (isVaporComponent(block)) trackScopeIdsInBlock(block.block, scopeIds);
+	else if (isArray(block)) for (const b of block) trackScopeIdsInBlock(b, scopeIds);
+	else if (isFragment(block)) trackScopeIdFragment(block, scopeIds);
+}
+const trackedInheritedScopeIdFragments = /* @__PURE__ */ new WeakMap();
+function trackInheritedScopeIdFragment(instance, frag) {
+	let trackedInstances = trackedInheritedScopeIdFragments.get(frag);
+	if (!trackedInstances) {
+		trackedInstances = /* @__PURE__ */ new WeakSet();
+		trackedInheritedScopeIdFragments.set(frag, trackedInstances);
+	} else if (trackedInstances.has(instance)) return;
+	trackedInstances.add(instance);
+	(frag.onUpdated || (frag.onUpdated = [])).push(() => applyInheritedScopeIdToRoot(instance));
+}
+function applyInheritedScopeIdToRoot(instance) {
+	const { scopeId } = instance;
+	if (!scopeId) return;
+	const root = getRootElement(instance, (frag) => trackInheritedScopeIdFragment(instance, frag));
+	if (root) root.setAttribute(scopeId, "");
+	return root;
+}
+function trackComponentScopeId(instance) {
+	const { parent, scopeId } = instance;
+	if (!parent || !scopeId) return;
+	getRootElement(instance, (frag) => trackInheritedScopeIdFragment(instance, frag));
 }
 function setComponentScopeId(instance) {
 	const { parent, scopeId } = instance;
 	if (!parent || !scopeId) return;
-	if (isArray(instance.block) && instance.block.length > 1) return;
-	const scopeIds = [];
-	const parentScopeId = parent && parent.type.__scopeId;
-	if (parentScopeId !== scopeId) scopeIds.push(scopeId);
-	else if (parentScopeId) scopeIds.push(parentScopeId);
-	if (isInteropEnabled && parent.subTree && parent.subTree.component === instance && parent.vnode.scopeId) {
-		scopeIds.push(parent.vnode.scopeId);
+	const root = applyInheritedScopeIdToRoot(instance);
+	if (isInteropEnabled && root && parent.subTree && parent.subTree.component === instance && parent.vnode.scopeId) {
+		root.setAttribute(parent.vnode.scopeId, "");
 		const inheritedScopeIds = getInheritedScopeIds(parent.vnode, parent.parent);
-		scopeIds.push(...inheritedScopeIds);
+		for (let i = 0; i < inheritedScopeIds.length; i++) root.setAttribute(inheritedScopeIds[i], "");
 	}
-	if (scopeIds.length > 0) setScopeId(instance.block, scopeIds);
+}
+function getCurrentScopeId() {
+	const scopeOwner = getScopeOwner();
+	return scopeOwner ? scopeOwner.type.__scopeId : void 0;
 }
 //#endregion
 //#region packages/runtime-vapor/src/componentSlots.ts
@@ -11378,6 +11493,36 @@ function setCurrentSlotScopeIds(scopeIds) {
 		currentSlotScopeIds = scopeIds;
 	}
 }
+const rawSlotsOwnerMap = /* @__PURE__ */ new WeakMap();
+const rawSlotWrappersCache = /* @__PURE__ */ new WeakMap();
+function normalizeRawSlots(rawSlots) {
+	if (!rawSlots) return rawSlots;
+	const normalized = isFunction(rawSlots) ? { default: rawSlots } : rawSlots;
+	if (!rawSlotsOwnerMap.has(normalized)) rawSlotsOwnerMap.set(normalized, getScopeOwner());
+	return normalized;
+}
+function withSlotOwner(slots, fn) {
+	if (!rawSlotsOwnerMap.has(slots)) return fn();
+	const prevOwner = setCurrentSlotOwner(rawSlotsOwnerMap.get(slots) || null);
+	try {
+		return fn();
+	} finally {
+		setCurrentSlotOwner(prevOwner);
+	}
+}
+function getOwnedSlot(slots, key, slot) {
+	if (!rawSlotsOwnerMap.has(slots)) return slot;
+	let wrappers = rawSlotWrappersCache.get(slots);
+	if (!wrappers) rawSlotWrappersCache.set(slots, wrappers = /* @__PURE__ */ new Map());
+	const cached = wrappers.get(key);
+	if (cached && cached.slot === slot) return cached.wrapped;
+	const wrapped = ((...args) => withSlotOwner(slots, () => slot(...args)));
+	wrappers.set(key, {
+		slot,
+		wrapped
+	});
+	return wrapped;
+}
 const dynamicSlotsProxyHandlers = {
 	get: getSlot,
 	has: (target, key) => !!getSlot(target, key),
@@ -11390,17 +11535,14 @@ const dynamicSlotsProxyHandlers = {
 		};
 	},
 	ownKeys(target) {
-		let keys = Object.keys(target);
+		const keys = new Set(Object.keys(target).filter((k) => k !== "$"));
 		const dynamicSources = target.$;
-		if (dynamicSources) {
-			keys = keys.filter((k) => k !== "$");
-			for (const source of dynamicSources) if (isFunction(source)) {
-				const slot = resolveFunctionSource(source);
-				if (slot) if (isArray(slot)) for (const s of slot) keys.push(String(s.name));
-				else keys.push(String(slot.name));
-			} else keys.push(...Object.keys(source));
-		}
-		return keys;
+		if (dynamicSources) for (const source of dynamicSources) if (isFunction(source)) {
+			const slot = withSlotOwner(target, () => resolveFunctionSource(source));
+			if (slot) if (isArray(slot)) for (const s of slot) keys.add(String(s.name));
+			else keys.add(String(slot.name));
+		} else for (const key of Object.keys(source)) keys.add(key);
+		return [...keys];
 	},
 	set: NO,
 	deleteProperty: NO
@@ -11414,16 +11556,16 @@ function getSlot(target, key) {
 		while (i--) {
 			source = dynamicSources[i];
 			if (isFunction(source)) {
-				const slot = resolveFunctionSource(source);
+				const slot = withSlotOwner(target, () => resolveFunctionSource(source));
 				if (slot) {
 					if (isArray(slot)) {
-						for (let j = slot.length - 1; j >= 0; j--) if (String(slot[j].name) === key) return slot[j].fn;
-					} else if (String(slot.name) === key) return slot.fn;
+						for (let j = slot.length - 1; j >= 0; j--) if (String(slot[j].name) === key) return getOwnedSlot(target, key, slot[j].fn);
+					} else if (String(slot.name) === key) return getOwnedSlot(target, key, slot.fn);
 				}
-			} else if (hasOwn(source, key)) return source[key];
+			} else if (hasOwn(source, key)) return getOwnedSlot(target, key, source[key]);
 		}
 	}
-	if (hasOwn(target, key)) return target[key];
+	if (hasOwn(target, key)) return getOwnedSlot(target, key, target[key]);
 }
 /**
 * Tracks the slot owner (the component that defines the slot content).
@@ -11446,24 +11588,6 @@ function setCurrentSlotOwner(owner) {
 function getScopeOwner() {
 	return currentSlotOwner || currentInstance;
 }
-/**
-* Wrap a slot function to track the slot owner.
-*
-* This ensures:
-* 1. createSlot gets rawSlots from the correct instance (slot owner)
-* 2. elements inherit the slot owner's scopeId
-*/
-function withVaporCtx(fn) {
-	const owner = getScopeOwner();
-	return (...args) => {
-		const prevOwner = setCurrentSlotOwner(owner);
-		try {
-			return fn(...args);
-		} finally {
-			setCurrentSlotOwner(prevOwner);
-		}
-	};
-}
 function createSlot(name = "default", rawProps, fallback, flags = 0) {
 	if (isInteropEnabled && isCollectingVdomSlotVNodes) return;
 	const _insertionParent = insertionParent;
@@ -11475,6 +11599,7 @@ function createSlot(name = "default", rawProps, fallback, flags = 0) {
 	const scopeId = !(flags & 1) && instance.type.__scopeId;
 	const slotScopeIds = scopeId ? [`${scopeId}-s`] : null;
 	const once = !!(flags & 2);
+	const slotRoot = !!(flags & 4);
 	const slotProps = rawProps ? new Proxy(once ? snapshotRawProps(rawProps) : rawProps, rawPropsProxyHandlers) : EMPTY_OBJ;
 	if (once && fallback) {
 		const originalFallback = fallback;
@@ -11483,15 +11608,24 @@ function createSlot(name = "default", rawProps, fallback, flags = 0) {
 	let fragment;
 	if (/* @__PURE__ */ isRef(rawSlots._) && isInteropEnabled) {
 		if (isHydrating$1) hydrationCursor = enterHydrationCursor();
-		fragment = instance.appContext.vapor.vdomSlot(rawSlots._, name, slotProps, instance, fallback, once);
+		fragment = instance.appContext.vapor.vdomSlot(rawSlots._, name, slotProps, instance, fallback, once, slotRoot);
 	} else {
 		if (isHydrating$1) hydrationCursor = captureHydrationCursor();
-		const slotFragment = fragment = new SlotFragment();
-		slotFragment.forwarded = currentSlotOwner != null && currentSlotOwner !== currentInstance;
+		const isCustomElementSlot = !!(instance.ce || instance.parent && isAsyncWrapper(instance.parent) && instance.parent.ce);
+		const slotFragment = isHydrating$1 || !!fallback || !!getCurrentSlotBoundary() || isCustomElementSlot ? new SlotFragment(slotRoot) : void 0;
+		let dynamicFragment;
+		if (slotFragment) {
+			fragment = slotFragment;
+			if (isHydrating$1) slotFragment.forwarded = currentSlotOwner != null && currentSlotOwner !== currentInstance;
+		} else {
+			dynamicFragment = new DynamicFragment("slot", false, false);
+			dynamicFragment.isSlot = true;
+			fragment = dynamicFragment;
+		}
 		const isDynamicName = isFunction(name);
 		const renderSlot = () => {
 			const slotName = isFunction(name) ? name() : name;
-			if (instance.ce || instance.parent && isAsyncWrapper(instance.parent) && instance.parent.ce) {
+			if (isCustomElementSlot) {
 				const el = /* @__PURE__ */ createElement("slot");
 				const setSlotProps = () => {
 					setDynamicProps(el, [slotProps, slotName !== "default" ? { name: slotName } : {}]);
@@ -11507,8 +11641,10 @@ function createSlot(name = "default", rawProps, fallback, flags = 0) {
 				return;
 			}
 			const slot = getSlot(rawSlots, slotName);
-			if (slot) slotFragment.updateSlot(getBoundSlot(slot), fallback);
-			else slotFragment.updateSlot(void 0, fallback);
+			if (slot) if (slotFragment) slotFragment.updateSlot(getBoundSlot(slot), fallback);
+			else dynamicFragment.update(getBoundSlot(slot));
+			else if (slotFragment) slotFragment.updateSlot(void 0, fallback);
+			else dynamicFragment.update();
 		};
 		let cachedSlot;
 		let cachedBoundSlot;
@@ -11533,7 +11669,8 @@ function createSlot(name = "default", rawProps, fallback, flags = 0) {
 		if (slotScopeIds) setScopeId(fragment, slotScopeIds);
 		if (_insertionParent) insert(fragment, _insertionParent, _insertionAnchor);
 	} else {
-		if (fragment.insert) fragment.hydrate();
+		if (isInteropEnabled && isInteropFragment(fragment)) fragment.hydrate();
+		if (slotScopeIds) trackScopeIdFragment(fragment, slotScopeIds);
 		exitHydrationCursor(hydrationCursor);
 	}
 	return fragment;
@@ -11578,7 +11715,7 @@ function setBlockKey(block, key) {
 		if (block.length === 1) setBlockKey(block[0], key);
 	} else {
 		block.$key = key;
-		if (block.vnode) block.vnode.key = key;
+		if (isInteropEnabled && block.vnode) block.vnode.key = key;
 		setBlockKey(block.nodes, key);
 	}
 }
@@ -11598,9 +11735,10 @@ function isVaporTransition(component) {
 }
 //#endregion
 //#region packages/runtime-vapor/src/fragment.ts
-const EMPTY_BLOCK = EMPTY_ARR;
+const EMPTY_BLOCK$1 = EMPTY_ARR;
 var VaporFragment = class {
 	constructor(nodes) {
+		this.__vf = true;
 		this.renderInstance = currentInstance;
 		this.slotOwner = currentSlotOwner;
 		this.inheritedSlotBoundary = currentSlotBoundary;
@@ -11609,30 +11747,32 @@ var VaporFragment = class {
 	}
 	runWithRenderCtx(fn, scope) {
 		const prevInstance = setCurrentInstance(this.renderInstance, scope);
-		const keepAliveCtx = isKeepAliveEnabled ? this.keepAliveCtx || null : null;
-		if (currentSlotOwner === this.slotOwner && currentSlotBoundary === this.inheritedSlotBoundary && (!isKeepAliveEnabled || currentKeepAliveCtx === keepAliveCtx)) try {
-			return fn();
-		} finally {
-			setCurrentInstance(...prevInstance);
-		}
-		const prevSlotOwner = setCurrentSlotOwner(this.slotOwner);
-		let prevKeepAliveCtx = null;
-		if (isKeepAliveEnabled) prevKeepAliveCtx = setCurrentKeepAliveCtx(keepAliveCtx);
-		const prevBoundary = setCurrentSlotBoundary(this.inheritedSlotBoundary);
 		try {
-			return fn();
+			return runWithFragmentCtx(this, fn);
 		} finally {
-			setCurrentSlotBoundary(prevBoundary);
-			if (isKeepAliveEnabled) setCurrentKeepAliveCtx(prevKeepAliveCtx);
-			setCurrentSlotOwner(prevSlotOwner);
 			setCurrentInstance(...prevInstance);
 		}
 	}
 };
+function runWithFragmentCtx(fragment, fn) {
+	const keepAliveCtx = isKeepAliveEnabled ? fragment.keepAliveCtx || null : null;
+	if (currentSlotOwner === fragment.slotOwner && currentSlotBoundary === fragment.inheritedSlotBoundary && (!isKeepAliveEnabled || currentKeepAliveCtx === keepAliveCtx)) return fn();
+	const prevSlotOwner = setCurrentSlotOwner(fragment.slotOwner);
+	let prevKeepAliveCtx = null;
+	if (isKeepAliveEnabled) prevKeepAliveCtx = setCurrentKeepAliveCtx(keepAliveCtx);
+	const prevBoundary = setCurrentSlotBoundary(fragment.inheritedSlotBoundary);
+	try {
+		return fn();
+	} finally {
+		setCurrentSlotBoundary(prevBoundary);
+		if (isKeepAliveEnabled) setCurrentKeepAliveCtx(prevKeepAliveCtx);
+		setCurrentSlotOwner(prevSlotOwner);
+	}
+}
 var ForFragment = class extends VaporFragment {
-	constructor(nodes) {
+	constructor(nodes, trackSlotBoundary) {
 		super(nodes);
-		trackSlotBoundaryDirtying(this);
+		if (trackSlotBoundary) trackSlotBoundaryDirtying(this);
 	}
 	onReset(fn) {
 		(this.resetListeners || (this.resetListeners = [])).push(fn);
@@ -11664,8 +11804,9 @@ function queueAnchorInsert(parentNode$1, nextNode, createAnchor) {
 	});
 }
 var DynamicFragment = class extends VaporFragment {
-	constructor(anchorLabel, keyed = false, locate = true, trackSlotBoundary = true) {
-		super(EMPTY_BLOCK);
+	constructor(anchorLabel, keyed = false, locate = true, trackSlotBoundary = false) {
+		super(EMPTY_BLOCK$1);
+		this.__df = true;
 		if (keyed) this.keyed = true;
 		if (isTransitionEnabled && currentInstance && isVaporTransition(currentInstance.type)) this.inTransition = true;
 		if (isHydrating$1) {
@@ -11677,12 +11818,17 @@ var DynamicFragment = class extends VaporFragment {
 		}
 		if (trackSlotBoundary) trackSlotBoundaryDirtying(this);
 	}
-	update(render, key = render, noScope = false) {
+	update(render, key = render, noScope = false, shouldInsert = true) {
 		if (key === this.current) {
-			if (isHydrating$1 && this.anchorLabel !== "slot") this.hydrate(true);
+			if (isHydrating$1 && !this.isSlot) this.hydrate(true);
 			return;
 		}
 		const transition = isTransitionEnabled ? this.$transition : void 0;
+		const wasMounted = this.current !== void 0;
+		if (wasMounted) {
+			const onBeforeUpdate = this.onBeforeUpdate;
+			if (onBeforeUpdate) for (let i = 0; i < onBeforeUpdate.length; i++) onBeforeUpdate[i]();
+		}
 		if (transition && transition.state.isLeaving) {
 			this.current = key;
 			const pending = this.pending;
@@ -11699,8 +11845,8 @@ var DynamicFragment = class extends VaporFragment {
 		}
 		const instance = currentInstance;
 		const prevSub = setActiveSub();
-		const parent = isHydrating$1 ? null : this.anchor.parentNode;
-		if (this.current !== void 0) {
+		const parent = !isHydrating$1 && shouldInsert ? this.anchor.parentNode : null;
+		if (wasMounted) {
 			const scope = this.scope;
 			if (scope) {
 				let retainScope = false;
@@ -11716,8 +11862,8 @@ var DynamicFragment = class extends VaporFragment {
 						const pending = this.pending;
 						if (pending) {
 							this.pending = void 0;
-							this.renderBranch(pending.render, transition, parent, pending.key, pending.noScope);
-						} else this.renderBranch(render, transition, parent, key, noScope);
+							this.renderBranch(pending.render, transition, parent, pending.key, pending.noScope, true);
+						} else this.renderBranch(render, transition, parent, key, noScope, true);
 					} finally {
 						setCurrentInstance(...prevInstance);
 					}
@@ -11731,7 +11877,7 @@ var DynamicFragment = class extends VaporFragment {
 		}
 		let reusingDeferredAnchor = false;
 		if (isHydrating$1) {
-			const isRevivingDeferredBranch = isInDeferredHydrationBoundary() && !!render && this.anchorLabel !== "slot" && !isValidBlock(this.nodes);
+			const isRevivingDeferredBranch = isInDeferredHydrationBoundary() && !!render && !this.isSlot && !isValidBlock(this.nodes);
 			reusingDeferredAnchor = isRevivingDeferredBranch && !!this.anchor && !!this.anchor.parentNode;
 			if (isRevivingDeferredBranch) {
 				let slotEndAnchor = null;
@@ -11739,11 +11885,11 @@ var DynamicFragment = class extends VaporFragment {
 				if (anchor) setCurrentHydrationNode(markHydrationAnchor(anchor));
 			}
 		}
-		this.renderBranch(render, transition, parent, key, noScope);
+		this.renderBranch(render, transition, parent, key, noScope, wasMounted || !!parent);
 		setActiveSub(prevSub);
-		if (isHydrating$1 && this.anchorLabel !== "slot" && !reusingDeferredAnchor) this.hydrate(render == null);
+		if (isHydrating$1 && !this.isSlot && !reusingDeferredAnchor) this.hydrate(render == null);
 	}
-	renderBranch(render, transition, parent, key, noScope = false) {
+	renderBranch(render, transition, parent, key, noScope = false, notifyUpdated = !!parent) {
 		this.current = key;
 		if (render) {
 			const keepAliveCtx = isKeepAliveEnabled ? this.keepAliveCtx : null;
@@ -11755,7 +11901,7 @@ var DynamicFragment = class extends VaporFragment {
 			} else this.scope = void 0;
 			const renderBranch = () => {
 				try {
-					this.nodes = this.runWithRenderCtx(() => (useScope ? this.scope.run(render) : render()) || EMPTY_BLOCK, this.scope);
+					this.nodes = this.runWithRenderCtx(() => (useScope ? this.scope.run(render) : render()) || EMPTY_BLOCK$1, this.scope);
 				} finally {
 					const key = this.keyed ? this.current : this.$key;
 					if (key !== void 0 && (transition || this.inTransition || keepAliveCtx)) setBlockKey(this.nodes, key);
@@ -11772,14 +11918,12 @@ var DynamicFragment = class extends VaporFragment {
 			}
 		} else {
 			this.scope = void 0;
-			this.nodes = EMPTY_BLOCK;
-		}
-		if (parent) {
-			const onUpdated = this.onUpdated;
-			if (onUpdated) onUpdated.forEach((hook) => hook(this.nodes));
+			this.nodes = EMPTY_BLOCK$1;
 		}
+		const onUpdated = this.onUpdated;
+		if (notifyUpdated && onUpdated) onUpdated.forEach((hook) => hook(this.nodes));
 	}
-	hydrate(isEmpty = false, isSlot = false) {
+	hydrate(isEmpty = false) {
 		if (!isHydrating$1) return;
 		let advanceAfterRestore = null;
 		let exitHydrationBoundary;
@@ -11814,12 +11958,12 @@ var DynamicFragment = class extends VaporFragment {
 						return;
 					}
 				}
-				if (!isSlot && this.anchorLabel && currentHydrationNode && !isHydratingSlotFallbackActive() && !isComment(currentHydrationNode, "]")) {
+				if (!this.isSlot && this.anchorLabel && currentHydrationNode && !isHydratingSlotFallbackActive() && !isComment(currentHydrationNode, "]")) {
 					const parentNode$4 = /* @__PURE__ */ parentNode(currentHydrationNode);
 					const anchor = nextLogicalSibling(currentHydrationNode);
 					const reusableAnchor = anchor && anchor.nodeType === 8 && isReusableDynamicFragmentAnchor(anchor, this.anchorLabel) && /* @__PURE__ */ parentNode(anchor) ? anchor : null;
 					if (parentNode$4) {
-						this.nodes = EMPTY_BLOCK;
+						this.nodes = EMPTY_BLOCK$1;
 						if (reusableAnchor) reuseAnchor(reusableAnchor);
 						else cleanupAndInsertRuntimeAnchor(parentNode$4, anchor, currentHydrationNode, anchor);
 						return;
@@ -11828,7 +11972,7 @@ var DynamicFragment = class extends VaporFragment {
 			}
 			if (this.anchorLabel && !isValidBlock(this.nodes) && this.nodes instanceof Comment && isReusableDynamicFragmentAnchor(this.nodes, this.anchorLabel) && /* @__PURE__ */ parentNode(this.nodes)) {
 				const anchor = this.nodes;
-				this.nodes = EMPTY_BLOCK;
+				this.nodes = EMPTY_BLOCK$1;
 				reuseAnchor(anchor);
 				return;
 			}
@@ -11836,15 +11980,15 @@ var DynamicFragment = class extends VaporFragment {
 				const parentNode$5 = /* @__PURE__ */ parentNode(currentHydrationNode);
 				const nextNode = nextLogicalSibling(currentHydrationNode);
 				if (parentNode$5) {
-					this.nodes = EMPTY_BLOCK;
+					this.nodes = EMPTY_BLOCK$1;
 					cleanupAndInsertRuntimeAnchor(parentNode$5, nextNode, currentHydrationNode, nextNode);
 					return;
 				}
 			}
 			const currentSlotEndAnchor = getCurrentSlotEndAnchor();
-			const forwardedSlot = isSlot ? this.forwarded : false;
-			const slotAnchor = isSlot ? currentSlotEndAnchor : null;
-			const closeOwner = getDynamicCloseOwner(isSlot, forwardedSlot, this.anchorLabel, this.nodes, currentSlotEndAnchor);
+			const forwardedSlot = this.isSlot ? this.forwarded : false;
+			const slotAnchor = this.isSlot ? currentSlotEndAnchor : null;
+			const closeOwner = getDynamicCloseOwner(!!this.isSlot, forwardedSlot, this.anchorLabel, this.nodes, currentSlotEndAnchor);
 			if (closeOwner === 1) {
 				const anchor = locateHydrationBoundaryClose(slotAnchor || currentHydrationNode, slotAnchor || null);
 				if (isComment(anchor, "]")) {
@@ -11870,7 +12014,7 @@ var DynamicFragment = class extends VaporFragment {
 				parentNode$3 = currentSlotEndAnchor.parentNode;
 				nextNode = currentSlotEndAnchor;
 			} else {
-				const node = findBlockNode(this.nodes);
+				const node = findBlockBoundary(this.nodes);
 				parentNode$3 = node.parentNode;
 				nextNode = node.nextNode;
 			}
@@ -11914,58 +12058,14 @@ function getRedirectedBoundary(boundary) {
 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;
-	}
-	return fragment(block, (block) => walkSlotFallbackBlock(block, node, fragment));
-}
-function resolveSlotFallbackCarrierOwner(block) {
-	let owner = null;
-	walkSlotFallbackBlock(block, () => false, (block) => {
-		owner = block;
-		return true;
+	let prevValid = isValidBlock(fragment);
+	(fragment.onBeforeUpdate || (fragment.onBeforeUpdate = [])).push(() => {
+		prevValid = isValidBlock(fragment);
 	});
-	return owner;
-}
-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 false;
-	});
-	return node;
-}
-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;
-}
-function mutateSlotFallbackCarrier(block, apply) {
-	walkSlotFallbackBlock(block, (block) => {
-		if (!(block instanceof Comment)) apply(block);
-		return false;
-	}, (block) => {
-		apply(block);
-		return false;
+	(fragment.onUpdated || (fragment.onUpdated = [])).push(() => {
+		const valid = isValidBlock(fragment);
+		if (valid !== prevValid) boundary.markDirty();
+		prevValid = valid;
 	});
 }
 function hasSlotFallback(boundary) {
@@ -11975,161 +12075,145 @@ function hasSlotFallback(boundary) {
 	}
 	return false;
 }
-function renderSlotFallback(boundary, scope, ...args) {
-	const [block, hasFallback] = renderSlotFallbackBlock(boundary || null, scope, args);
-	return hasFallback ? block : void 0;
-}
-function renderSlotFallbackBlock(boundary, scope, args) {
-	if (!boundary) return [[], false];
+function renderSlotFallback(boundary, scope) {
+	if (!boundary) return;
 	const localFallback = boundary.getFallback();
-	if (!localFallback) return renderSlotFallbackBlock(boundary.parent, scope, args);
-	const renderFallback = () => withOwnedSlotBoundary(getRedirectedBoundary(boundary), () => localFallback(...args));
-	const local = boundary.run(() => (scope ? scope.run(renderFallback) : renderFallback()) || [], scope);
-	if (isValidBlock(local)) return [local, true];
-	const [inherited] = renderSlotFallbackBlock(boundary.parent, scope, args);
-	return [resolveSlotFallbackCarrierOwner(local) ? [inherited, local] : inherited, true];
-}
-function getSlotEffectiveOutput(outlet) {
-	return outlet.activeFallback || outlet.getContent();
-}
-function isSlotFallbackContentValid(outlet) {
-	return outlet.isContentValid ? outlet.isContentValid() : isValidBlock(outlet.getContent());
-}
-function markSlotFallbackDirty(outlet) {
-	if (outlet.isDisposed && outlet.isDisposed()) return;
-	if (outlet.isRenderingFallback) {
-		if (isHydrating$1) outlet.pendingRecheck = true;
+	if (!localFallback) return renderSlotFallback(boundary.parent, scope);
+	const renderFallback = () => withOwnedSlotBoundary(getRedirectedBoundary(boundary), () => localFallback());
+	const local = boundary.run(() => scope.run(renderFallback) || [], scope);
+	if (isValidBlock(local)) return local;
+	const inherited = renderSlotFallback(boundary.parent, scope);
+	return inherited === void 0 ? local : inherited;
+}
+function detachBlock(block, parent) {
+	if (block instanceof Node) {
+		if (block.parentNode === parent) removeNode(block, parent);
+	} else if (isVaporComponent(block)) {
+		if (block.block) detachBlock(block.block, parent);
+	} else if (isArray(block)) for (let i = 0; i < block.length; i++) detachBlock(block[i], parent);
+	else {
+		detachBlock(block.nodes, parent);
+		if (!(block instanceof SlotFragment) && block.anchor && block.anchor.parentNode === parent) removeNode(block.anchor, parent);
+	}
+}
+function markSlotFallbackDirty(state) {
+	if (state.isDisposed()) return;
+	if (state.isRenderingFallback) {
+		state.pendingRecheck = true;
 		return;
 	}
-	if (outlet.isBusy && outlet.isBusy()) {
-		outlet.pendingRecheck = true;
+	if (state.isBusy()) {
+		state.pendingRecheck = true;
 		return;
 	}
-	recheckSlotFallback(outlet, true);
+	recheckSlotFallback(state, true);
 }
-function clearSlotFallback(outlet) {
-	if (outlet.activeFallback) {
-		const parentNode = outlet.getParentNode();
-		if (parentNode) remove(outlet.activeFallback, parentNode);
-		outlet.activeFallback = null;
+function clearSlotFallback(state) {
+	const fallback = state.activeFallback;
+	if (fallback) {
+		const parentNode = state.getParentNode();
+		if (parentNode) remove(fallback, parentNode);
+		state.activeFallback = null;
 	}
-	if (outlet.fallbackScope) {
-		outlet.fallbackScope.stop();
-		outlet.fallbackScope = void 0;
+	if (state.fallbackScope) {
+		state.fallbackScope.stop();
+		state.fallbackScope = void 0;
 	}
 }
-function renderSlotFallbackForOutlet(outlet) {
-	const scope = new EffectScope();
+function renderSlotFallbackState(state) {
+	const scope = new EffectScope(true);
 	let renderedFallback;
-	outlet.isRenderingFallback = true;
+	state.isRenderingFallback = true;
 	try {
-		renderedFallback = renderSlotFallback(outlet.boundary, scope) || void 0;
+		renderedFallback = renderSlotFallback(state.boundary, scope);
 	} catch (err) {
 		scope.stop();
 		throw err;
 	} finally {
-		outlet.isRenderingFallback = false;
+		state.isRenderingFallback = false;
 	}
 	if (!renderedFallback) {
 		scope.stop();
-		return { found: false };
+		return;
 	}
 	return {
-		found: true,
 		block: renderedFallback,
 		scope
 	};
 }
-function syncSlotFallbackOrder(outlet, block) {
-	if (!isFragment(block) || !isArray(block.nodes) || block.nodes.length < 2) return;
-	const carrierNodes = collectBlockNodes(outlet.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;
-	}
-}
-function ensureSlotFallbackOrderHook(outlet, block) {
-	if (!isFragment(block)) return;
-	const fragment = block;
-	if (fragment.hasSlotFallbackOrderHook) return;
-	(fragment.onUpdated || (fragment.onUpdated = [])).push(() => syncSlotFallbackOrder(outlet, fragment));
-	fragment.hasSlotFallbackOrderHook = true;
-}
-function insertActiveSlotFallback(outlet) {
-	if (isHydrating$1 || !outlet.activeFallback) return;
-	const parentNode = outlet.getParentNode();
+function insertActiveSlotFallback(state) {
+	const fallback = state.activeFallback;
+	if (isHydrating$1 || !fallback || !isValidBlock(fallback)) return;
+	const parentNode = state.getParentNode();
 	if (!parentNode) return;
-	const carrierAnchor = findFirstSlotFallbackCarrierNode(outlet.getContent());
-	insert(outlet.activeFallback, parentNode, carrierAnchor && carrierAnchor.parentNode === parentNode ? carrierAnchor : outlet.getAnchor());
+	insert(fallback, parentNode, state.getAnchor());
 }
-function commitSlotFallback(outlet, block, scope) {
-	outlet.activeFallback = block;
-	outlet.fallbackScope = scope;
-	ensureSlotFallbackOrderHook(outlet, block);
+function commitSlotFallback(state, block, scope, detachContent) {
+	const parentNode = state.getParentNode();
+	if (detachContent && !isHydrating$1 && parentNode) detachBlock(state.getContent(), parentNode);
+	state.activeFallback = block;
+	state.fallbackScope = scope;
 	if (isTransitionEnabled) {
-		const transitionOutlet = outlet;
-		if (transitionOutlet.$transition) {
+		const transitionState = state;
+		if (transitionState.$transition) {
 			setBlockKey(block, "_fb");
-			transitionOutlet.$transition = applyTransitionHooks(block, transitionOutlet.$transition);
+			transitionState.$transition = applyTransitionHooks(block, transitionState.$transition);
 		}
 	}
-	insertActiveSlotFallback(outlet);
+	insertActiveSlotFallback(state);
 }
-function syncActiveSlotFallback(outlet) {
-	if (!outlet.activeFallback) return;
-	const activeFallback = outlet.activeFallback;
-	queuePostFlushCb(() => {
-		syncSlotFallbackOrder(outlet, activeFallback);
-	});
+function renderAndCommitSlotFallback(state, hadFallback) {
+	const result = renderSlotFallbackState(state);
+	clearSlotFallback(state);
+	if (result) {
+		commitSlotFallback(state, result.block, result.scope, !hadFallback);
+		if (state.pendingRecheck) {
+			state.pendingRecheck = false;
+			recheckSlotFallback(state, true);
+		}
+	}
 }
-function disposeSlotFallback(outlet) {
-	clearSlotFallback(outlet);
-	outlet.pendingRecheck = false;
-	outlet.lastEffectiveValid = void 0;
+function disposeSlotFallback(state) {
+	clearSlotFallback(state);
+	state.pendingRecheck = false;
+	state.lastNodesValid = void 0;
 }
-function recheckSlotFallback(outlet, force = false) {
-	if (outlet.isRenderingFallback) {
-		outlet.pendingRecheck = true;
+function recheckSlotFallback(state, force = false) {
+	if (state.isRenderingFallback) {
+		state.pendingRecheck = true;
 		return;
 	}
-	const prevValid = outlet.lastEffectiveValid === void 0 ? outlet.activeFallback ? isValidBlock(outlet.activeFallback) : isSlotFallbackContentValid(outlet) : outlet.lastEffectiveValid;
-	if (isSlotFallbackContentValid(outlet)) clearSlotFallback(outlet);
-	else {
-		if (force) clearSlotFallback(outlet);
-		if (outlet.activeFallback) insertActiveSlotFallback(outlet);
-		else {
-			const result = renderSlotFallbackForOutlet(outlet);
-			if (result.found) {
-				commitSlotFallback(outlet, result.block, result.scope);
-				if (outlet.pendingRecheck && outlet.rerunRecheckAfterFallbackRender !== false) {
-					outlet.pendingRecheck = false;
-					recheckSlotFallback(outlet, true);
-				}
-			} else clearSlotFallback(outlet);
-		}
+	const fallback = state.activeFallback;
+	const fallbackValid = fallback ? isValidBlock(fallback) : false;
+	const contentValid = state.isContentValid();
+	const prevNodesValid = state.lastNodesValid === void 0 ? fallback ? fallbackValid : contentValid : state.lastNodesValid;
+	if (!force && contentValid && !fallback && prevNodesValid) {
+		state.syncNodes();
+		state.lastNodesValid = true;
+		return;
 	}
-	const nextValid = outlet.activeFallback ? isValidBlock(outlet.activeFallback) : isSlotFallbackContentValid(outlet);
-	if (outlet.syncEffectiveOutput) outlet.syncEffectiveOutput();
-	outlet.lastEffectiveValid = nextValid;
-	if (prevValid !== nextValid) outlet.notifyFallbackValidityChange();
+	if (contentValid) {
+		const content = state.getContent();
+		const hadFallback = !!fallback;
+		clearSlotFallback(state);
+		if (!isHydrating$1 && hadFallback) {
+			const parentNode = state.getParentNode();
+			if (parentNode) insert(content, parentNode, state.getAnchor());
+		}
+	} else if (fallback) {
+		if (prevNodesValid) {
+			if (!fallbackValid && !hasSlotFallback(state.boundary.parent)) {
+				const parentNode = state.getParentNode();
+				if (parentNode) detachBlock(fallback, parentNode);
+			} else if (force) renderAndCommitSlotFallback(state, true);
+		} else if (fallbackValid) insertActiveSlotFallback(state);
+		else if (force) renderAndCommitSlotFallback(state, true);
+	} else renderAndCommitSlotFallback(state, false);
+	const nextFallback = state.activeFallback;
+	const nextNodesValid = nextFallback ? isValidBlock(nextFallback) : state.isContentValid();
+	state.syncNodes();
+	state.lastNodesValid = nextNodesValid;
+	if (prevNodesValid !== nextNodesValid) state.notifyFallbackValidityChange();
 }
 let currentHydratingSlotBoundaryState = null;
 function setCurrentHydratingSlotBoundaryState(state) {
@@ -12184,16 +12268,18 @@ function isReusableDynamicFragmentAnchor(node, anchorLabel) {
 	return isComment(node, anchorLabel) || isComment(node, "") && (anchorLabel === "dynamic-component" || anchorLabel === "async component" || anchorLabel === "keyed");
 }
 var SlotFragment = class extends DynamicFragment {
-	constructor() {
+	constructor(notifyParent = false) {
 		super("slot", false, false, false);
+		this.isSlot = true;
 		this.disposed = false;
 		this.forwarded = false;
 		this.parentSlotBoundary = getCurrentSlotBoundary();
 		this.activeFallback = null;
 		this.pendingRecheck = false;
 		this.isRenderingFallback = false;
-		this.rerunRecheckAfterFallbackRender = false;
+		this.content = EMPTY_BLOCK$1;
 		this.isUpdatingSlot = false;
+		this.notifyParent = notifyParent;
 		if (!isHydrating$1) this.insert = (parent, anchor) => this.insertSlot(parent, anchor);
 		this.remove = (parent) => this.removeSlot(parent);
 	}
@@ -12218,55 +12304,46 @@ var SlotFragment = class extends DynamicFragment {
 	get slotFallbackBoundary() {
 		return this.ensureSlotFallbackBoundary();
 	}
-	getEffectiveOutput() {
-		return getSlotEffectiveOutput(this);
-	}
 	insertSlot(parent, anchor) {
 		this.disposed = false;
-		if (this.fallbackBlock) {
-			insert(this.fallbackBlock, parent, anchor);
-			mutateSlotFallbackCarrier(this.nodes, (block) => insert(block, parent, anchor));
-			return;
-		}
 		insert(this.nodes, parent, anchor);
 	}
 	removeSlot(parent) {
 		this.disposed = true;
-		if (this.fallbackBlock) mutateSlotFallbackCarrier(this.nodes, (block) => remove(block, parent));
-		else remove(this.nodes, parent);
+		const nodes = this.nodes;
+		remove(nodes, parent);
+		if (this.activeFallback === nodes) this.activeFallback = null;
 		disposeSlotFallback(this);
 	}
+	updateContent(render, key) {
+		this.nodes = this.content;
+		this.update(render, key, false, !this.activeFallback);
+		this.content = this.nodes;
+	}
 	updateSlot(render, fallback, key = render || fallback) {
 		const prevLocalFallback = this.localFallback;
 		this.localFallback = fallback;
-		const fallbackChanged = prevLocalFallback !== fallback;
-		const fastSlotKey = key === void 0 ? render : key;
-		if (!isHydrating$1 && !fallback && !this.parentSlotBoundary && !this._slotFallbackBoundary) {
-			this.update(render, fastSlotKey);
-			return;
-		}
 		const boundary = this.slotFallbackBoundary;
-		const slotRender = render ? () => withOwnedSlotBoundary(boundary, render) : () => [];
-		const slotKey = key === void 0 ? slotRender : key;
+		const slotRender = render ? () => withOwnedSlotBoundary(boundary, render) : () => EMPTY_BLOCK$1;
 		this.isUpdatingSlot = true;
 		this.pendingRecheck = false;
 		try {
-			const shouldForce = fallbackChanged;
+			const shouldForce = prevLocalFallback !== fallback;
 			if (isHydrating$1) withHydratingSlotBoundary(() => {
 				const prev = isHydratingSlotFallbackActive();
 				try {
 					if (hasSlotFallback(boundary)) setCurrentHydratingSlotFallbackActive(true);
-					this.update(slotRender, slotKey);
-					const contentValid = isValidBlock(this.nodes);
+					this.updateContent(slotRender, key);
+					const contentValid = isValidBlock(this.content);
 					recheckSlotFallback(this, shouldForce);
 					if (!hasSlotFallback(boundary) || contentValid) setCurrentHydratingSlotFallbackActive(prev);
-					this.hydrate(!isValidBlock(this.getEffectiveOutput()), true);
+					this.hydrate(!isValidBlock(this.nodes));
 				} finally {
 					setCurrentHydratingSlotFallbackActive(prev);
 				}
 			});
 			else {
-				this.update(slotRender, slotKey);
+				this.updateContent(slotRender, key);
 				recheckSlotFallback(this, shouldForce);
 			}
 		} finally {
@@ -12275,7 +12352,7 @@ var SlotFragment = class extends DynamicFragment {
 		}
 	}
 	getContent() {
-		return this.nodes;
+		return this.content;
 	}
 	getParentNode() {
 		return this.anchor ? this.anchor.parentNode : null;
@@ -12289,15 +12366,27 @@ var SlotFragment = class extends DynamicFragment {
 	isDisposed() {
 		return this.disposed;
 	}
+	isContentValid() {
+		return isValidBlock(this.content);
+	}
+	syncNodes() {
+		this.nodes = this.activeFallback || this.content;
+	}
 	notifyFallbackValidityChange() {
-		if (this.parentSlotBoundary) this.parentSlotBoundary.markDirty();
+		if (this.notifyParent && this.parentSlotBoundary) this.parentSlotBoundary.markDirty();
 	}
 };
 function isFragment(val) {
-	return val instanceof VaporFragment;
+	return !!(val && val.__vf);
+}
+function isInteropFragment(val) {
+	return isFragment(val) && val.vnode !== void 0;
 }
 function isDynamicFragment(val) {
-	return val instanceof DynamicFragment;
+	return !!(val && val.__df);
+}
+function isSlotFragment(val) {
+	return isDynamicFragment(val) && !!val.isSlot;
 }
 //#endregion
 //#region packages/runtime-vapor/src/teleport.ts
@@ -12310,7 +12399,7 @@ function isVaporTeleport(value) {
 	return !!(value && value.__isTeleport && value.__vapor);
 }
 function isTeleportFragment(value) {
-	return !!(value && value.__isTeleportFragment);
+	return !!(value && value.__tf);
 }
 //#endregion
 //#region packages/runtime-vapor/src/block.ts
@@ -12323,11 +12412,9 @@ function isValidBlock(block) {
 	else if (isVaporComponent(block)) return isValidBlock(block.block);
 	else if (isArray(block)) return block.length > 0 && block.some(isValidBlock);
 	else {
-		const isBlockValid = block.isBlockValid;
-		if (isBlockValid) return isBlockValid.call(block);
+		if (isInteropEnabled && block.isBlockValid) return block.isBlockValid();
 		if (block.validityPending) return true;
-		const getEffectiveOutput = block.getEffectiveOutput;
-		return isValidBlock(getEffectiveOutput ? getEffectiveOutput.call(block) : block.nodes);
+		return isValidBlock(block.nodes);
 	}
 }
 function insert(block, parent, anchor = null, parentSuspense) {
@@ -12413,7 +12500,7 @@ function normalizeBlock(block) {
 	}
 	return nodes;
 }
-function findBlockNode(block) {
+function findBlockBoundary(block) {
 	const lastChild = findLastChild(block);
 	let { parentNode, nextSibling: nextNode } = lastChild;
 	if (nextNode && isComment(nextNode, "]") && isFragmentBlock(block) && !isComment(lastChild, "]")) nextNode = nextNode.nextSibling;
@@ -12440,73 +12527,42 @@ function isFragmentBlock(block) {
 //#endregion
 //#region packages/runtime-vapor/src/hmr.ts
 function hmrRerender(instance) {
-	const normalized = normalizeBlock(instance.block);
-	const parent = normalized[0].parentNode;
-	const anchor = normalized[normalized.length - 1].nextSibling;
-	instance.scope.reset();
+	const { parentNode, nextNode: anchor } = findBlockBoundary(instance.block);
+	const parent = parentNode;
+	if (instance.renderEffects) {
+		instance.renderEffects.forEach((e) => e.stop());
+		instance.renderEffects.length = 0;
+	}
 	remove(instance.block, parent);
 	const prev = setCurrentInstance(instance);
 	pushWarningContext(instance);
-	devRender(instance);
-	popWarningContext();
-	setCurrentInstance(...prev);
+	try {
+		devRender(instance);
+	} finally {
+		popWarningContext();
+		setCurrentInstance(...prev);
+	}
 	insert(instance.block, parent, anchor);
 }
 function hmrReload(instance, newComp) {
-	if (isKeepAliveEnabled && instance.parent && isKeepAlive(instance.parent)) {
-		instance.parent.hmrRerender();
+	const parentInstance = instance.parent;
+	if (parentInstance) {
+		parentInstance.hmrRerender();
 		return;
 	}
-	const normalized = normalizeBlock(instance.block);
-	const parent = normalized[0].parentNode;
-	const anchor = normalized[normalized.length - 1].nextSibling;
+	const { parentNode, nextNode: anchor } = findBlockBoundary(instance.block);
+	const parent = parentNode;
 	unmountComponent(instance, parent);
-	const parentInstance = instance.parent;
 	const prev = setCurrentInstance(parentInstance);
-	const newInstance = createComponent(newComp, instance.rawProps, instance.rawSlots, instance.isSingleRoot, void 0, instance.appContext);
-	setCurrentInstance(...prev);
-	mountComponent(newInstance, parent, anchor);
-	updateParentBlockOnHmrReload(parentInstance, instance, newInstance);
-	updateParentTeleportOnHmrReload(instance, newInstance);
-}
-/**
-* dev only
-* update parentInstance.block to ensure that the correct parent and
-* anchor are found during parentInstance HMR rerender/reload, as
-* `normalizeBlock` relies on the current instance.block
-*/
-function updateParentBlockOnHmrReload(parentInstance, instance, newInstance) {
-	if (parentInstance) parentInstance.block = replaceBlockInstance(parentInstance.block, instance, newInstance);
-}
-/**
-* dev only
-* during root component HMR reload, since the old component will be unmounted
-* and a new one will be mounted, we need to update the teleport's nodes
-* to ensure that the correct parent and anchor are found during parentInstance
-* HMR rerender/reload, as `normalizeBlock` relies on the current instance.block
-*/
-function updateParentTeleportOnHmrReload(instance, newInstance) {
-	const teleport = instance.parentTeleport;
-	if (teleport) {
-		newInstance.parentTeleport = teleport;
-		teleport.nodes = replaceBlockInstance(teleport.nodes, instance, newInstance);
-	}
-}
-function replaceBlockInstance(block, instance, newInstance) {
-	if (block === instance) return newInstance;
-	if (isArray(block)) {
-		for (let i = 0; i < block.length; i++) block[i] = replaceBlockInstance(block[i], instance, newInstance);
-		return block;
-	}
-	if (isVaporComponent(block)) {
-		block.block = replaceBlockInstance(block.block, instance, newInstance);
-		return block;
-	}
-	if (isFragment(block)) {
-		block.nodes = replaceBlockInstance(block.nodes, instance, newInstance);
-		return block;
+	let newInstance;
+	try {
+		newInstance = createComponent(newComp, instance.rawProps, instance.rawSlots, instance.isSingleRoot, void 0, instance.appContext);
+	} finally {
+		setCurrentInstance(...prev);
 	}
-	return block;
+	mountComponent(newInstance, parent, anchor);
+	const app = instance.appContext.app;
+	if (app && app._instance === instance) app._instance = newInstance;
 }
 //#endregion
 //#region packages/runtime-vapor/src/suspense.ts
@@ -12524,10 +12580,7 @@ function setParentSuspense(suspense) {
 }
 //#endregion
 //#region packages/runtime-vapor/src/component.ts
-function normalizeRawSlots(rawSlots) {
-	return rawSlots && isFunction(rawSlots) ? { default: rawSlots } : rawSlots;
-}
-function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appContext = currentInstance && currentInstance.appContext || emptyContext, managedMount = false) {
+function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appContext = currentInstance && currentInstance.appContext || emptyContext, managedMount = false, ce) {
 	const wasInOnceSlot = inOnceSlot;
 	if (wasInOnceSlot) once = true;
 	if (isInteropEnabled && isCollectingVdomSlotVNodes) {
@@ -12585,7 +12638,7 @@ function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appC
 			} else frag.hydrate();
 			return frag;
 		}
-		const instance = new VaporComponentInstance(component, rawProps, rawSlots, appContext, once);
+		const instance = new VaporComponentInstance(component, rawProps, rawSlots, appContext, once, ce);
 		if (isKeepAliveEnabled && currentKeepAliveCtx && !isAsyncWrapper(instance)) {
 			currentKeepAliveCtx.processShapeFlag(instance);
 			setCurrentKeepAliveCtx(null);
@@ -12623,7 +12676,7 @@ function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appC
 		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);
+				if (instance.block && hydrationClose && findBlockBoundary(instance.block).nextNode === hydrationClose.nextSibling) setCurrentHydrationNode(hydrationClose);
 				finalizeHydrationBoundary();
 			};
 			exitHydrationCursor(hydrationCursor);
@@ -12705,7 +12758,7 @@ const emptyContext = {
 	provides: /* @__PURE__ */ Object.create(null)
 };
 var VaporComponentInstance = class {
-	constructor(comp, rawProps, rawSlots, appContext, once) {
+	constructor(comp, rawProps, rawSlots, appContext, once, ce) {
 		this.accessedAttrs = false;
 		this.vapor = true;
 		this.uid = nextUid();
@@ -12751,9 +12804,9 @@ var VaporComponentInstance = class {
 		} else this.props = this.attrs = EMPTY_OBJ;
 		const normalizedRawSlots = normalizeRawSlots(rawSlots);
 		this.rawSlots = normalizedRawSlots || EMPTY_OBJ;
-		this.slots = normalizedRawSlots ? normalizedRawSlots.$ ? new Proxy(normalizedRawSlots, dynamicSlotsProxyHandlers) : normalizedRawSlots : EMPTY_OBJ;
+		this.slots = normalizedRawSlots ? new Proxy(normalizedRawSlots, dynamicSlotsProxyHandlers) : EMPTY_OBJ;
 		this.scopeId = getCurrentScopeId();
-		if (comp.ce) comp.ce(this);
+		if (ce) ce(this);
 		if (this.props === this.attrs) this.accessedAttrs = true;
 		else {
 			const attrs = this.attrs;
@@ -12887,7 +12940,7 @@ function mountComponent(instance, parent, anchor) {
 	if (!isHydrating$1) {
 		insert(instance.block, parent, anchor);
 		setComponentScopeId(instance);
-	}
+	} else trackComponentScopeId(instance);
 	if (instance.m) queuePostFlushCb(instance.m);
 	if (isKeepAliveEnabled && instance.shapeFlag & 256 && instance.a) queuePostFlushCb(instance.a);
 	instance.isMounted = true;
@@ -12916,7 +12969,7 @@ 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) && !(isTeleportEnabled && isTeleportFragment(block))) {
-		if (block instanceof DynamicFragment && onDynamicFragment) onDynamicFragment(block);
+		if (isDynamicFragment(block) && onDynamicFragment) onDynamicFragment(block);
 		const { nodes } = block;
 		if (nodes instanceof Element && nodes.$root) return nodes;
 		return getRootElement(nodes, onDynamicFragment, recurse);
@@ -12953,27 +13006,65 @@ function handleSetupResult(setupResult, component, instance) {
 	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) => registerDynamicFragmentFallthroughAttrs(frag, instance.attrs), false);
-		if (root) renderEffect(() => {
-			const attrs = isFunction(component) && !(isTransitionEnabled ? isVaporTransition(component) : false) ? getFunctionalFallthrough(instance.attrs) : instance.attrs;
+		const getFallthroughAttrs = isFunction(component) && !(isTransitionEnabled ? isVaporTransition(component) : false) ? () => getFunctionalFallthrough(instance.attrs) : () => instance.attrs;
+		applyFallthroughAttrs(instance.block, instance, getFallthroughAttrs);
+	}
+	popWarningContext();
+}
+function applyFallthroughAttrs(block, instance, getFallthroughAttrs, scope) {
+	let hasSlotFragment = false;
+	let dynamicFragments;
+	const root = getRootElement(block, (frag) => {
+		if (frag.isSlot) hasSlotFragment = true;
+		else (dynamicFragments || (dynamicFragments = [])).push(frag);
+	}, false);
+	const dynamicRoot = root ? void 0 : getSingleDynamicRootChain(block);
+	const fragmentsToRegister = root ? dynamicFragments : dynamicRoot && dynamicRoot.fragments;
+	if (fragmentsToRegister) {
+		for (const frag of fragmentsToRegister) if (!frag.isSlot) registerDynamicFragmentFallthroughAttrs(frag, instance, getFallthroughAttrs);
+	}
+	if (root && !hasSlotFragment) {
+		const applyEffect = () => renderEffect(() => {
+			const attrs = getFallthroughAttrs();
 			if (attrs) applyFallthroughProps(root, attrs);
 		});
-		else if (!instance.accessedAttrs && isArray(instance.block) && instance.block.length || isTeleportEnabled && isTeleportFragment(instance.block)) warnExtraneousAttributes(instance.attrs);
+		scope ? scope.run(applyEffect) : applyEffect();
+	} else if (hasSlotFragment || dynamicRoot && dynamicRoot.hasNonSingleRoot || isTeleportEnabled && containsTeleportFragment(block) || !instance.accessedAttrs && isArray(block) && block.length) warnExtraneousAttributes(instance.attrs);
+}
+function getSingleDynamicRootChain(block) {
+	if (isDynamicFragment(block)) {
+		const { nodes } = block;
+		const nested = getSingleDynamicRootChain(nodes);
+		return {
+			fragments: nested ? [block, ...nested.fragments] : [block],
+			hasNonSingleRoot: nested ? nested.hasNonSingleRoot : isArray(nodes) && nodes.some((child) => !(child instanceof Comment))
+		};
+	}
+	if (isFragment(block) && !(isTeleportEnabled && isTeleportFragment(block))) return getSingleDynamicRootChain(block.nodes);
+	if (isArray(block)) {
+		let singleRoot;
+		let hasComment = false;
+		for (const child of block) {
+			if (child instanceof Comment) {
+				hasComment = true;
+				continue;
+			}
+			const childRoot = getSingleDynamicRootChain(child);
+			if (!childRoot || singleRoot) return;
+			singleRoot = childRoot;
+		}
+		return hasComment ? singleRoot : void 0;
 	}
-	popWarningContext();
 }
-function getCurrentScopeId() {
-	const scopeOwner = getScopeOwner();
-	return scopeOwner ? scopeOwner.type.__scopeId : void 0;
+function containsTeleportFragment(block) {
+	if (isTeleportFragment(block)) return true;
+	if (isArray(block)) return block.some((child) => !(child instanceof Comment) && containsTeleportFragment(child));
+	return isFragment(block) && containsTeleportFragment(block.nodes);
 }
-function registerDynamicFragmentFallthroughAttrs(frag, attrs) {
+function registerDynamicFragmentFallthroughAttrs(frag, instance, getFallthroughAttrs) {
+	if (frag.hasFallthroughAttrs) return;
 	frag.hasFallthroughAttrs = true;
-	(frag.onBeforeInsert || (frag.onBeforeInsert = [])).push((nodes) => {
-		if (nodes instanceof Element) frag.scope.run(() => {
-			renderEffect(() => applyFallthroughProps(nodes, attrs));
-		});
-		else if (frag.anchorLabel === "slot" || isArray(nodes) && nodes.length) warnExtraneousAttributes(attrs);
-	});
+	(frag.onBeforeInsert || (frag.onBeforeInsert = [])).push((nodes) => applyFallthroughAttrs(nodes, instance, getFallthroughAttrs, frag.scope));
 }
 //#endregion
 //#region packages/runtime-vapor/src/apiCreateApp.ts
@@ -13082,23 +13173,31 @@ function defineVaporAsyncComponent(source) {
 				frag.update(() => createInnerComp(resolvedComp, instance));
 				return frag;
 			}
+			frag.validityPending = true;
 			const onError = (err) => {
 				setPendingRequest(null);
 				handleError(err, instance, 13, !errorComponent);
 			};
 			if (suspensible && instance.suspense) return load().then(() => {
 				resolvedComp = getResolvedComp();
+				frag.validityPending = false;
 				if (resolvedComp) frag.update(() => createInnerComp(resolvedComp, instance));
 				return frag;
 			}).catch((err) => {
 				onError(err);
-				if (errorComponent) frag.update(() => createInnerComp(errorComponent, instance, { error: () => err }, {}));
+				frag.validityPending = false;
+				if (errorComponent) frag.update(() => createErrorComp(errorComponent, instance, err));
 				return frag;
 			});
-			const { loaded, error, delayed } = useAsyncComponentState(delay, timeout, onError);
+			const { loaded, error, delayed } = useAsyncComponentState(delay, timeout, onError, instance);
 			load().then(() => {
+				if (instance.isUnmounted) return;
 				loaded.value = true;
 			}).catch((err) => {
+				if (instance.isUnmounted) {
+					setPendingRequest(null);
+					return;
+				}
 				onError(err);
 				error.value = err;
 			});
@@ -13106,8 +13205,11 @@ function defineVaporAsyncComponent(source) {
 				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);
+				else if (error.value && errorComponent) {
+					const err = error.value;
+					render = () => createErrorComp(errorComponent, instance, err);
+				} else if (loadingComponent && !delayed.value) render = () => createInnerComp(loadingComponent, instance);
+				frag.validityPending = !render && !error.value;
 				frag.update(render);
 				if (isKeepAliveEnabled && frag.keepAliveCtx) frag.keepAliveCtx.cacheBlock();
 			});
@@ -13115,6 +13217,9 @@ function defineVaporAsyncComponent(source) {
 		}
 	});
 }
+function createErrorComp(comp, parent, error) {
+	return createInnerComp(comp, parent, { error: () => error }, {});
+}
 function createInnerComp(comp, parent, rawProps = parent.rawProps, rawSlots = parent.rawSlots) {
 	const prevInstance = setCurrentInstance(parent);
 	try {
@@ -13136,17 +13241,19 @@ function setCurrentPendingVShows(pending) {
 function applyVShow(target, source) {
 	if (isVaporComponent(target)) return applyVShow(target.block, source);
 	if (isArray(target) && target.length === 1) return applyVShow(target[0], source);
-	if (target instanceof DynamicFragment) {
+	if (isDynamicFragment(target)) {
 		const update = target.update;
-		target.update = (render, key) => {
-			update.call(target, render, key);
+		target.update = (...args) => {
+			const res = update.call(target, ...args);
 			setDisplay(target, source());
+			return res;
 		};
-	} else if (target instanceof VaporFragment && target.insert) {
+	} else if (isFragment(target) && target.insert) {
 		const insert = target.insert;
-		target.insert = (parent, anchor) => {
-			insert.call(target, parent, anchor);
+		target.insert = (...args) => {
+			const res = insert.call(target, ...args);
 			setDisplay(target, source());
+			return res;
 		};
 	}
 	renderEffect(() => {
@@ -13154,20 +13261,20 @@ function applyVShow(target, source) {
 		if (currentPendingVShows) {
 			currentPendingVShows.push({
 				target,
-				setDisplay: () => setDisplay(target, value)
+				apply: () => setDisplay(target, value, true)
 			});
 			return;
 		}
 		setDisplay(target, value);
 	});
 }
-function setDisplay(target, value) {
-	if (isVaporComponent(target)) return setDisplay(target.block, value);
+function setDisplay(target, value, deferEnter = false) {
+	if (isVaporComponent(target)) return setDisplay(target.block, value, deferEnter);
 	if (isArray(target)) {
 		if (target.length === 0) return;
-		if (target.length === 1) return setDisplay(target[0], value);
+		if (target.length === 1) return setDisplay(target[0], value, deferEnter);
 	}
-	if (isFragment(target)) return setDisplay(target.nodes, value);
+	if (isFragment(target)) return setDisplay(target.nodes, value, deferEnter);
 	if (target instanceof Element) {
 		const el = target;
 		if (!(vShowOriginalDisplay in el)) el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
@@ -13175,6 +13282,7 @@ function setDisplay(target, value) {
 		if ($transition) if (value) {
 			$transition.beforeEnter(target);
 			el.style.display = el[vShowOriginalDisplay];
+			if (deferEnter) return () => $transition.enter(target);
 			$transition.enter(target);
 		} else if (target.isConnected) $transition.leave(target, () => {
 			el.style.display = "none";
@@ -13269,11 +13377,14 @@ const VaporTransition = /* @__PURE__ */ decorate$1((props, { slots, expose }) =>
 	return children;
 });
 const transitionTypeMap = /* @__PURE__ */ new WeakMap();
+const inheritedTransitionKeyMap = /* @__PURE__ */ new WeakMap();
+let transitionKeyGeneration = 0;
+let currentTransitionKeyGeneration = 0;
 function getTransitionType(block) {
 	const type = transitionTypeMap.get(block);
 	if (type !== void 0) return type;
 	if (block instanceof Element) return block.localName;
-	if (isFragment(block) && block.vnode) {
+	if (isInteropEnabled && isFragment(block) && block.vnode) {
 		const children = getTransitionRawChildren([block.vnode]);
 		if (children.length === 1) return children[0].type;
 	}
@@ -13290,11 +13401,8 @@ function getLeavingNodesForType(state, block) {
 	return nodes;
 }
 function getLeaveElement(block) {
-	if (block instanceof Element) return block;
-	if (isInteropEnabled && isFragment(block) && block.vnode) {
-		const el = getTransitionElementFromVNode(block.vnode);
-		if (el) return el;
-	}
+	const el = getTransitionElement(block);
+	if (el) return el;
 	if (isFragment(block) && !isArray(block.nodes) && (block.nodes instanceof Element || isFragment(block.nodes))) return getLeaveElement(block.nodes);
 }
 const getTransitionHooksContext = (block, props, state, instance, postClone) => {
@@ -13336,7 +13444,7 @@ function applyResolvedTransitionHooks(block, hooks) {
 		if (block.length === 1) block = block[0];
 		else if (block.length === 0) return { hooks };
 	}
-	if (hooks.applyGroup && (block instanceof ForFragment || block instanceof SlotFragment || isVaporComponent(block) && block.block instanceof SlotFragment)) {
+	if (hooks.applyGroup && (block instanceof ForFragment || isSlotFragment(block) || isVaporComponent(block) && isSlotFragment(block.block))) {
 		hooks.applyGroup(block, hooks.props, hooks.state, hooks.instance);
 		return { hooks };
 	}
@@ -13393,52 +13501,138 @@ function applyTransitionLeaveHooksImpl(block, enterHooks, afterLeaveCb) {
 	};
 }
 function resolveTransitionBlock(block, onFragment) {
-	let child;
+	return resolveTransitionChildren(block, {
+		mode: "single",
+		onFragment
+	})[0];
+}
+function resolveTransitionBlocks(block, onFragment, onUpdateOwner) {
+	return resolveTransitionChildren(block, {
+		mode: "group",
+		onFragment,
+		onUpdateOwner
+	});
+}
+function resolveTransitionChildren(block, options) {
+	const children = [];
+	const prevGeneration = currentTransitionKeyGeneration;
+	currentTransitionKeyGeneration = ++transitionKeyGeneration;
+	try {
+		collectTransitionBlocks(block, options, children);
+		return children;
+	} finally {
+		currentTransitionKeyGeneration = prevGeneration;
+	}
+}
+function collectTransitionBlocks(block, options, children) {
 	if (block instanceof Node) {
-		if (block instanceof Element) child = block;
-	} else if (isVaporComponent(block)) if (isAsyncWrapper(block)) if (!block.type.__asyncResolved) onFragment && onFragment(block.block);
-	else {
-		child = resolveTransitionBlock(block.block.nodes, onFragment);
-		if (child) {
-			if (child.$key == null) {
-				var _block$$key;
-				child.$key = (_block$$key = block.$key) !== null && _block$$key !== void 0 ? _block$$key : block.uid;
-			}
-			transitionTypeMap.set(child, block.type);
-		}
+		if (block instanceof Element) children.push(block);
+	} else if (isVaporComponent(block)) collectComponentTransitionBlocks(block, options, children);
+	else if (isArray(block)) collectArrayTransitionBlocks(block, options, children);
+	else if (isFragment(block)) collectFragmentTransitionBlocks(block, options, children);
+}
+function collectComponentTransitionBlocks(block, options, children) {
+	if (options.mode === "group") {
+		const isRootSlot = block.block && isSlotFragment(block.block);
+		if (options.onUpdateOwner && !isRootSlot) options.onUpdateOwner(block);
+		const start = children.length;
+		collectTransitionBlocks(block.block, isRootSlot ? options : {
+			mode: options.mode,
+			onFragment: options.onFragment
+		}, children);
+		inheritTransitionKey(children, start, block.$key);
+		return;
 	}
-	else {
-		if (getComponentName(block.type) === "VaporTransition") return void 0;
-		child = resolveTransitionBlock(block.block, onFragment);
-		if (child) {
-			if (child.$key == null) {
-				var _block$$key2;
-				child.$key = (_block$$key2 = block.$key) !== null && _block$$key2 !== void 0 ? _block$$key2 : block.uid;
-			}
-			transitionTypeMap.set(child, block.type);
+	if (isAsyncWrapper(block)) {
+		if (!block.type.__asyncResolved) {
+			if (options.onFragment) options.onFragment(block.block);
+			return;
 		}
+		const start = children.length;
+		collectTransitionBlocks(block.block.nodes, options, children);
+		inheritSingleComponentKey(children[start], block);
+		return;
 	}
-	else if (isArray(block)) {
-		let hasFound = false;
+	if (block.type === VaporTransition) return;
+	const start = children.length;
+	collectTransitionBlocks(block.block, options, children);
+	inheritSingleComponentKey(children[start], block);
+}
+function collectArrayTransitionBlocks(block, options, children) {
+	if (options.mode === "group") {
 		for (const c of block) {
-			if (c instanceof Comment) continue;
-			const item = resolveTransitionBlock(c, onFragment);
-			if (hasFound) {
-				warn("<transition> can only be used on a single element or component. Use <transition-group> for lists.");
-				break;
+			const start = children.length;
+			collectTransitionBlocks(c, options, children);
+			if (c instanceof ForBlock) {
+				const count = children.length - start;
+				for (let j = start; j < children.length; j++) children[j].$key = c.key != null && count > 1 ? `${c.key}:${j - start}` : c.key;
 			}
-			child = item;
-			hasFound = true;
 		}
-	} else if (isFragment(block)) if (isInteropEnabled && block.vnode) {
-		child = block;
-		const children = getTransitionRawChildren([block.vnode]);
-		if (children.length === 1) transitionTypeMap.set(child, children[0].type);
-	} else {
-		if (onFragment) onFragment(block);
-		child = resolveTransitionBlock(block.nodes, onFragment);
+		return;
+	}
+	let hasFound = false;
+	for (const c of block) {
+		if (c instanceof Comment) continue;
+		const nested = [];
+		collectTransitionBlocks(c, options, nested);
+		if (hasFound) {
+			warn("<transition> can only be used on a single element or component. Use <transition-group> for lists.");
+			break;
+		}
+		if (nested.length) children.push(nested[0]);
+		hasFound = true;
+	}
+}
+function collectFragmentTransitionBlocks(block, options, children) {
+	if (options.mode === "group") {
+		if (options.onFragment) options.onFragment(block);
+		if (options.onUpdateOwner) options.onUpdateOwner(block);
+		if (isInteropEnabled && block.vnode) children.push(block);
+		else {
+			const start = children.length;
+			collectTransitionBlocks(block.nodes, options, children);
+			inheritTransitionKey(children, start, block.$key);
+		}
+		return;
+	}
+	if (isInteropEnabled && block.vnode) {
+		children.push(block);
+		const rawChildren = getTransitionRawChildren([block.vnode]);
+		if (rawChildren.length === 1) transitionTypeMap.set(block, rawChildren[0].type);
+		return;
+	}
+	if (options.onFragment) options.onFragment(block);
+	collectTransitionBlocks(block.nodes, options, children);
+}
+function inheritSingleComponentKey(child, block) {
+	if (!child) return;
+	if (child.$key == null) {
+		var _block$$key;
+		child.$key = (_block$$key = block.$key) !== null && _block$$key !== void 0 ? _block$$key : block.uid;
+	}
+	transitionTypeMap.set(child, block.type);
+}
+function inheritTransitionKey(children, start, key) {
+	if (key == null || start === children.length) return;
+	for (let i = start; i < children.length; i++) {
+		const child = children[i];
+		let record = inheritedTransitionKeyMap.get(child);
+		let baseKey;
+		if (record && record.generation === currentTransitionKeyGeneration) baseKey = child.$key != null ? child.$key : i - start;
+		else {
+			if (!record || !Object.is(child.$key, record.inheritedKey)) {
+				record = {
+					generation: currentTransitionKeyGeneration,
+					rawBaseKey: child.$key != null ? child.$key : i - start,
+					inheritedKey: ""
+				};
+				inheritedTransitionKeyMap.set(child, record);
+			} else record.generation = currentTransitionKeyGeneration;
+			baseKey = record.rawBaseKey;
+		}
+		record.inheritedKey = String(key) + String(baseKey);
+		child.$key = record.inheritedKey;
 	}
-	return child;
 }
 function setTransitionHooks$1(block, hooks) {
 	if (isVaporComponent(block)) {
@@ -13459,6 +13653,13 @@ function getTransitionElementFromVNode(vnode) {
 	const children = getTransitionRawChildren([vnode]);
 	if (children.length === 1 && children[0] !== vnode) return getTransitionElementFromVNode(children[0]);
 }
+function isValidTransitionBlock(block) {
+	return !!(block instanceof Element || isInteropEnabled && isFragment(block) && block.vnode);
+}
+function getTransitionElement(block) {
+	if (block instanceof Element) return block;
+	if (isInteropEnabled && isFragment(block) && block.vnode) return getTransitionElementFromVNode(block.vnode);
+}
 function capturePendingVShows(enabled, render) {
 	if (!enabled) return [render(), void 0];
 	const pendingVShows = [];
@@ -13473,8 +13674,16 @@ function applyPendingVShows(hooks, root, pendingVShows) {
 	if (!pendingVShows) return;
 	if (root) hooks.persisted = hooks.persisted || pendingVShows.some((pending) => pending.target === root || resolveTransitionBlock(pending.target) === root);
 	onBeforeMount(() => {
-		for (const pending of pendingVShows) pending.setDisplay();
+		let enterCbs;
+		pendingVShows.forEach((pending) => {
+			const enterCb = pending.apply();
+			if (enterCb) (enterCbs || (enterCbs = [])).push(enterCb);
+		});
 		pendingVShows.length = 0;
+		if (enterCbs) {
+			const cbs = enterCbs;
+			queuePostFlushCb(() => cbs.forEach((cb) => cb()), -1);
+		}
 	});
 }
 //#endregion
@@ -13546,7 +13755,7 @@ const VaporKeepAlive = /* @__PURE__ */ withKeepAliveEnabled(/* @__PURE__ */ defi
 				cache.forEach((cached) => {
 					unsetShapeFlag(cached);
 					if (cached !== current) {
-						const parentNode = findBlockNode(cached).parentNode;
+						const parentNode = findBlockBoundary(cached).parentNode;
 						if (parentNode) remove(cached, parentNode);
 					}
 				});
@@ -13638,7 +13847,7 @@ const VaporKeepAlive = /* @__PURE__ */ withKeepAliveEnabled(/* @__PURE__ */ defi
 			const cached = cache.get(key);
 			if (cached && (!current || cached !== current)) {
 				unsetShapeFlag(cached);
-				const parentNode = findBlockNode(cached).parentNode;
+				const parentNode = findBlockBoundary(cached).parentNode;
 				if (parentNode) remove(cached, parentNode);
 			} else if (current) unsetShapeFlag(current);
 			cache.delete(key);
@@ -13770,9 +13979,6 @@ function getInnerBlock(block) {
 	else if (isFragment(block)) return getInnerBlock(block.nodes);
 	return [void 0, false];
 }
-function isInteropFragment(block) {
-	return !!(isFragment(block) && block.vnode);
-}
 function getInstanceFromCache(cached) {
 	if (isVaporComponent(cached)) return cached;
 	if (isInteropEnabled) return cached.vnode.component;
@@ -13798,6 +14004,8 @@ function deactivate$1(instance, container) {
 }
 //#endregion
 //#region packages/runtime-vapor/src/vdomInterop.ts
+const EMPTY_BLOCK = EMPTY_ARR;
+const EMPTY_VNODES = EMPTY_ARR;
 function filterReservedProps(props) {
 	const filtered = {};
 	for (const key in props) if (!isReservedProp(key)) filtered[key] = props[key];
@@ -13805,7 +14013,7 @@ function filterReservedProps(props) {
 }
 const vaporInteropImpl = {
 	mount(vnode, container, anchor, parentComponent, parentSuspense, onBeforeMount, onVnodeBeforeMount) {
-		let selfAnchor = vnode.anchor = /* @__PURE__ */ createTextNode();
+		const selfAnchor = vnode.anchor = /* @__PURE__ */ createTextNode();
 		if (isHydrating$1) queuePostFlushCb(() => container.insertBefore(selfAnchor, anchor));
 		else {
 			vnode.el = selfAnchor;
@@ -13879,14 +14087,14 @@ const vaporInteropImpl = {
 				const anchor = vnode.anchor;
 				unmountComponent(instance, container);
 				if (!doRemove) {
-					const blockContainer = shouldUseCurrentParent(instance.block) ? anchor && anchor.parentNode : void 0;
+					const blockContainer = needsHostParentForRemove(instance.block) ? anchor && anchor.parentNode : void 0;
 					remove(instance.block, blockContainer);
 				}
 			}
 		} else if (vnode.vb) {
 			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);
+			const blockContainer = container || (needsHostParentForRemove(vnode.vb) ? anchor && anchor.parentNode : void 0);
 			remove(vnode.vb, blockContainer);
 			stopVaporSlotScope(vnode);
 		}
@@ -14031,26 +14239,35 @@ const vaporSlotPropsProxyHandler = {
 	}
 };
 const vaporSlotWrappersCache = /* @__PURE__ */ new WeakMap();
-const vaporSlotsProxyHandler = { get(target, key) {
-	const slot = target[key];
-	if (isFunction(slot)) {
-		slot.__vapor = true;
-		let wrappers = vaporSlotWrappersCache.get(target);
-		if (!wrappers) vaporSlotWrappersCache.set(target, wrappers = /* @__PURE__ */ new Map());
-		const cached = wrappers.get(key);
-		if (cached && cached.slot === slot) return cached.wrapped;
-		const wrapped = (props) => {
-			return normalizeVaporSlotVNodes(slot, props) || [renderSlot({ [key]: slot }, key, props)];
-		};
-		wrapped.__vs = slot;
-		wrappers.set(key, {
-			slot,
-			wrapped
-		});
-		return wrapped;
+const vaporSlotsProxyHandler = {
+	get(target, key) {
+		const slot = isString(key) && !isInternalSlotKey(key) ? getSlot(target, key) : target[key];
+		if (isFunction(slot)) {
+			slot.__vapor = true;
+			let wrappers = vaporSlotWrappersCache.get(target);
+			if (!wrappers) vaporSlotWrappersCache.set(target, wrappers = /* @__PURE__ */ new Map());
+			const cached = wrappers.get(key);
+			if (cached && cached.slot === slot) return cached.wrapped;
+			const wrapped = (props) => {
+				return normalizeVaporSlotVNodes(slot, props) || [renderSlot({ [key]: slot }, key, props)];
+			};
+			wrapped.__vs = slot;
+			wrappers.set(key, {
+				slot,
+				wrapped
+			});
+			return wrapped;
+		}
+		return slot;
+	},
+	ownKeys(target) {
+		return Array.from(dynamicSlotsProxyHandlers.ownKeys(target)).filter((key) => isString(key) && !isInternalSlotKey(key));
+	},
+	getOwnPropertyDescriptor(target, key) {
+		if (!isString(key) || isInternalSlotKey(key)) return;
+		return dynamicSlotsProxyHandlers.getOwnPropertyDescriptor(target, key);
 	}
-	return slot;
-} };
+};
 const collectedVdomSlotVNodes = /* @__PURE__ */ new WeakMap();
 function normalizeVaporSlotVNodes(slot, props) {
 	if (props && hasVNodeSlotProps(props)) return;
@@ -14132,38 +14349,43 @@ function removeAttachedNodes(block, parent) {
 		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;
-	props.onVnodeUpdated = existing ? isArray(existing) ? [...existing, hook] : [existing, hook] : hook;
-}
-function appendVnodeBeforeUpdateHook(vnode, hook) {
+function appendVnodeHook(vnode, key, hook) {
 	const props = vnode.props || (vnode.props = {});
-	const existing = props.onVnodeBeforeUpdate;
-	props.onVnodeBeforeUpdate = existing ? isArray(existing) ? [...existing, hook] : [existing, hook] : hook;
+	const existing = props[key];
+	props[key] = existing ? isArray(existing) ? [...existing, hook] : [existing, hook] : hook;
 }
-function trackFragmentVNodeUpdates(frag, vnode) {
+function trackFragmentVNodeUpdates(frag, vnode, syncNodes) {
 	const beforeUpdate = () => {
-		if (frag.onBeforeUpdate) for (let i = 0; i < frag.onBeforeUpdate.length; i++) frag.onBeforeUpdate[i]();
+		if (frag.onBeforeUpdate) frag.onBeforeUpdate.forEach((bu) => bu());
 	};
 	const updated = () => {
+		syncNodes();
+		if (frag.onUpdated) frag.onUpdated.forEach((u) => u());
+	};
+	appendVnodeHook(vnode, "onVnodeBeforeUpdate", beforeUpdate);
+	appendVnodeHook(vnode, "onVnodeUpdated", updated);
+}
+function createVNodeFragment(vnode) {
+	const frag = createInteropFragment(EMPTY_BLOCK, vnode);
+	frag.$key = vnode.key;
+	let validityPending = !isHydrating$1;
+	const syncNodes = () => {
 		frag.nodes = resolveVNodeNodes(vnode);
-		frag.validityPending = false;
-		if (frag.onUpdated) frag.onUpdated.forEach((m) => m());
+		validityPending = false;
+	};
+	frag.isBlockValid = () => validityPending ? true : isValidBlock(frag.nodes);
+	trackFragmentVNodeUpdates(frag, vnode, syncNodes);
+	return {
+		frag,
+		syncNodes
 	};
-	appendVnodeBeforeUpdateHook(vnode, beforeUpdate);
-	appendVnodeUpdatedHook(vnode, updated);
 }
 /**
 * Mount VNode in vapor
 */
 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);
+	const { frag, syncNodes } = createVNodeFragment(vnode);
 	let isMounted = false;
 	const unmount = (parentNode, transition) => {
 		if (transition) setTransitionHooks(vnode, transition);
@@ -14176,8 +14398,7 @@ function mountVNode(internals, vnode, parentComponent) {
 		hydrateVNode(vnode, parentComponent);
 		onScopeDispose(unmount, true);
 		isMounted = true;
-		frag.nodes = resolveVNodeNodes(vnode);
-		frag.validityPending = false;
+		syncNodes();
 	};
 	frag.insert = (parentNode, anchor, transition) => {
 		if (isHydrating$1) return;
@@ -14196,8 +14417,7 @@ function mountVNode(internals, vnode, parentComponent) {
 			} else internals.m(vnode, parentNode, anchor, 2, parentComponent);
 			simpleSetCurrentInstance(prev);
 		}
-		frag.nodes = resolveVNodeNodes(vnode);
-		frag.validityPending = false;
+		syncNodes();
 		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
 	};
 	frag.remove = unmount;
@@ -14210,11 +14430,8 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 	const suspense = parentSuspense || parentComponent && parentComponent.suspense;
 	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);
+	const vnode = createVNode(comp, rawProps && extend({}, new Proxy(rawProps, rawPropsProxyHandlers)));
+	const { frag, syncNodes } = createVNodeFragment(vnode);
 	if (!isCollectingVdomSlotVNodes && isKeepAliveEnabled && currentKeepAliveCtx) {
 		currentKeepAliveCtx.processShapeFlag(frag);
 		if (component.__asyncLoader) {
@@ -14228,7 +14445,7 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 		setCurrentKeepAliveCtx(null);
 	}
 	const wrapper = new VaporComponentInstance(useBridge ? comp : { props: component.props }, rawProps, rawSlots, parentComponent ? parentComponent.appContext : void 0, once);
-	if (isCollectingVdomSlotVNodes) collectedVdomSlotVNodes.set(frag, createCollectedVDOMSlotVNode(component, rawProps, wrapper.slots));
+	if (isCollectingVdomSlotVNodes) collectedVdomSlotVNodes.set(frag, createCollectedVDOMSlotVNode(component, rawProps, wrapper.rawSlots));
 	vnode.vi = (instance) => {
 		instance.props = /* @__PURE__ */ shallowReactive(wrapper.props);
 		const attrs = createInternalObject();
@@ -14251,7 +14468,7 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 				};
 			}
 		});
-		instance.slots = wrapper.slots === EMPTY_OBJ ? EMPTY_OBJ : new Proxy(wrapper.slots, vaporSlotsProxyHandler);
+		instance.slots = wrapper.rawSlots === EMPTY_OBJ ? EMPTY_OBJ : new Proxy(wrapper.rawSlots, vaporSlotsProxyHandler);
 	};
 	let rawRef = null;
 	let isMounted = false;
@@ -14282,8 +14499,7 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 		if (!isHydrating$1) return;
 		hydrateVNode(vnode, parentComponent);
 		isMounted = true;
-		frag.nodes = resolveVNodeNodes(vnode);
-		frag.validityPending = false;
+		syncNodes();
 	};
 	vnode.scopeId = getCurrentScopeId() || null;
 	vnode.slotScopeIds = currentSlotScopeIds;
@@ -14301,8 +14517,7 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 			} else internals.m(vnode, parentNode, anchor, 2, parentComponent);
 			simpleSetCurrentInstance(prev);
 		}
-		frag.nodes = resolveVNodeNodes(vnode);
-		frag.validityPending = false;
+		syncNodes();
 		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
 	};
 	frag.remove = unmount;
@@ -14342,12 +14557,6 @@ function ensureRendererBridge(component) {
 	if (!bridge) rendererBridgeCache.set(component, bridge = (props, { slots }) => createVNode(component, props, slots));
 	return bridge;
 }
-function trackSlotVNodeUpdates(frag, vnode) {
-	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]);
 }
@@ -14355,13 +14564,12 @@ 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) {
+function hydrateForwardedEmptySlotFragment(vnode, parentComponent, contentValid) {
 	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;
@@ -14385,10 +14593,11 @@ function hydrateForwardedEmptySlotFragment(vnode, parentComponent) {
 	if (currentHydrationNode === fragmentEndAnchor) advanceHydrationNode(fragmentEndAnchor);
 	return true;
 }
-function trackSlotVNodeUpdatesWithRefresh(vnode, refresh) {
+function trackSlotVNodeUpdatesWithRefresh(vnode, refresh, beforeUpdate) {
 	const onUpdated = () => refresh();
 	const track = (node) => {
-		appendVnodeUpdatedHook(node, onUpdated);
+		if (beforeUpdate) appendVnodeHook(node, "onVnodeBeforeUpdate", beforeUpdate);
+		appendVnodeHook(node, "onVnodeUpdated", onUpdated);
 		if (node.type === Fragment && isArray(node.children)) node.children.forEach((child) => {
 			if (isVNode(child)) track(child);
 		});
@@ -14398,73 +14607,81 @@ function trackSlotVNodeUpdatesWithRefresh(vnode, refresh) {
 /**
 * Mount vdom slot in vapor
 */
-function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallback, once) {
+function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallback, once, slotRoot) {
 	const suspense = parentSuspense || parentComponent.suspense;
-	const frag = new VaporFragment([]);
-	trackSlotBoundaryDirtying(frag);
-	frag.validityPending = !isHydrating$1;
+	const frag = createInteropFragment();
+	let validityPending = !isHydrating$1;
 	const instance = currentInstance;
 	let isMounted = false;
 	const contentState = {
-		nodes: [],
+		nodes: EMPTY_BLOCK,
 		valid: false,
 		rendered: null
 	};
-	let currentParentNode;
-	let currentAnchor;
+	let currentParentNode = null;
+	let currentAnchor = null;
 	let disposed = false;
 	const scope = effectScope();
 	const inheritedBoundary = frag.inheritedSlotBoundary;
 	let isContentUpdateRecheck = false;
 	let localFallback;
-	let outlet;
+	let fallbackState;
+	frag.isBlockValid = () => {
+		if (validityPending) return true;
+		return fallbackState.activeFallback ? isValidBlock(fallbackState.activeFallback) : contentState.valid;
+	};
 	const boundary = {
 		get parent() {
 			return inheritedBoundary;
 		},
 		getFallback: () => localFallback,
-		run: (fn) => runWithFragmentRenderCtx(frag, fn),
-		markDirty: () => markSlotFallbackDirty(outlet)
+		run: (fn) => runWithFragmentCtx(frag, fn),
+		markDirty: () => markSlotFallbackDirty(fallbackState)
 	};
-	outlet = {
+	fallbackState = {
 		boundary,
 		activeFallback: null,
 		pendingRecheck: false,
 		isRenderingFallback: false,
 		getContent: () => contentState.nodes,
-		getParentNode: () => getSlotFallbackParentNode(currentParentNode, contentState.nodes),
-		getAnchor: () => currentAnchor || null,
+		getParentNode: () => currentParentNode,
+		getAnchor: () => currentAnchor,
+		isBusy: () => false,
 		isDisposed: () => disposed,
 		isContentValid: () => contentState.valid,
-		syncEffectiveOutput: () => {
-			frag.nodes = getSlotEffectiveOutput(outlet);
+		syncNodes: () => {
+			frag.nodes = fallbackState.activeFallback || contentState.nodes;
 		},
 		notifyFallbackValidityChange: () => {
-			if (!isContentUpdateRecheck && inheritedBoundary) inheritedBoundary.markDirty();
+			if (slotRoot && !isContentUpdateRecheck && inheritedBoundary) inheritedBoundary.markDirty();
 		}
 	};
+	if (slotRoot) trackSlotBoundaryDirtying(frag);
 	localFallback = fallback ? once ? () => withOnceSlot(() => fallback(internals, parentComponent)) : () => fallback(internals, parentComponent) : void 0;
-	const setRenderedContent = (rendered) => {
+	const setRenderedContent = (rendered, knownValid) => {
 		contentState.rendered = rendered;
 		if (isVNode(rendered)) {
 			contentState.nodes = resolveVNodeNodes(rendered);
-			contentState.valid = hasValidVNodeContent(rendered);
+			contentState.valid = knownValid === void 0 ? hasValidVNodeContent(rendered) : knownValid;
 		} else if (rendered) {
 			contentState.nodes = rendered;
-			contentState.valid = isValidBlock(rendered);
+			contentState.valid = knownValid === void 0 ? isValidBlock(rendered) : knownValid;
 		} else {
-			contentState.nodes = [];
+			contentState.nodes = EMPTY_BLOCK;
 			contentState.valid = false;
 		}
-		frag.validityPending = false;
+		validityPending = false;
 	};
 	const notifyUpdated = () => {
-		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
+		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((u) => u());
+	};
+	const notifyBeforeUpdate = () => {
+		if (isMounted && frag.onBeforeUpdate) frag.onBeforeUpdate.forEach((bu) => bu());
 	};
 	const recheckAfterContentUpdate = (forceFallbackRecheck = false) => {
 		isContentUpdateRecheck = true;
 		try {
-			recheckSlotFallback(outlet, forceFallbackRecheck);
+			recheckSlotFallback(fallbackState, forceFallbackRecheck);
 		} finally {
 			isContentUpdateRecheck = false;
 		}
@@ -14475,7 +14692,7 @@ function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallb
 	};
 	frag.insert = (parentNode, anchor) => {
 		if (isHydrating$1) return;
-		currentParentNode = parentNode || void 0;
+		currentParentNode = parentNode;
 		currentAnchor = anchor;
 		if (!isMounted) {
 			scope.run(render);
@@ -14483,25 +14700,25 @@ function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallb
 		} else {
 			if (isVNode(contentState.rendered)) internals.m(contentState.rendered, parentNode, anchor, 2, parentComponent);
 			else if (contentState.rendered) insert(contentState.rendered, parentNode, anchor);
-			insertActiveSlotFallback(outlet);
+			insertActiveSlotFallback(fallbackState);
 		}
 		notifyUpdated();
 	};
 	frag.remove = (parentNode) => {
-		currentParentNode = parentNode || currentParentNode || void 0;
-		currentAnchor = currentAnchor || null;
+		if (parentNode) currentParentNode = parentNode;
 		scope.stop();
 		disposed = true;
 		if (isVNode(contentState.rendered)) internals.um(contentState.rendered, parentComponent, null, !!parentNode);
 		else if (contentState.rendered) remove(contentState.rendered, parentNode);
-		disposeSlotFallback(outlet);
+		disposeSlotFallback(fallbackState);
 	};
 	const render = () => {
 		const prev = currentInstance;
 		simpleSetCurrentInstance(instance);
 		try {
 			const renderSlotContent = () => {
-				runWithFragmentRenderCtx(frag, () => withOwnedSlotBoundary(boundary, () => {
+				notifyBeforeUpdate();
+				runWithFragmentCtx(frag, () => withOwnedSlotBoundary(boundary, () => {
 					let slotContent;
 					let slotContentValid = false;
 					if (slotsRef.value) {
@@ -14519,13 +14736,20 @@ function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallb
 						if (isVNode(hydratedContent)) {
 							frag.vnode = hydratedContent;
 							frag.$key = getVNodeKey(hydratedContent);
-							trackSlotVNodeUpdates(frag, hydratedContent);
-							if (!hydrateForwardedEmptySlotFragment(hydratedContent, parentComponent)) hydrateVNode(hydratedContent, parentComponent);
-							setRenderedContent(hydratedContent);
+							const refreshSlotVNode = () => {
+								frag.nodes = resolveVNodeNodes(hydratedContent);
+								if (frag.onUpdated) frag.onUpdated.forEach((m) => m());
+							};
+							trackSlotVNodeUpdatesWithRefresh(hydratedContent, refreshSlotVNode, slotRoot ? notifyBeforeUpdate : void 0);
+							if (!hydrateForwardedEmptySlotFragment(hydratedContent, parentComponent, slotContentValid)) hydrateVNode(hydratedContent, parentComponent);
+							const hydratedEnd = hydratedContent.anchor;
+							currentParentNode = hydratedEnd.parentNode;
+							currentAnchor = hydratedEnd.nextSibling;
+							setRenderedContent(hydratedContent, slotContentValid);
 						} else if (hydratedContent) {
 							frag.vnode = null;
 							frag.$key = void 0;
-							setRenderedContent(hydratedContent);
+							setRenderedContent(hydratedContent, slotContentValid);
 						} else {
 							frag.vnode = null;
 							frag.$key = void 0;
@@ -14537,17 +14761,20 @@ function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallb
 					if (isVNode(slotContent)) {
 						frag.vnode = slotContent;
 						frag.$key = getVNodeKey(slotContent);
-						trackSlotVNodeUpdatesWithRefresh(slotContent, () => {
+						const refreshSlotVNode = () => {
 							const prevValid = contentState.valid;
 							const prevOutput = frag.nodes;
 							setRenderedContent(slotContent);
 							recheckAfterContentUpdate();
 							if (contentState.valid !== prevValid || !isSameResolvedOutput(prevOutput, frag.nodes)) notifyUpdated();
-						});
+						};
+						trackSlotVNodeUpdatesWithRefresh(slotContent, refreshSlotVNode, slotRoot ? notifyBeforeUpdate : void 0);
 						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);
+						const prevIsVNode = isVNode(prevRendered);
+						const prevVNode = prevIsVNode && (!fallbackState.activeFallback || contentState.valid) ? prevRendered : null;
+						if (prevRendered && !prevIsVNode) remove(prevRendered, currentParentNode);
+						internals.p(prevVNode, slotContent, currentParentNode, currentAnchor, parentComponent, suspense, void 0, slotContent.slotScopeIds);
+						setRenderedContent(slotContent, slotContentValid);
 						finishContentUpdate();
 						return;
 					}
@@ -14558,7 +14785,7 @@ function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallb
 						if (isVNode(prevRendered)) internals.um(prevRendered, parentComponent, null, true);
 						else if (prevRendered) remove(prevRendered, currentParentNode);
 						insert(slotContent, currentParentNode, currentAnchor);
-						setRenderedContent(slotContent);
+						setRenderedContent(slotContent, slotContentValid);
 						finishContentUpdate();
 						return;
 					}
@@ -14578,23 +14805,25 @@ function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallb
 	frag.hydrate = () => {
 		if (!isHydrating$1) return;
 		scope.run(render);
-		currentParentNode = currentHydrationNode.parentNode;
-		currentAnchor = currentHydrationNode;
+		if (!currentParentNode) {
+			currentAnchor = getCurrentSlotEndAnchor() || currentHydrationNode;
+			currentParentNode = currentAnchor.parentNode;
+		}
 		isMounted = true;
 	};
 	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);
+function needsHostParentForRemove(block) {
+	if (isVaporComponent(block)) return isKeepAlive(block) || needsHostParentForRemove(block.block);
+	if (isArray(block)) return block.some(needsHostParentForRemove);
+	if (isFragment(block)) return needsHostParentForRemove(block.nodes);
 	return false;
 }
 const vaporInteropPlugin = (app) => {
 	enableSuspense();
 	setInteropEnabled();
 	const internals = ensureRenderer().internals;
-	app._context.vapor = extend(vaporInteropImpl, {
+	app._context.vapor = extend({}, vaporInteropImpl, {
 		vdomMount: createVDOMComponent.bind(null, internals),
 		vdomUnmount: internals.umt,
 		vdomSlot: renderVDOMSlot.bind(null, internals),
@@ -14617,30 +14846,17 @@ function createFallback(fallback, parentComponent, isVNodeFallback) {
 	const internals = ensureRenderer().internals;
 	return () => {
 		if (isVNodeFallback()) {
-			const frag = createVNodeChildrenFragment(internals, () => fallback().map(normalizeVNode), parentComponent);
+			const frag = createVNodeChildrenFragment(internals, () => {
+				const children = fallback();
+				return children == null ? EMPTY_VNODES : normalizeInteropSlotValue(children);
+			}, parentComponent);
 			if (isHydrating$1 && frag.hydrate) frag.hydrate();
 			return frag;
 		}
 		return fallback();
 	};
 }
-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 getSlotFallbackParentNode(currentParentNode, content) {
-	if (currentParentNode) return currentParentNode;
-	const carrierAnchor = findFirstSlotFallbackCarrierNode(content);
-	return carrierAnchor ? carrierAnchor.parentNode : null;
-}
+const renderEmptyVNodes = () => EMPTY_VNODES;
 function resolveInteropVaporSlotState(vnode) {
 	const slot = vnode.vs;
 	let state = slot.state;
@@ -14688,12 +14904,14 @@ function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 	simpleSetCurrentInstance(parentComponent);
 	if (isSuspenseEnabled && parentSuspense) prevSuspense = setParentSuspense(parentSuspense);
 	try {
-		if (!vnode.vs || !vnode.vs.slot) return [];
+		if (!vnode.vs || !vnode.vs.slot) return EMPTY_BLOCK;
 		const slotState = resolveInteropVaporSlotState(vnode);
-		const frag = new VaporFragment([]);
-		frag.validityPending = !isHydrating$1;
+		const scopeIds = getInteropVaporSlotScopeIds(vnode, parentComponent);
+		const frag = createInteropFragment();
+		let validityPending = !isHydrating$1;
+		frag.isBlockValid = () => validityPending ? true : isValidBlock(frag.nodes);
 		const inheritedBoundary = frag.inheritedSlotBoundary;
-		let contentNodes = [];
+		let contentNodes = EMPTY_BLOCK;
 		let isResolvingContent = false;
 		let localFallback;
 		let outletFallback;
@@ -14701,13 +14919,13 @@ function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 		let currentAnchor = null;
 		let slotScope;
 		let disposed = false;
-		let outlet;
+		let fallbackState;
 		let ownedSlotFragment;
 		let ownedSlotFragmentDirtyQueued = false;
 		const markInteropFallbackDirty = () => {
 			const target = ownedSlotFragment;
 			if (!target) {
-				markSlotFallbackDirty(outlet);
+				markSlotFallbackDirty(fallbackState);
 				return;
 			}
 			if (ownedSlotFragmentDirtyQueued) return;
@@ -14715,7 +14933,6 @@ function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 			queuePostFlushCb(() => {
 				ownedSlotFragmentDirtyQueued = false;
 				markSlotFallbackDirty(target);
-				syncActiveSlotFallback(target);
 			});
 		};
 		const outletFallbackBoundary = {
@@ -14723,7 +14940,7 @@ function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 				return inheritedBoundary;
 			},
 			getFallback: () => slotState.outletFallback.value ? outletFallback : void 0,
-			run: (fn) => runWithFragmentRenderCtx(frag, fn),
+			run: (fn) => runWithFragmentCtx(frag, fn),
 			markDirty: markInteropFallbackDirty
 		};
 		const localFallbackBoundary = {
@@ -14731,37 +14948,38 @@ function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 				return outletFallbackBoundary;
 			},
 			getFallback: () => slotState.localFallback.value ? localFallback : void 0,
-			run: (fn) => runWithFragmentRenderCtx(frag, fn),
+			run: (fn) => runWithFragmentCtx(frag, fn),
 			markDirty: markInteropFallbackDirty
 		};
-		outlet = {
+		fallbackState = {
 			boundary: localFallbackBoundary,
 			activeFallback: null,
 			pendingRecheck: false,
 			isRenderingFallback: false,
 			getContent: () => contentNodes,
-			getParentNode: () => getSlotFallbackParentNode(currentParentNode, contentNodes),
+			getParentNode: () => currentParentNode,
 			getAnchor: () => currentAnchor,
 			isBusy: () => isResolvingContent,
 			isDisposed: () => disposed,
-			syncEffectiveOutput: () => {
-				frag.nodes = getSlotEffectiveOutput(outlet);
-				frag.validityPending = false;
+			isContentValid: () => isValidBlock(contentNodes),
+			syncNodes: () => {
+				frag.nodes = fallbackState.activeFallback || contentNodes;
+				validityPending = false;
 			},
 			notifyFallbackValidityChange: () => {
 				if (inheritedBoundary) inheritedBoundary.markDirty();
 			}
 		};
 		const takePendingRecheck = () => {
-			const shouldRecheck = outlet.pendingRecheck;
-			outlet.pendingRecheck = false;
+			const shouldRecheck = fallbackState.pendingRecheck;
+			fallbackState.pendingRecheck = false;
 			return shouldRecheck;
 		};
 		const dispose = (parentNode) => {
 			if (disposed) return;
-			currentParentNode = parentNode || currentParentNode;
+			if (parentNode) currentParentNode = parentNode;
 			disposed = true;
-			disposeSlotFallback(outlet);
+			disposeSlotFallback(fallbackState);
 			slotScope = void 0;
 			currentParentNode = null;
 			currentAnchor = null;
@@ -14769,22 +14987,23 @@ function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 		try {
 			localFallback = createFallback(() => (slotState.localFallback.value || renderEmptyVNodes)(), parentComponent, () => !!slotState.localFallback.value && !!slotState.localFallback.value.__vdom);
 			outletFallback = createFallback(() => (slotState.outletFallback.value || renderEmptyVNodes)(), parentComponent, () => !!slotState.outletFallback.value && !!slotState.outletFallback.value.__vdom);
-			const preferSlotFragmentOwnership = !!slotState.localFallback.value || !!slotState.outletFallback.value;
-			outlet.pendingRecheck = false;
+			const hasInteropFallback = !!slotState.localFallback.value || !!slotState.outletFallback.value;
+			fallbackState.pendingRecheck = false;
 			const finalizeResolvedContent = (resolvedContent) => {
-				if (preferSlotFragmentOwnership && resolvedContent instanceof SlotFragment) return resolvedContent;
-				contentNodes = resolvedContent || [];
-				recheckSlotFallback(outlet, takePendingRecheck());
+				if (resolvedContent && scopeIds) setScopeId(resolvedContent, scopeIds);
+				if (hasInteropFallback && resolvedContent instanceof SlotFragment) return resolvedContent;
+				contentNodes = resolvedContent || EMPTY_BLOCK;
+				recheckSlotFallback(fallbackState, takePendingRecheck());
 				return resolvedContent;
 			};
 			let resolvedContent;
 			isResolvingContent = true;
 			try {
-				if (isHydrating$1) resolvedContent = withHydratingSlotBoundary(() => finalizeResolvedContent(runWithFragmentRenderCtx(frag, () => {
+				if (isHydrating$1) resolvedContent = withHydratingSlotBoundary(() => finalizeResolvedContent(runWithFragmentCtx(frag, () => {
 					const renderSlot = () => withOwnedSlotBoundary(localFallbackBoundary, () => invokeVaporSlot(vnode));
 					return hasSlotFallback(localFallbackBoundary) ? withHydratingSlotFallbackActive(renderSlot) : renderSlot();
 				})));
-				else resolvedContent = finalizeResolvedContent(runWithFragmentRenderCtx(frag, () => withOwnedSlotBoundary(localFallbackBoundary, () => invokeVaporSlot(vnode))));
+				else resolvedContent = finalizeResolvedContent(runWithFragmentCtx(frag, () => withOwnedSlotBoundary(localFallbackBoundary, () => invokeVaporSlot(vnode))));
 			} finally {
 				isResolvingContent = false;
 			}
@@ -14795,30 +15014,30 @@ function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 					onScopeDispose(() => dispose(), true);
 				});
 			}
-			if (preferSlotFragmentOwnership && resolvedContent instanceof SlotFragment) {
+			if (hasInteropFallback && resolvedContent instanceof SlotFragment) {
 				ownedSlotFragment = resolvedContent;
 				trackInteropFallbackChanges(vnode.vs.scope, slotState, () => markInteropFallbackDirty());
 				dispose();
 				return resolvedContent;
 			}
-			outlet.pendingRecheck = false;
+			fallbackState.pendingRecheck = false;
 			frag.insert = (parentNode, anchor) => {
 				currentParentNode = parentNode;
 				currentAnchor = anchor;
-				if (outlet.activeFallback) {
-					insertActiveSlotFallback(outlet);
-					mutateSlotFallbackCarrier(contentNodes, (block) => insert(block, parentNode, anchor));
-				} else insert(frag.nodes, parentNode, anchor);
+				if (fallbackState.activeFallback) insertActiveSlotFallback(fallbackState);
+				else insert(frag.nodes, parentNode, anchor);
 			};
 			frag.remove = (parentNode) => {
-				if (outlet.activeFallback) mutateSlotFallbackCarrier(contentNodes, (block) => remove(block, parentNode));
-				else remove(frag.nodes, parentNode);
+				if (!fallbackState.activeFallback) remove(frag.nodes, parentNode);
 				dispose(parentNode);
 			};
 			trackInteropFallbackChanges(vnode.vs.scope, slotState, () => {
-				recheckSlotFallback(outlet, true);
-				syncActiveSlotFallback(outlet);
+				recheckSlotFallback(fallbackState, true);
 			});
+			if (isHydrating$1 && currentHydrationNode) {
+				currentAnchor = currentHydrationNode;
+				currentParentNode = currentAnchor.parentNode;
+			}
 			return frag;
 		} catch (e) {
 			dispose();
@@ -14894,24 +15113,24 @@ function ensureVNodeHookState(instance, vnode) {
 }
 function createVNodeChildrenFragment(internals, render, parentComponent) {
 	const suspense = parentSuspense || parentComponent && parentComponent.suspense;
-	const frag = new VaporFragment([]);
+	const frag = createInteropFragment();
 	let contentValid = false;
-	frag.validityPending = !isHydrating$1;
-	frag.isBlockValid = () => frag.validityPending ? true : contentValid;
+	let validityPending = !isHydrating$1;
+	frag.isBlockValid = () => validityPending ? true : contentValid;
 	let currentVNode = null;
-	let currentChildren = [];
+	let currentChildren = EMPTY_VNODES;
 	let currentParentNode = null;
 	let currentAnchor = null;
 	let isMounted = false;
 	let isRenderEffectStarted = false;
 	const scope = effectScope();
 	const syncResolvedNodes = (children = currentChildren) => {
-		const prevValid = frag.validityPending ? true : contentValid;
+		const prevValid = validityPending ? true : contentValid;
 		contentValid = !!ensureValidVNode(children);
-		if (children.length === 0) frag.nodes = [];
+		if (children.length === 0) frag.nodes = EMPTY_BLOCK;
 		else if (children.length === 1) frag.nodes = resolveVNodeNodes(children[0]);
 		else frag.nodes = children.map(resolveVNodeNodes);
-		frag.validityPending = false;
+		validityPending = false;
 		return prevValid !== contentValid;
 	};
 	const notifyUpdated = (validityChanged = false) => {
@@ -14923,7 +15142,7 @@ function createVNodeChildrenFragment(internals, render, parentComponent) {
 		simpleSetCurrentInstance(parentComponent);
 		try {
 			renderEffect(() => {
-				runWithFragmentRenderCtx(frag, () => {
+				runWithFragmentCtx(frag, () => {
 					const nextChildren = render();
 					if (isHydrating$1) {
 						nextChildren.forEach((vnode) => hydrateVNode(vnode, parentComponent));
@@ -14935,8 +15154,9 @@ function createVNodeChildrenFragment(internals, render, parentComponent) {
 					} else if (!isMounted) {
 						currentChildren = nextChildren;
 						currentVNode = createVNode(Fragment, null, nextChildren);
-						contentValid = !!ensureValidVNode(nextChildren);
-						frag.validityPending = false;
+						const wasPending = validityPending;
+						const validityChanged = syncResolvedNodes(nextChildren);
+						if (!wasPending) notifyUpdated(validityChanged);
 						return;
 					} else if (!currentVNode) {
 						currentChildren = nextChildren;
@@ -15022,7 +15242,23 @@ function normalizeInteropSlots(rawSlots) {
 	});
 	return normalized;
 }
+const interopSlotCache = /* @__PURE__ */ new WeakMap();
 function normalizeInteropSlot(rawSlot, ctx) {
+	let cache = interopSlotCache.get(rawSlot);
+	if (!cache) interopSlotCache.set(rawSlot, cache = {});
+	if (ctx) {
+		let ctxCache = cache.ctx;
+		if (!ctxCache) cache.ctx = ctxCache = /* @__PURE__ */ new WeakMap();
+		const cached = ctxCache.get(ctx);
+		if (cached) return cached;
+		const normalized = createNormalizedInteropSlot(rawSlot, ctx);
+		ctxCache.set(ctx, normalized);
+		return normalized;
+	}
+	if (cache.noCtx) return cache.noCtx;
+	return cache.noCtx = createNormalizedInteropSlot(rawSlot, ctx);
+}
+function createNormalizedInteropSlot(rawSlot, ctx) {
 	const normalized = withCtx((...args) => normalizeInteropSlotValue(rawSlot(...args)), ctx);
 	normalized._c = false;
 	return normalized;
@@ -15036,7 +15272,7 @@ function normalizeInteropDefaultSlot(value) {
 function normalizeInteropSlotValue(value) {
 	return isArray(value) ? value.map((child) => normalizeVNode(child)) : [normalizeVNode(value)];
 }
-const isInternalSlotKey = (key) => key === "_" || key === "_ctx" || key === "$stable";
+const isInternalSlotKey = (key) => key === "_" || key === "_ctx" || key === "$stable" || key === "$";
 const interopSlotsSourceHandlers = {
 	get(target, key) {
 		const slots = target.value;
@@ -15048,7 +15284,7 @@ const interopSlotsSourceHandlers = {
 	},
 	ownKeys(target) {
 		const slots = target.value;
-		return slots ? Object.keys(slots).filter((key) => !isInternalSlotKey(key)) : [];
+		return slots ? Object.keys(slots).filter((key) => !isInternalSlotKey(key)) : EMPTY_ARR;
 	},
 	getOwnPropertyDescriptor(target, key) {
 		const slots = target.value;
@@ -15088,11 +15324,27 @@ function setInteropVnodeScopeId(instance, vnode, parentComponent) {
 	}
 	if (interopScopeIdRootMap.get(instance) === root) return;
 	interopScopeIdRootMap.set(instance, root);
+	const scopeIds = getInteropVnodeScopeIds(vnode, parentComponent);
+	if (!scopeIds) return;
+	for (let i = 0; i < scopeIds.length; i++) root.setAttribute(scopeIds[i], "");
+}
+function getInteropVnodeScopeIds(vnode, parentComponent) {
 	const scopeIds = [];
 	if (vnode.scopeId) scopeIds.push(vnode.scopeId);
 	if (vnode.slotScopeIds) scopeIds.push(...vnode.slotScopeIds);
 	scopeIds.push(...getInheritedScopeIds(vnode, parentComponent));
-	for (let i = 0; i < scopeIds.length; i++) root.setAttribute(scopeIds[i], "");
+	return scopeIds.length ? scopeIds : void 0;
+}
+function getInteropVaporSlotScopeIds(vnode, parentComponent) {
+	const scopeIds = [];
+	if (vnode.slotScopeIds) scopeIds.push(...vnode.slotScopeIds);
+	scopeIds.push(...getInheritedScopeIds(vnode, parentComponent));
+	return scopeIds.length ? scopeIds : void 0;
+}
+function createInteropFragment(nodes = EMPTY_BLOCK, vnode = null) {
+	const frag = new VaporFragment(nodes);
+	frag.vnode = vnode;
+	return frag;
 }
 //#endregion
 //#region packages/runtime-vapor/src/components/Teleport.ts
@@ -15107,28 +15359,29 @@ const VaporTeleportImpl = {
 var TeleportFragment = class extends VaporFragment {
 	constructor(props, slots) {
 		super([]);
-		this.__isTeleportFragment = true;
-		this.isMounted = false;
+		this.__tf = true;
 		this.childrenInitialized = false;
-		this.ownerInstance = currentInstance;
 		this.childrenScope = getCurrentScope();
+		this.mountState = { location: 0 };
 		this.insert = (container, anchor) => {
 			if (isHydrating$1) return;
+			const wasMountedInTarget = this.mountState.location === 2;
 			if (!this.placeholder) this.placeholder = /* @__PURE__ */ createComment("teleport start");
 			insert(this.placeholder, container, anchor);
 			insert(this.anchor, container, anchor);
-			this.handlePropsUpdate();
+			if (!wasMountedInTarget) 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);
+			const mountState = this.mountState;
+			if (this.nodes && mountState.location !== 0) {
+				remove(this.nodes, mountState.container);
 				this.nodes = [];
 			}
-			this.isMounted = false;
+			this.mountState = { location: 0 };
 			if (this.targetStart) {
 				remove(this.targetStart, /* @__PURE__ */ parentNode(this.targetStart));
 				this.targetStart = void 0;
@@ -15138,8 +15391,6 @@ var TeleportFragment = class extends VaporFragment {
 				this.targetAnchor = void 0;
 			}
 			this.target = void 0;
-			this.mountContainer = void 0;
-			this.mountAnchor = void 0;
 		};
 		this.remove = (_parent) => {
 			this.dispose();
@@ -15162,26 +15413,28 @@ var TeleportFragment = class extends VaporFragment {
 				if (disabled) this.hydrateDisabledTeleport(target, targetNode);
 				else {
 					this.anchor = markHydrationAnchor(locateTeleportEndAnchor(currentHydrationNode.nextSibling));
-					this.mountContainer = target;
 					this.hydrateTargetAnchors(target, targetNode);
-					this.mountAnchor = this.targetAnchor;
+					this.mountState = {
+						location: 2,
+						container: target,
+						anchor: this.targetAnchor || null
+					};
 					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);
+			if (target || disabled) this.updateCssVars();
 			advanceHydrationNode(this.anchor);
 		};
-		this.rawProps = props;
 		this.rawSlots = slots;
-		this.parentComponent = getScopeOwner();
 		this.anchor = isHydrating$1 ? void 0 : /* @__PURE__ */ createComment("teleport end");
+		const propsProxy = new Proxy(props, rawPropsProxyHandlers);
 		renderEffect(() => {
 			const prevTo = this.resolvedProps && this.resolvedProps.to;
 			const wasDisabled = this.isDisabled;
-			this.resolvedProps = extend({}, new Proxy(this.rawProps, rawPropsProxyHandlers));
+			this.resolvedProps = extend({}, propsProxy);
 			this.isDisabled = isTeleportDisabled(this.resolvedProps);
 			if (wasDisabled !== this.isDisabled || !this.isDisabled && prevTo !== this.resolvedProps.to) this.handlePropsUpdate();
 		});
@@ -15189,8 +15442,11 @@ var TeleportFragment = class extends VaporFragment {
 	get parent() {
 		return this.anchor ? /* @__PURE__ */ parentNode(this.anchor) : null;
 	}
+	get scopeOwner() {
+		return this.slotOwner || this.renderInstance;
+	}
 	initChildren() {
-		const prevInstance = setCurrentInstance(this.ownerInstance, this.childrenScope);
+		const prevInstance = setCurrentInstance(this.renderInstance, this.childrenScope);
 		try {
 			this.childrenInitialized = true;
 			renderEffect(() => this.runWithRenderCtx(() => this.handleChildrenUpdate(this.rawSlots && this.rawSlots.default ? this.rawSlots.default() : []), this.childrenScope));
@@ -15204,76 +15460,87 @@ var TeleportFragment = class extends VaporFragment {
 	}
 	registerUpdateCssVars(block) {
 		if (isFragment(block)) {
-			(block.onUpdated || (block.onUpdated = [])).push(() => updateCssVars(this));
+			(block.onUpdated || (block.onUpdated = [])).push(() => this.updateCssVars());
 			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 (isVaporComponent(block)) block.parentTeleport = this;
-		else if (isArray(block)) block.forEach((node) => isVaporComponent(node) && (node.parentTeleport = this));
+		const scopeOwner = this.scopeOwner;
+		if (scopeOwner && scopeOwner.ut) this.registerUpdateCssVars(block);
 	}
 	handleChildrenUpdate(children) {
-		if (isHydrating$1 || !this.parent || !this.mountContainer) {
+		const mountState = this.mountState;
+		if (isHydrating$1 || !this.parent || mountState.location === 0) {
 			this.nodes = children;
 			return;
 		}
-		remove(this.nodes, this.mountContainer);
-		insert(this.nodes = children, this.mountContainer, this.mountAnchor);
+		remove(this.nodes, mountState.container);
+		this.nodes = children;
+		const onBeforeInsert = this.onBeforeInsert;
+		if (onBeforeInsert) onBeforeInsert.forEach((fn) => fn(this.nodes));
+		insert(children, mountState.container, mountState.anchor);
 		this.bindChildren(this.nodes);
-		updateCssVars(this);
+		this.updateCssVars();
 	}
-	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);
+	mount(parent, anchor, location) {
+		if (isTransitionEnabled && this.$transition && this.mountState.location === 0) applyTransitionHooks(this.nodes, this.$transition);
+		if (this.mountState.location !== 0) move(this.nodes, parent, anchor, 2);
 		else {
-			insert(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor);
-			this.isMounted = true;
+			const onBeforeInsert = this.onBeforeInsert;
+			if (onBeforeInsert) onBeforeInsert.forEach((fn) => fn(this.nodes));
+			insert(this.nodes, parent, anchor);
+		}
+		this.mountState = {
+			location,
+			container: parent,
+			anchor
+		};
+		this.updateCssVars();
+	}
+	prepareTargetAnchors(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);
 		}
-		updateCssVars(this);
 	}
-	mountToTarget() {
+	prepareTarget() {
 		const target = this.target = resolveTarget(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.prepareTargetAnchors(target);
+			const scopeOwner = this.scopeOwner;
+			if (scopeOwner && scopeOwner.isCE) (scopeOwner.ce._teleportTargets || (scopeOwner.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
+		}
+		return target;
+	}
+	queueTargetUpdate() {
+		if (!this.mountToTargetJob || this.mountToTargetJob.flags & 4) this.mountToTargetJob = () => {
+			this.mountToTargetJob = void 0;
+			if (!this.anchor) return;
+			if (this.isDisabled) {
+				if (!this.targetAnchor) this.prepareTarget();
+			} else this.mountToTarget();
+		};
+		queuePostFlushCb(this.mountToTargetJob);
+	}
+	mountToTarget() {
+		const target = this.prepareTarget();
+		if (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);
+			this.mount(target, this.targetAnchor, 2);
 		} else 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();
-		}
+			this.mount(this.parent, this.anchor, 1);
+			if (!this.targetAnchor) if (isTeleportDeferred(this.resolvedProps) || !this.parent.isConnected) this.queueTargetUpdate();
+			else this.prepareTarget();
+		} else if (isTeleportDeferred(this.resolvedProps) || !this.parent.isConnected) this.queueTargetUpdate();
+		else this.mountToTarget();
 	}
 	hydrateTargetAnchors(target, targetNode) {
 		let targetAnchor = targetNode;
@@ -15293,8 +15560,12 @@ var TeleportFragment = class extends VaporFragment {
 		if (!isHydrating$1) return;
 		let nextNode = this.placeholder.nextSibling;
 		setCurrentHydrationNode(nextNode);
-		this.mountAnchor = this.anchor = markHydrationAnchor(locateTeleportEndAnchor(nextNode));
-		this.mountContainer = /* @__PURE__ */ parentNode(this.anchor);
+		this.anchor = markHydrationAnchor(locateTeleportEndAnchor(nextNode));
+		this.mountState = {
+			location: 1,
+			container: /* @__PURE__ */ parentNode(this.anchor),
+			anchor: this.anchor
+		};
 		if (target) this.hydrateTargetAnchors(target, targetNode);
 		else {
 			this.targetStart = targetNode;
@@ -15305,13 +15576,42 @@ var TeleportFragment = class extends VaporFragment {
 	mountChildren(target) {
 		if (!isHydrating$1) return;
 		target.appendChild(this.targetStart = /* @__PURE__ */ createTextNode(""));
-		target.appendChild(this.mountAnchor = this.targetAnchor = markHydrationAnchor(/* @__PURE__ */ createTextNode("")));
+		target.appendChild(this.targetAnchor = markHydrationAnchor(/* @__PURE__ */ createTextNode("")));
+		this.mountState = {
+			location: 2,
+			container: target,
+			anchor: this.targetAnchor
+		};
 		if (!isMismatchAllowed(target, 1)) {
 			warn(`Hydration children mismatch on`, target, `\nServer rendered element contains fewer child nodes than client nodes.`);
 			logMismatchError();
 		}
 		runWithoutHydration(this.initChildren.bind(this));
 	}
+	updateCssVars() {
+		const ctx = this.scopeOwner;
+		if (ctx && ctx.ut) {
+			let node;
+			let anchor;
+			if (this.mountState.location === 1) {
+				node = this.placeholder;
+				anchor = this.anchor;
+			} else if (this.mountState.location === 2) {
+				node = this.targetStart;
+				anchor = this.targetAnchor;
+			} else return;
+			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();
+			}
+		}
+	}
 };
 const VaporTeleport = /* @__PURE__ */ enableTeleport(VaporTeleportImpl);
 function locateTeleportEndAnchor(node = currentHydrationNode) {
@@ -15324,29 +15624,6 @@ function locateTeleportEndAnchor(node = currentHydrationNode) {
 	}
 	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/apiDefineCustomElement.ts
 const vaporCustomElementHydrates = /* @__PURE__ */ new WeakMap();
@@ -15368,7 +15645,7 @@ const defineVaporSSRCustomElement = ((options, extraOptions) => {
 });
 var VaporElement = class extends VueElementBase {
 	constructor(def, props = {}, createAppFn = createVaporApp) {
-		super(def, props, createAppFn);
+		super(def, /* @__PURE__ */ shallowReactive(props), createAppFn);
 	}
 	_needsHydration() {
 		const hydrate = vaporCustomElementHydrates.get(this.constructor);
@@ -15387,13 +15664,9 @@ var VaporElement = class extends VueElementBase {
 		this._app.mount(this._root);
 		if (!this.shadowRoot) this._renderSlots();
 	}
-	_update() {
-		if (!this._app) return;
-		const renderEffects = this._instance.renderEffects;
-		if (renderEffects) renderEffects.forEach((e) => e.run());
-	}
+	_update() {}
 	_unmount() {
-		this._app.unmount();
+		if (this._app) this._app.unmount();
 		if (this._instance && this._instance.ce) this._instance.ce = void 0;
 		this._app = this._instance = null;
 	}
@@ -15425,12 +15698,12 @@ var VaporElement = class extends VueElementBase {
 		else this._updateFragmentNodes(nodes, replacements);
 	}
 	_createComponent() {
-		this._def.ce = (instance) => {
+		const ce = (instance) => {
 			this._app._ceComponent = this._instance = instance;
 			if (!this.shadowRoot) this._instance.u = [this._renderSlots.bind(this)];
 			this._processInstance();
 		};
-		createComponent(this._def, this._props, void 0, void 0, void 0, this._app._context);
+		createComponent(this._def, this._props, void 0, void 0, void 0, this._app._context, false, ce);
 	}
 };
 //#endregion
@@ -15490,10 +15763,10 @@ function createIf(condition, b1, b2, flags = 1) {
 		}
 		frag = ok ? b1() : b2 ? b2() : [/* @__PURE__ */ createComment("if")];
 	} else {
-		const index = flags >> 7;
+		const index = flags >> 8;
 		const keyed = index > 0;
 		const keyBase = keyed ? (index - 1) * 2 : 0;
-		frag = new DynamicFragment("if", keyed, false);
+		frag = new DynamicFragment("if", keyed, false, !!(flags & 128));
 		renderEffect(() => {
 			const ok = condition();
 			if (isHydrating$1) {
@@ -15565,10 +15838,10 @@ const createFor = (src, renderItem, getKey, flags = 0) => {
 	let parentAnchor;
 	let pendingHydrationAnchor = false;
 	if (!isHydrating$1) parentAnchor = /* @__PURE__ */ createComment("for");
-	const frag = new ForFragment(oldBlocks);
+	const frag = new ForFragment(oldBlocks, !!(flags & 32));
 	const instance = currentInstance;
-	const canUseFastRemove = !!(flags & 1);
 	const isComponent = !!(flags & 2);
+	const canUseFastRemove = !!(flags & 1) && !isComponent;
 	const isSingleNode = !!(flags & 8);
 	const isFragment = !!(flags & 16);
 	const slotOwner = currentSlotOwner;
@@ -15590,8 +15863,9 @@ const createFor = (src, renderItem, getKey, flags = 0) => {
 			for (let i = 0; i < newLength; i++) newKeys[i] = getKey(...getItem(source, i));
 		}
 		const prevSub = setActiveSub();
-		if (isMounted && frag.onBeforeUpdate) for (let i = 0; i < frag.onBeforeUpdate.length; i++) frag.onBeforeUpdate[i]();
-		if (!isMounted) {
+		const wasMounted = isMounted;
+		if (wasMounted && frag.onBeforeUpdate) for (let i = 0; i < frag.onBeforeUpdate.length; i++) frag.onBeforeUpdate[i]();
+		if (!wasMounted) {
 			isMounted = true;
 			if (isHydrating$1) hydrateList(source, newLength);
 			else for (let i = 0; i < newLength; i++) mount(source, i);
@@ -15608,7 +15882,10 @@ const createFor = (src, renderItem, getKey, flags = 0) => {
 				}
 			} 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]);
+				for (let i = 0; i < commonLength; i++) {
+					const item = getItem(source, i);
+					update(newBlocks[i] = oldBlocks[i], ...item);
+				}
 				for (let i = oldLength; i < newLength; i++) mount(source, i);
 				for (let i = newLength; i < oldLength; i++) unmount(oldBlocks[i]);
 			} else {
@@ -15646,7 +15923,7 @@ const createFor = (src, renderItem, getKey, flags = 0) => {
 					const currentKey = newKeys[i];
 					const oldBlock = oldBlocks[i];
 					const oldKey = oldBlock.key;
-					if (oldKey === currentKey) update(newBlocks[i] = oldBlock, currentItem[0]);
+					if (oldKey === currentKey) update(newBlocks[i] = oldBlock, ...currentItem);
 					else {
 						queuedBlocks[queuedBlocksLength++] = [
 							i,
@@ -15747,7 +16024,7 @@ const createFor = (src, renderItem, getKey, flags = 0) => {
 		}
 		frag.nodes = [oldBlocks = newBlocks];
 		if (parentAnchor) frag.nodes.push(parentAnchor);
-		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
+		if (wasMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
 		setActiveSub(prevSub);
 	};
 	const needKey = renderItem.length > 1;
@@ -15775,7 +16052,11 @@ const createFor = (src, renderItem, getKey, flags = 0) => {
 			if (frag.$transition.applyGroup) setBlockKey(block.nodes, block.key);
 			applyTransitionHooks(block.nodes, frag.$transition);
 		}
-		if (parent) insertForBlock(block, anchor);
+		if (parent) {
+			const onBeforeInsert = frag.onBeforeInsert;
+			if (onBeforeInsert) onBeforeInsert.forEach((fn) => fn(block.nodes));
+			insertForBlock(block, anchor);
+		}
 		return block;
 	};
 	function hydrateList(source, newLength) {
@@ -15957,11 +16238,14 @@ function normalizeSource(source) {
 			isReadonlySource = /* @__PURE__ */ isReadonly(source);
 		}
 	} else if (isString(source)) values = source.split("");
-	else if (typeof source === "number") {
-		if (!Number.isInteger(source)) warn(`The v-for range expect an integer value but got ${source}.`);
+	else if (typeof source === "number") if (!Number.isInteger(source) || source < 0) {
+		warn(`The v-for range expects a positive integer value but got ${source}.`);
+		values = [];
+	} else {
 		values = new Array(source);
 		for (let i = 0; i < source; i++) values[i] = i + 1;
-	} else if (isObject(source)) if (source[Symbol.iterator]) values = Array.from(source);
+	}
+	else if (isObject(source)) if (source[Symbol.iterator]) values = Array.from(source);
 	else {
 		keys = Object.keys(source);
 		values = new Array(keys.length);
@@ -15998,8 +16282,7 @@ function normalizeAnchor(node) {
 		return;
 	} else if (isVaporComponent(node)) return normalizeAnchor(node.block);
 	else {
-		const getEffectiveOutput = node.getEffectiveOutput;
-		const nodes = getEffectiveOutput ? getEffectiveOutput.call(node) : node.nodes;
+		const nodes = node.nodes;
 		return isValidBlock(nodes) ? normalizeAnchor(nodes) : node.anchor || normalizeAnchor(nodes);
 	}
 }
@@ -16008,11 +16291,8 @@ function getRestElement(val, keys) {
 	for (const key in val) if (!keys.includes(key)) res[key] = val[key];
 	return res;
 }
-function getDefaultValue(val, defaultVal) {
-	return val === void 0 ? defaultVal : val;
-}
-function isForBlock(block) {
-	return block instanceof ForBlock;
+function getDefaultValue(val, getDefaultVal) {
+	return val === void 0 ? getDefaultVal() : val;
 }
 //#endregion
 //#region packages/runtime-vapor/src/apiTemplateRef.ts
@@ -16034,25 +16314,39 @@ function ensureCleanup(el) {
 }
 function createTemplateRefSetter() {
 	const instance = currentInstance;
-	const oldRefMap = /* @__PURE__ */ new WeakMap();
-	const setRefMap = /* @__PURE__ */ new WeakMap();
+	const stateMap = /* @__PURE__ */ new WeakMap();
 	return (el, ref, refFor, refKey) => {
-		const frag = getTemplateRefUpdateFragment(el);
-		if (frag) {
-			const doSet = () => {
-				if (isVaporComponent(el) && el.isDeactivated) return;
-				oldRefMap.set(el, setRef$1(instance, el, ref, oldRefMap.get(el), refFor, refKey));
-			};
-			const prevSet = setRefMap.get(frag);
-			if (prevSet && frag.onUpdated) remove$1(frag.onUpdated, prevSet);
-			(frag.onUpdated || (frag.onUpdated = [])).push(doSet);
-			setRefMap.set(frag, doSet);
-		}
-		const oldRef = setRef$1(instance, el, ref, oldRefMap.get(el), refFor, refKey);
-		oldRefMap.set(el, oldRef);
-		return oldRef;
+		let state = stateMap.get(el);
+		if (!state) stateMap.set(el, state = { ref });
+		return setTemplateRefWithState(instance, el, state, ref, refFor, refKey);
+	};
+}
+function createSingleTemplateRefSetter() {
+	const instance = currentInstance;
+	let state;
+	return (el, ref, refFor, refKey) => {
+		if (!state) state = { ref };
+		return setTemplateRefWithState(instance, el, state, ref, refFor, refKey);
 	};
 }
+function setTemplateRefWithState(instance, el, state, ref, refFor, refKey) {
+	state.ref = ref;
+	state.refFor = refFor;
+	state.refKey = refKey;
+	const frag = getTemplateRefUpdateFragment(el);
+	if (frag && state.registeredFrag !== frag) {
+		state.registeredFrag = frag;
+		(frag.onUpdated || (frag.onUpdated = [])).push(() => {
+			if (isVaporComponent(el) && el.isDeactivated) return;
+			state.oldRef = setRef$1(instance, el, state.ref, state.oldRef, state.refFor, state.refKey, state.oldRefKey);
+			state.oldRefKey = state.oldRef != null ? state.refKey : void 0;
+		});
+	}
+	const oldRef = setRef$1(instance, el, ref, state.oldRef, refFor, refKey, state.oldRefKey);
+	state.oldRef = oldRef;
+	state.oldRefKey = oldRef != null ? refKey : void 0;
+	return oldRef;
+}
 function setStaticTemplateRef(el, ref, refFor, refKey) {
 	const instance = currentInstance;
 	const oldRef = setRef$1(instance, el, ref, void 0, refFor, refKey);
@@ -16063,13 +16357,13 @@ function setStaticTemplateRef(el, ref, refFor, refKey) {
 	});
 	return oldRef;
 }
-function setTemplateRefBinding(el, getter, setter = createTemplateRefSetter(), refFor, refKey) {
+function setTemplateRefBinding(el, getter, setter = createSingleTemplateRefSetter(), refFor, refKey) {
 	renderEffect(() => setter(el, getter(), refFor, refKey));
 }
 /**
 * Function for handling a template ref
 */
-function setRef$1(instance, el, ref, oldRef, refFor = false, refKey) {
+function setRef$1(instance, el, ref, oldRef, refFor = false, refKey, oldRefKey) {
 	if (!instance || instance.isUnmounted) return;
 	const setupState = instance.setupState || {};
 	const refValue = getRefValue(el);
@@ -16093,7 +16387,8 @@ function setRef$1(instance, el, ref, oldRef, refFor = false, refKey) {
 			refs[oldRef] = null;
 			if (canSetSetupRef(oldRef)) setupState[oldRef] = null;
 		} else if (/* @__PURE__ */ isRef(oldRef)) {
-			if (canSetRef(oldRef)) oldRef.value = null;
+			if (canSetRef(oldRef, oldRefKey)) oldRef.value = null;
+			if (oldRefKey) refs[oldRefKey] = null;
 		} else if (isFunction(oldRef) && isDynamicFragment(el)) callWithErrorHandling(oldRef, instance, 12, [null, refs]);
 	} else if (oldRef != null && isDynamicFragment(el)) {
 		if (isFunction(oldRef)) callWithErrorHandling(oldRef, instance, 12, [null, refs]);
@@ -16200,12 +16495,15 @@ function setVarsOnBlock(block, vars) {
 }
 //#endregion
 //#region packages/runtime-vapor/src/apiCreateDynamicComponent.ts
-function createDynamicComponent(getter, rawProps, rawSlots, isSingleRoot, once) {
+function createDynamicComponent(getter, rawProps, rawSlots, flags = 0) {
+	const isSingleRoot = !!(flags & 1);
+	const once = !!(flags & 2);
+	const slotRoot = !!(flags & 4);
 	const _insertionParent = insertionParent;
 	const _insertionAnchor = insertionAnchor;
 	if (!isHydrating$1) resetInsertionState();
 	const hydrationCursor = isHydrating$1 ? captureHydrationCursor() : null;
-	const frag = new DynamicFragment("dynamic-component");
+	const frag = new DynamicFragment("dynamic-component", false, true, slotRoot);
 	const normalizedRawSlots = normalizeRawSlots(rawSlots);
 	const scopeOwner = getScopeOwner();
 	const renderFn = () => {
@@ -16370,11 +16668,11 @@ const VaporTransitionGroup = /* @__PURE__ */ decorate(/* @__PURE__ */ defineVapo
 			if (isUpdatePending) return;
 			isUpdatePending = true;
 			prevChildren = [];
-			const children = getTransitionBlocks(slottedBlock);
+			const children = resolveTransitionBlocks(slottedBlock);
 			for (let i = 0; i < children.length; i++) {
 				const child = children[i];
 				const el = isValidTransitionBlock(child) && child.$transition ? getTransitionElement(child) : void 0;
-				if (el) {
+				if (el && !el[vShowHidden]) {
 					prevChildren.push(child);
 					child.$transition.disabled = true;
 					positionMap.set(child, el.getBoundingClientRect());
@@ -16388,15 +16686,16 @@ const VaporTransitionGroup = /* @__PURE__ */ decorate(/* @__PURE__ */ defineVapo
 			if (!prevChildren.length) return;
 			const moveClass = props.moveClass || `${props.name || "v"}-move`;
 			const firstChild = getFirstConnectedChild(prevChildren);
-			if (!firstChild || !hasCSSTransform(firstChild, firstChild.parentNode, moveClass)) {
-				prevChildren = [];
-				return;
-			}
-			prevChildren.forEach(callPendingCbs);
+			const hasMove = !!(firstChild && hasCSSTransform(firstChild, firstChild.parentNode, moveClass));
 			prevChildren.forEach((child) => {
 				child.$transition.disabled = false;
-				recordPosition(child);
+				if (hasMove) callPendingCbs(child);
 			});
+			if (!hasMove) {
+				prevChildren = [];
+				return;
+			}
+			prevChildren.forEach(recordPosition);
 			const movedChildren = prevChildren.filter(applyTranslation);
 			forceReflow();
 			movedChildren.forEach((c) => handleMovedChildren(getTransitionElement(c), moveClass));
@@ -16459,7 +16758,7 @@ const VaporTransitionGroup = /* @__PURE__ */ decorate(/* @__PURE__ */ defineVapo
 }));
 function applyGroupTransitionHooks(block, props, state, instance, updateHooks) {
 	const fragments = [];
-	const children = getTransitionBlocks(block, (frag) => fragments.push(frag), (owner) => trackTransitionGroupUpdate(owner, updateHooks));
+	const children = resolveTransitionBlocks(block, (frag) => fragments.push(frag), (owner) => trackTransitionGroupUpdate(owner, updateHooks));
 	for (let i = 0; i < children.length; i++) {
 		const child = children[i];
 		if (isValidTransitionBlock(child)) if (child.$key != null) setTransitionHooks$1(child, resolveTransitionHooks$1(child, props, state, instance));
@@ -16506,47 +16805,6 @@ function trackTransitionGroupUpdate(owner, updateHooks) {
 		});
 	}
 }
-function inheritKey(children, key) {
-	if (key === void 0 || children.length === 0) return;
-	for (let i = 0; i < children.length; i++) {
-		const child = children[i];
-		child.$key = String(key) + String(child.$key != null ? child.$key : i);
-	}
-}
-function getTransitionBlocks(block, onFragment, onUpdateOwner) {
-	let children = [];
-	if (block instanceof Element) children.push(block);
-	else if (isVaporComponent(block)) {
-		const isRootSlot = block.block instanceof SlotFragment;
-		if (onUpdateOwner && !isRootSlot) onUpdateOwner(block);
-		const blocks = getTransitionBlocks(block.block, onFragment, isRootSlot ? onUpdateOwner : void 0);
-		inheritKey(blocks, block.$key);
-		children.push(...blocks);
-	} else if (isArray(block)) for (let i = 0; i < block.length; i++) {
-		const b = block[i];
-		const blocks = getTransitionBlocks(b, onFragment, onUpdateOwner);
-		if (isForBlock(b)) blocks.forEach((block) => block.$key = b.key);
-		children.push(...blocks);
-	}
-	else if (isFragment(block)) {
-		if (onFragment) onFragment(block);
-		if (onUpdateOwner) onUpdateOwner(block);
-		if (isInteropEnabled && block.vnode) children.push(block);
-		else {
-			const blocks = getTransitionBlocks(block.nodes, onFragment, onUpdateOwner);
-			inheritKey(blocks, block.$key);
-			children.push(...blocks);
-		}
-	}
-	return children;
-}
-function isValidTransitionBlock(block) {
-	return !!(block instanceof Element || isFragment(block) && block.vnode);
-}
-function getTransitionElement(block) {
-	if (block instanceof Element) return block;
-	if (isInteropEnabled && isFragment(block) && block.vnode) return getTransitionElementFromVNode(block.vnode);
-}
 function recordPosition(c) {
 	const el = getTransitionElement(c);
 	if (el) newPositionMap.set(c, el.getBoundingClientRect());
@@ -16563,4 +16821,4 @@ function getFirstConnectedChild(children) {
 	}
 }
 //#endregion
-export { BaseTransition, BaseTransitionPropsValidators, Comment$1 as Comment, DeprecationTypes, DynamicFragment, EffectScope, ErrorCodes, ErrorTypeStrings, Fragment, KeepAlive, MismatchTypes, MoveType, NULL_DYNAMIC_COMPONENT, ReactiveEffect, SchedulerJobFlags, Static, Suspense, Teleport, Text$1 as Text, TrackOpTypes, Transition, TransitionGroup, TransitionPropsValidators, TriggerOpTypes, VaporElement, VaporFragment, VaporKeepAlive, VaporSlot, VaporTeleport, VaporTransition, VaporTransitionGroup, VueElement, VueElementBase, activate, applyCheckboxModel, applyDynamicModel, applyRadioModel, applySelectModel, applyTextModel, applyVShow, assertNumber, baseApplyTranslation, baseEmit, baseNormalizePropsOptions, baseResolveTransitionHooks, baseUseCssVars, callPendingCbs, callWithAsyncErrorHandling, callWithErrorHandling, camelize, capitalize, checkTransitionMode, child, cloneVNode, compatUtils, compile, computed, createApp, createAppAPI, createAssetComponent, createAsyncComponentContext, createBlock, createCanSetSetupRefChecker, createCommentVNode, createComponent, createComponentWithFallback, createDynamicComponent, createElementBlock, createBaseVNode as createElementVNode, createFor, createForSlots, createHydrationRenderer, createIf, createInternalObject, createInvoker, createKeyedFragment, createPlainElement, createPropsRestProxy, createRenderer, createSSRApp, createSelector, createSlot, createSlots, createStaticVNode, createTemplateRefSetter, createTextNode, createTextVNode, createVNode, createVaporApp, createVaporSSRApp, currentInstance, customRef, deactivate, defineAsyncComponent, defineComponent, defineCustomElement, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSSRCustomElement, defineSlots, defineVaporAsyncComponent, defineVaporComponent, defineVaporCustomElement, defineVaporSSRCustomElement, delegate, delegateEvents, devtools, devtoolsComponentAdded, effect, effectScope, endMeasure, ensureHydrationRenderer, ensureRenderer, ensureValidVNode, ensureVaporSlotFallback, expose, flushOnAppMount, forceReflow, getAttributeMismatch, getComponentName, getCurrentInstance, getCurrentScope, getCurrentWatcher, getDefaultValue, getFunctionalFallthrough, getInheritedScopeIds, getRestElement, getTransitionRawChildren, guardReactiveProps, h, handleError, handleMovedChildren, hasCSSTransform, hasInjectionContext, hydrate, hydrateOnIdle, hydrateOnInteraction, hydrateOnMediaQuery, hydrateOnVisible, initCustomFormatter, initDirectivesForSSR, initFeatureFlags, inject, insert, invalidateMount, invokeDirectiveHook, isAsyncWrapper, isEmitListener, isFragment, isHydrating, isKeepAlive, isMapEqual, isMemoSame, isMismatchAllowed, isProxy, isReactive, isReadonly, isRef, isRuntimeOnly, isSetEqual, isShallow, isTeleportDeferred, isTeleportDisabled, isTemplateNode, isTemplateRefKey, isVNode, isValidHtmlOrSvgAttribute, isVaporComponent, knownTemplateRefs, leaveCbKey, markAsyncBoundary, markRaw, matches, mergeDefaults, mergeModels, mergeProps, next, nextTick, nextUid, nodeOps, normalizeClass, normalizeContainer, normalizeProps, normalizeRef, normalizeStyle, normalizeVNode, nthChild, on, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onBinding, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onScopeDispose, onServerPrefetch, onUnmounted, onUpdated, onWatcherCleanup, openBlock, patchProp, patchStyle, performAsyncHydrate, performTransitionEnter, performTransitionLeave, popScopeId, popWarningContext, prepend, provide, proxyRefs, pushScopeId, pushWarningContext, queueJob, queuePostFlushCb, reactive, readonly, ref, registerHMR, registerRuntimeCompiler, remove, render, renderEffect, renderList, renderSlot, resetShapeFlag, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolvePropValue, resolveTarget as resolveTeleportTarget, resolveTransitionHooks, resolveTransitionProps, setAttr, setBlockHtml, setBlockKey, setBlockText, setBlockTracking, setClass, setClassName, setCurrentInstance, setCurrentRenderingInstance, setDOMProp, setDevtoolsHook, setDynamicEvents, setDynamicProps, setElementText, setHtml, setInsertionState, setIsHydratingEnabled, setProp, setRef, setStaticTemplateRef, setStyle, setTemplateRefBinding, setText, setTransitionHooks, setValue, setVarsOnNode, shallowReactive, shallowReadonly, shallowRef, shouldSetAsProp, shouldSetAsPropForVueCE, shouldUpdateComponent, simpleSetCurrentInstance, ssrContextKey, ssrUtils, startMeasure, stop, svgNS, template, toClassSet, toDisplayString, toHandlerKey, toHandlers, toRaw, toRef, toRefs, toStyleMap, toValue, transformVNodeArgs, triggerRef, txt, unref, unregisterHMR, unsafeToTrustedHTML, useAsyncComponentState, useAttrs, useCssModule, useCssVars, useHost, useId, useInstanceOption, useModel, useSSRContext, useShadowRoot, useSlots, useTemplateRef, useTransitionState, useVaporCssVars, vModelCheckbox, vModelCheckboxInit, vModelCheckboxUpdate, vModelDynamic, getValue as vModelGetValue, vModelRadio, vModelSelect, vModelSelectInit, vModelSetSelected, vModelText, vModelTextInit, vModelTextUpdate, vShow, vShowHidden, vShowOriginalDisplay, validateComponentName, validateProps, vaporInteropPlugin, version, warn, warnExtraneousAttributes, warnPropMismatch, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withKeys, withMemo, withModifiers, withScopeId, withVaporCtx, withVaporDirectives, withVaporKeys, withVaporModifiers, xlinkNS };
+export { BaseTransition, BaseTransitionPropsValidators, Comment$1 as Comment, DeprecationTypes, DynamicFragment, EffectScope, ErrorCodes, ErrorTypeStrings, Fragment, KeepAlive, MismatchTypes, MoveType, NULL_DYNAMIC_COMPONENT, ReactiveEffect, SchedulerJobFlags, Static, Suspense, Teleport, Text$1 as Text, TrackOpTypes, Transition, TransitionGroup, TransitionPropsValidators, TriggerOpTypes, VaporElement, VaporFragment, VaporKeepAlive, VaporSlot, VaporTeleport, VaporTransition, VaporTransitionGroup, VueElement, VueElementBase, activate, applyCheckboxModel, applyDynamicModel, applyRadioModel, applySelectModel, applyTextModel, applyVShow, assertNumber, baseApplyTranslation, baseEmit, baseNormalizePropsOptions, baseResolveTransitionHooks, baseUseCssVars, callPendingCbs, callWithAsyncErrorHandling, callWithErrorHandling, camelize, capitalize, checkTransitionMode, child, cloneVNode, compatUtils, compile, computed, createApp, createAppAPI, createAssetComponent, createAsyncComponentContext, createBlock, createCanSetSetupRefChecker, createCommentVNode, createComponent, createComponentWithFallback, createDynamicComponent, createElementBlock, createBaseVNode as createElementVNode, createFor, createForSlots, createHydrationRenderer, createIf, createInternalObject, createInvoker, createKeyedFragment, createPlainElement, createPropsRestProxy, createRenderer, createSSRApp, createSelector, createSlot, createSlots, createStaticVNode, createTemplateRefSetter, createTextNode, createTextVNode, createVNode, createVaporApp, createVaporSSRApp, currentInstance, customRef, deactivate, defineAsyncComponent, defineComponent, defineCustomElement, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSSRCustomElement, defineSlots, defineVaporAsyncComponent, defineVaporComponent, defineVaporCustomElement, defineVaporSSRCustomElement, delegate, delegateEvents, devtools, devtoolsComponentAdded, effect, effectScope, endMeasure, ensureHydrationRenderer, ensureRenderer, ensureValidVNode, ensureVaporSlotFallback, expose, flushOnAppMount, forceReflow, getAttributeMismatch, getComponentName, getCurrentInstance, getCurrentScope, getCurrentWatcher, getDefaultValue, getFunctionalFallthrough, getInheritedScopeIds, getRestElement, getTransitionRawChildren, guardReactiveProps, h, handleError, handleMovedChildren, hasCSSTransform, hasInjectionContext, hydrate, hydrateOnIdle, hydrateOnInteraction, hydrateOnMediaQuery, hydrateOnVisible, initCustomFormatter, initDirectivesForSSR, initFeatureFlags, inject, insert, invalidateMount, invokeDirectiveHook, isAsyncWrapper, isEmitListener, isFragment, isHydrating, isKeepAlive, isMapEqual, isMemoSame, isMismatchAllowed, isProxy, isReactive, isReadonly, isRef, isRuntimeOnly, isSetEqual, isShallow, isTeleportDeferred, isTeleportDisabled, isTemplateNode, isTemplateRefKey, isVNode, isValidHtmlOrSvgAttribute, isVaporComponent, knownTemplateRefs, leaveCbKey, markAsyncBoundary, markRaw, matches, mergeDefaults, mergeModels, mergeProps, next, nextTick, nextUid, nodeOps, normalizeClass, normalizeContainer, normalizeProps, normalizeRef, normalizeStyle, normalizeVNode, nthChild, on, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onBinding, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onScopeDispose, onServerPrefetch, onUnmounted, onUpdated, onWatcherCleanup, openBlock, patchProp, patchStyle, performAsyncHydrate, performTransitionEnter, performTransitionLeave, popScopeId, popWarningContext, prepend, provide, proxyRefs, pushScopeId, pushWarningContext, queueJob, queuePostFlushCb, reactive, readonly, ref, registerHMR, registerRuntimeCompiler, remove, render, renderEffect, renderList, renderSlot, resetShapeFlag, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolvePropValue, resolveTarget as resolveTeleportTarget, resolveTransitionHooks, resolveTransitionProps, setAttr, setBlockHtml, setBlockKey, setBlockText, setBlockTracking, setClass, setClassName, setCurrentInstance, setCurrentRenderingInstance, setDOMProp, setDevtoolsHook, setDynamicEvents, setDynamicProps, setElementText, setHtml, setInsertionState, setIsHydratingEnabled, setProp, setRef, setStaticTemplateRef, setStyle, setTemplateRefBinding, setText, setTransitionHooks, setValue, setVarsOnNode, shallowReactive, shallowReadonly, shallowRef, shouldSetAsProp, shouldSetAsPropForVueCE, shouldUpdateComponent, simpleSetCurrentInstance, ssrContextKey, ssrUtils, startMeasure, stop, svgNS, template, toClassSet, toDisplayString, toHandlerKey, toHandlers, toRaw, toRef, toRefs, toStyleMap, toValue, transformVNodeArgs, triggerRef, txt, unref, unregisterHMR, unsafeToTrustedHTML, useAsyncComponentState, useAttrs, useCssModule, useCssVars, useHost, useId, useInstanceOption, useModel, useSSRContext, useShadowRoot, useSlots, useTemplateRef, useTransitionState, useVaporCssVars, vModelCheckbox, vModelCheckboxInit, vModelCheckboxUpdate, vModelDynamic, getValue as vModelGetValue, vModelRadio, vModelSelect, vModelSelectInit, vModelSetSelected, vModelText, vModelTextInit, vModelTextUpdate, vShow, vShowHidden, vShowOriginalDisplay, validateComponentName, validateProps, vaporInteropPlugin, version, warn, warnExtraneousAttributes, warnPropMismatch, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withKeys, withMemo, withModifiers, withScopeId, withVaporDirectives, withVaporKeys, withVaporModifiers, xlinkNS };