vue 3.6.0-beta.13 → 3.6.0-beta.14

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

@@ -1,5 +1,5 @@
 /**
-  * vue v3.6.0-beta.13
+  * vue v3.6.0-beta.14
   * (c) 2018-present Yuxi (Evan) You and Vue contributors
   * @license MIT
   **/
@@ -2645,6 +2645,7 @@ function flushJobs(seen) {
 		}
 		flushIndex = 0;
 		jobsLength = 0;
+		jobs.length = 0;
 		flushPostFlushCbs(seen);
 		currentFlushPromise = null;
 		if (jobsLength || postJobs.length) flushJobs(seen);
@@ -2702,6 +2703,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 +2742,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();
@@ -4741,6 +4777,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)) {
@@ -8468,7 +8505,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.14";
 const warn = warn$1;
 /**
 * Runtime error messages. Only exposed in dev or esm builds.
@@ -10580,7 +10617,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 +10685,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 +10700,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;
 			}
 		}
@@ -11334,22 +11377,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 +11476,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 +11518,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 +11539,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 +11571,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 +11582,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 +11591,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 +11624,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 +11652,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;
@@ -11598,7 +11718,7 @@ 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.renderInstance = currentInstance;
@@ -11609,30 +11729,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 +11786,8 @@ 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);
 		if (keyed) this.keyed = true;
 		if (isTransitionEnabled && currentInstance && isVaporTransition(currentInstance.type)) this.inTransition = true;
 		if (isHydrating$1) {
@@ -11677,12 +11799,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 +11826,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 +11843,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 +11858,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 +11866,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 +11882,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 +11899,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 +11939,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 +11953,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 +11961,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 +11995,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 +12039,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 +12056,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 +12249,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 +12285,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 +12333,7 @@ var SlotFragment = class extends DynamicFragment {
 		}
 	}
 	getContent() {
-		return this.nodes;
+		return this.content;
 	}
 	getParentNode() {
 		return this.anchor ? this.anchor.parentNode : null;
@@ -12289,16 +12347,28 @@ 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;
 }
+function isInteropFragment(val) {
+	return val instanceof VaporFragment && val.vnode !== void 0;
+}
 function isDynamicFragment(val) {
 	return val instanceof DynamicFragment;
 }
+function isSlotFragment(val) {
+	return val instanceof DynamicFragment && !!val.isSlot;
+}
 //#endregion
 //#region packages/runtime-vapor/src/teleport.ts
 let isTeleportEnabled = false;
@@ -12323,11 +12393,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 +12481,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 +12508,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 +12561,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 +12619,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 +12657,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 +12739,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 +12785,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 +12921,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;
@@ -12953,27 +12987,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 (block instanceof DynamicFragment) {
+		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,17 +13154,20 @@ 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);
@@ -13106,8 +13181,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 +13193,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 {
@@ -13336,7 +13417,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 };
 	}
@@ -13546,7 +13627,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 +13719,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 +13851,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 +13876,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 +13885,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 +13959,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 +14111,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 +14221,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) {
+function appendVnodeHook(vnode, key, hook) {
 	const props = vnode.props || (vnode.props = {});
-	const existing = props.onVnodeUpdated;
-	props.onVnodeUpdated = existing ? isArray(existing) ? [...existing, hook] : [existing, hook] : hook;
+	const existing = props[key];
+	props[key] = existing ? isArray(existing) ? [...existing, hook] : [existing, hook] : hook;
 }
-function appendVnodeBeforeUpdateHook(vnode, hook) {
-	const props = vnode.props || (vnode.props = {});
-	const existing = props.onVnodeBeforeUpdate;
-	props.onVnodeBeforeUpdate = 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 +14270,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 +14289,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 +14302,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 +14317,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 +14340,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 +14371,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 +14389,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 +14429,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 +14436,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 +14465,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 +14479,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 +14564,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 +14572,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 +14608,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 +14633,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 +14657,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 +14677,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 +14718,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 +14776,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 +14791,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 +14805,6 @@ function renderVaporSlot(vnode, parentComponent, parentSuspense) {
 			queuePostFlushCb(() => {
 				ownedSlotFragmentDirtyQueued = false;
 				markSlotFallbackDirty(target);
-				syncActiveSlotFallback(target);
 			});
 		};
 		const outletFallbackBoundary = {
@@ -14723,7 +14812,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 +14820,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 +14859,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 +14886,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 +14985,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 +15014,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 +15026,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 +15114,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 +15144,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 +15156,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 +15196,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
@@ -15211,8 +15335,6 @@ var TeleportFragment = class extends VaporFragment {
 	}
 	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));
 	}
 	handleChildrenUpdate(children) {
 		if (isHydrating$1 || !this.parent || !this.mountContainer) {
@@ -15220,7 +15342,10 @@ var TeleportFragment = class extends VaporFragment {
 			return;
 		}
 		remove(this.nodes, this.mountContainer);
-		insert(this.nodes = children, this.mountContainer, this.mountAnchor);
+		this.nodes = children;
+		const onBeforeInsert = this.onBeforeInsert;
+		if (onBeforeInsert) onBeforeInsert.forEach((fn) => fn(this.nodes));
+		insert(children, this.mountContainer, this.mountAnchor);
 		this.bindChildren(this.nodes);
 		updateCssVars(this);
 	}
@@ -15228,6 +15353,8 @@ var TeleportFragment = class extends VaporFragment {
 		if (isTransitionEnabled && this.$transition && !this.isMounted) applyTransitionHooks(this.nodes, this.$transition);
 		if (this.isMounted) move(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor, 2);
 		else {
+			const onBeforeInsert = this.onBeforeInsert;
+			if (onBeforeInsert) onBeforeInsert.forEach((fn) => fn(this.nodes));
 			insert(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor);
 			this.isMounted = true;
 		}
@@ -15368,7 +15495,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 +15514,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 +15548,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 +15613,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 +15688,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 +15713,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 +15732,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 +15773,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 +15874,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 +15902,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 +16088,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 +16132,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,8 +16141,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 getDefaultValue(val, getDefaultVal) {
+	return val === void 0 ? getDefaultVal() : val;
 }
 function isForBlock(block) {
 	return block instanceof ForBlock;
@@ -16200,12 +16333,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 = () => {
@@ -16374,7 +16510,7 @@ const VaporTransitionGroup = /* @__PURE__ */ decorate(/* @__PURE__ */ defineVapo
 			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());
@@ -16517,7 +16653,7 @@ function getTransitionBlocks(block, onFragment, onUpdateOwner) {
 	let children = [];
 	if (block instanceof Element) children.push(block);
 	else if (isVaporComponent(block)) {
-		const isRootSlot = block.block instanceof SlotFragment;
+		const isRootSlot = block.block && isSlotFragment(block.block);
 		if (onUpdateOwner && !isRootSlot) onUpdateOwner(block);
 		const blocks = getTransitionBlocks(block.block, onFragment, isRootSlot ? onUpdateOwner : void 0);
 		inheritKey(blocks, block.$key);
@@ -16563,4 +16699,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 };