@vue/runtime-vapor 3.6.0-beta.5 → 3.6.0-beta.6

package/dist/runtime-vapor.d.ts

@@ -1,4 +1,4 @@
-import { AllowedComponentProps, AsyncComponentInternalOptions, AsyncComponentLoader, AsyncComponentOptions, ComponentCustomProps, ComponentInternalOptions, ComponentObjectPropsOptions, ComponentPropsOptions, ComponentTypeEmits, CreateAppFunction, CustomElementOptions, DirectiveModifiers, EffectScope, EmitFn, EmitsOptions, EmitsToProps, ExtractDefaultPropTypes, ExtractPropTypes, GenericAppContext, GenericComponentInstance, LifecycleHook, NULL_DYNAMIC_COMPONENT, NormalizedPropsOptions, ObjectEmitsOptions, Plugin, ReservedProps, SchedulerJob, ShallowUnwrapRef, SuspenseBoundary, TransitionHooks, TransitionProps, TransitionState, TypeEmitsToOptions, VNode, VueElementBase } from "@vue/runtime-dom";
+import { AllowedComponentProps, AsyncComponentInternalOptions, AsyncComponentLoader, AsyncComponentOptions, ComponentCustomProps, ComponentInternalOptions, ComponentObjectPropsOptions, ComponentPropsOptions, ComponentTypeEmits, CreateAppFunction, CustomElementOptions, DirectiveModifiers, EffectScope, EmitFn, EmitsOptions, EmitsToProps, ExtractDefaultPropTypes, ExtractPropTypes, GenericAppContext, GenericComponentInstance, KeepAliveProps, LifecycleHook, NULL_DYNAMIC_COMPONENT, NormalizedPropsOptions, ObjectEmitsOptions, Plugin, ReservedProps, SchedulerJob, ShallowUnwrapRef, SuspenseBoundary, TeleportProps, TransitionGroupProps, TransitionHooks, TransitionProps, TransitionState, TypeEmitsToOptions, VNode, VueElementBase } from "@vue/runtime-dom";
 import { EffectScope as EffectScope$1, ReactiveEffect, Ref, ShallowRef } from "@vue/reactivity";
 import { IsKeyValues, Namespace, NormalizedStyle, Prettify } from "@vue/shared";
 
@@ -8,14 +8,80 @@ type RefEl = Element | VaporComponentInstance;
 type setRefFn = (el: RefEl, ref: NodeRef, refFor?: boolean, refKey?: string) => NodeRef | undefined;
 export declare function createTemplateRefSetter(): setRefFn;
 //#endregion
+//#region temp/packages/runtime-vapor/src/componentSlots.d.ts
+type RawSlots = Record<string, VaporSlot> & {
+  $?: DynamicSlotSource[];
+};
+type StaticSlots = Record<string, VaporSlot>;
+export type VaporSlot = BlockFn;
+type DynamicSlot = {
+  name: string;
+  fn: VaporSlot;
+};
+type DynamicSlotFn = () => DynamicSlot | DynamicSlot[];
+type DynamicSlotSource = StaticSlots | DynamicSlotFn;
+/**
+* Wrap a slot function to track the slot owner.
+*
+* This ensures:
+* 1. createSlot gets rawSlots from the correct component (slot owner)
+* 2. Elements inherit the slot owner's scopeId
+*/
+export declare function withVaporCtx(fn: Function): BlockFn;
+export declare function createSlot(name: string | (() => string), rawProps?: LooseRawProps | null, fallback?: VaporSlot, noSlotted?: boolean, once?: boolean): Block;
+//#endregion
+//#region temp/packages/runtime-vapor/src/apiDefineComponent.d.ts
+export type VaporPublicProps = ReservedProps & AllowedComponentProps & ComponentCustomProps;
+export type VaporRenderResult<T = Block> = VNode | T | VaporRenderResult<T>[];
+type VaporComponentInstanceConstructor<T extends VaporComponentInstance> = {
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  new (...args: any[]): T;
+};
+export type DefineVaporComponent<RuntimePropsOptions = {}, RuntimePropsKeys extends string = string, InferredProps = (string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : { [key in RuntimePropsKeys]?: any }), Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, TypeRefs extends Record<string, unknown> = {}, MakeDefaultsOptional extends boolean = true, PublicProps = VaporPublicProps, ResolvedProps = InferredProps & EmitsToProps<Emits>, Defaults = ExtractDefaultPropTypes<RuntimePropsOptions>> = VaporComponentInstanceConstructor<VaporComponentInstance<MakeDefaultsOptional extends true ? keyof Defaults extends never ? Prettify<ResolvedProps> & PublicProps : Partial<Defaults> & Omit<Prettify<ResolvedProps> & PublicProps, keyof Defaults> : Prettify<ResolvedProps> & PublicProps, Emits, Slots, Exposed, TypeBlock, TypeRefs>> & VaporComponentOptions<RuntimePropsOptions | RuntimePropsKeys[], Emits, RuntimeEmitsKeys, Slots, Exposed>;
+type DefineVaporSetupFnComponent<Props extends Record<string, any> = {}, Emits extends EmitsOptions = {}, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, ResolvedProps extends Record<string, any> = Props & EmitsToProps<Emits> & VaporPublicProps> = new () => VaporComponentInstance<ResolvedProps, Emits, Slots, Exposed, TypeBlock>;
+export declare function defineVaporComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block>(setup: (props: Props, ctx: {
+  emit: EmitFn<Emits>;
+  slots: Slots;
+  attrs: Record<string, any>;
+  expose: (exposed: Exposed) => void;
+}) => VaporRenderResult<TypeBlock> | void, extraOptions?: VaporComponentOptions<(keyof Props)[], Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props, Emits, Slots, Exposed, TypeBlock>;
+export declare function defineVaporComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block>(setup: (props: Props, ctx: {
+  emit: EmitFn<Emits>;
+  slots: Slots;
+  attrs: Record<string, any>;
+  expose: (exposed: Exposed) => void;
+}) => VaporRenderResult<TypeBlock> | void, extraOptions?: VaporComponentOptions<ComponentObjectPropsOptions<Props>, Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props, Emits, Slots, Exposed, TypeBlock>;
+export declare function defineVaporComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, ResolvedEmits extends EmitsOptions = ({} extends RuntimeEmitsOptions ? TypeEmitsToOptions<TypeEmits> : RuntimeEmitsOptions), InferredProps = (IsKeyValues<TypeProps> extends true ? TypeProps : string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : { [key in RuntimePropsKeys]?: any }), TypeRefs extends Record<string, unknown> = {}, TypeBlock extends Block = Block>(options: VaporComponentOptions<RuntimePropsOptions | RuntimePropsKeys[], ResolvedEmits, RuntimeEmitsKeys, Slots, Exposed, TypeBlock, InferredProps> & {
+  [key: string]: any;
+  /**
+  * @private for language-tools use only
+  */
+  __typeProps?: TypeProps;
+  /**
+  * @private for language-tools use only
+  */
+  __typeEmits?: TypeEmits;
+  /**
+  * @private for language-tools use only
+  */
+  __typeRefs?: TypeRefs;
+  /**
+  * @private for language-tools use only
+  */
+  __typeEl?: TypeBlock;
+} & ThisType<void>): DefineVaporComponent<RuntimePropsOptions, RuntimePropsKeys, InferredProps, ResolvedEmits, RuntimeEmitsKeys, Slots, Exposed extends Block ? Record<string, any> : Exposed, TypeBlock, TypeRefs, unknown extends TypeProps ? true : false>;
+//#endregion
 //#region temp/packages/runtime-vapor/src/components/KeepAlive.d.ts
-interface KeepAliveContext {
+export interface VaporKeepAliveContext {
   processShapeFlag(block: Block): boolean;
   cacheBlock(): void;
   cacheScope(key: any, scope: EffectScope$1): void;
   getScope(key: any): EffectScope$1 | undefined;
+  setCurrentBranchKey(key: any): any;
 }
-export declare const VaporKeepAliveImpl: ObjectVaporComponent;
+export declare const VaporKeepAlive: DefineVaporComponent<{}, string, KeepAliveProps>;
 //#endregion
 //#region temp/packages/runtime-vapor/src/fragment.d.ts
 export declare class VaporFragment<T extends Block = Block> implements TransitionOptions {
@@ -36,7 +102,7 @@ export declare class VaporFragment<T extends Block = Block> implements Transitio
 declare class ForFragment extends VaporFragment<Block[]> {
   constructor(nodes: Block[]);
 }
-declare class DynamicFragment extends VaporFragment {
+export declare class DynamicFragment extends VaporFragment {
   anchor: Node;
   scope: EffectScope$1 | undefined;
   current?: BlockFn;
@@ -44,12 +110,11 @@ declare class DynamicFragment extends VaporFragment {
     render?: BlockFn;
     key: any;
   };
-  fallback?: BlockFn;
   anchorLabel?: string;
   keyed?: boolean;
   attrs?: Record<string, any>;
   setAsyncRef?: (instance: VaporComponentInstance) => void;
-  keepAliveCtx: KeepAliveContext | null;
+  keepAliveCtx: VaporKeepAliveContext | null;
   slotOwner: VaporComponentInstance | null;
   constructor(anchorLabel?: string, keyed?: boolean);
   update(render?: BlockFn, key?: any): void;
@@ -101,41 +166,14 @@ declare class RenderEffect extends ReactiveEffect {
 }
 export declare function renderEffect(fn: () => void, noLifecycle?: boolean): void;
 //#endregion
-//#region temp/packages/runtime-vapor/src/componentSlots.d.ts
-type RawSlots = Record<string, VaporSlot> & {
-  $?: DynamicSlotSource[];
-};
-type StaticSlots = Record<string, VaporSlot>;
-export type VaporSlot = BlockFn;
-type DynamicSlot = {
-  name: string;
-  fn: VaporSlot;
-};
-type DynamicSlotFn = () => DynamicSlot | DynamicSlot[];
-type DynamicSlotSource = StaticSlots | DynamicSlotFn;
-/**
-* Wrap a slot function to track the slot owner.
-*
-* This ensures:
-* 1. createSlot gets rawSlots from the correct component (slot owner)
-* 2. Elements inherit the slot owner's scopeId
-*/
-export declare function withVaporCtx(fn: Function): BlockFn;
-export declare function createSlot(name: string | (() => string), rawProps?: LooseRawProps | null, fallback?: VaporSlot, noSlotted?: boolean, once?: boolean): Block;
-//#endregion
 //#region temp/packages/runtime-vapor/src/components/Teleport.d.ts
-export declare const VaporTeleportImpl: {
-  name: string;
-  __isTeleport: boolean;
-  __vapor: boolean;
-  process(props: LooseRawProps, slots: LooseRawSlots): TeleportFragment;
-};
 declare class TeleportFragment extends VaporFragment {
   anchor?: Node;
   private rawProps?;
   private resolvedProps?;
   private rawSlots?;
   isDisabled?: boolean;
+  private isMounted;
   target?: ParentNode | null;
   targetAnchor?: Node | null;
   targetStart?: Node | null;
@@ -156,60 +194,19 @@ declare class TeleportFragment extends VaporFragment {
   private mountChildren;
   hydrate: () => void;
 }
-//#endregion
-//#region temp/packages/runtime-vapor/src/apiDefineComponent.d.ts
-export type VaporPublicProps = ReservedProps & AllowedComponentProps & ComponentCustomProps;
-export type VaporRenderResult<T = Block> = VNode | T | VaporRenderResult<T>[];
-type VaporComponentInstanceConstructor<T extends VaporComponentInstance> = {
-  __isFragment?: never;
-  __isTeleport?: never;
-  __isSuspense?: never;
-  new (...args: any[]): T;
-};
-export type DefineVaporComponent<RuntimePropsOptions = {}, RuntimePropsKeys extends string = string, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, TypeRefs extends Record<string, unknown> = {}, MakeDefaultsOptional extends boolean = true, InferredProps = (string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : { [key in RuntimePropsKeys]?: any }), PublicProps = VaporPublicProps, ResolvedProps = InferredProps & EmitsToProps<Emits>, Defaults = ExtractDefaultPropTypes<RuntimePropsOptions>> = VaporComponentInstanceConstructor<VaporComponentInstance<MakeDefaultsOptional extends true ? keyof Defaults extends never ? Prettify<ResolvedProps> & PublicProps : Partial<Defaults> & Omit<Prettify<ResolvedProps> & PublicProps, keyof Defaults> : Prettify<ResolvedProps> & PublicProps, Emits, Slots, Exposed, TypeBlock, TypeRefs>> & ObjectVaporComponent<RuntimePropsOptions | RuntimePropsKeys[], Emits, RuntimeEmitsKeys, Slots, Exposed>;
-type DefineVaporSetupFnComponent<Props extends Record<string, any> = {}, Emits extends EmitsOptions = {}, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, ResolvedProps extends Record<string, any> = Props & EmitsToProps<Emits> & VaporPublicProps> = new (props?: ResolvedProps) => VaporComponentInstance<ResolvedProps, Emits, Slots, Exposed, TypeBlock>;
-export declare function defineVaporComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block>(setup: (props: Props, ctx: {
-  emit: EmitFn<Emits>;
-  slots: Slots;
-  attrs: Record<string, any>;
-  expose: (exposed: Exposed) => void;
-}) => VaporRenderResult<TypeBlock> | void, extraOptions?: ObjectVaporComponent<(keyof Props)[], Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props, Emits, Slots, Exposed, TypeBlock>;
-export declare function defineVaporComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block>(setup: (props: Props, ctx: {
-  emit: EmitFn<Emits>;
-  slots: Slots;
-  attrs: Record<string, any>;
-  expose: (exposed: Exposed) => void;
-}) => VaporRenderResult<TypeBlock> | void, extraOptions?: ObjectVaporComponent<ComponentObjectPropsOptions<Props>, Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props, Emits, Slots, Exposed, TypeBlock>;
-export declare function defineVaporComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, ResolvedEmits extends EmitsOptions = ({} extends RuntimeEmitsOptions ? TypeEmitsToOptions<TypeEmits> : RuntimeEmitsOptions), InferredProps = (IsKeyValues<TypeProps> extends true ? TypeProps : string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : { [key in RuntimePropsKeys]?: any }), TypeRefs extends Record<string, unknown> = {}, TypeBlock extends Block = Block>(options: ObjectVaporComponent<RuntimePropsOptions | RuntimePropsKeys[], ResolvedEmits, RuntimeEmitsKeys, Slots, Exposed, TypeBlock, InferredProps> & {
-  /**
-  * @private for language-tools use only
-  */
-  __typeProps?: TypeProps;
-  /**
-  * @private for language-tools use only
-  */
-  __typeEmits?: TypeEmits;
-  /**
-  * @private for language-tools use only
-  */
-  __typeRefs?: TypeRefs;
-  /**
-  * @private for language-tools use only
-  */
-  __typeEl?: TypeBlock;
-} & ThisType<void>): DefineVaporComponent<RuntimePropsOptions, RuntimePropsKeys, ResolvedEmits, RuntimeEmitsKeys, Slots, Exposed extends Block ? Record<string, any> : Exposed, TypeBlock, TypeRefs, unknown extends TypeProps ? true : false, InferredProps>;
+export declare const VaporTeleport: DefineVaporSetupFnComponent<TeleportProps>;
 //#endregion
 //#region temp/packages/runtime-vapor/src/component.d.ts
-export type VaporComponent = FunctionalVaporComponent | ObjectVaporComponent | DefineVaporComponent;
+export type VaporComponent = FunctionalVaporComponent | VaporComponentOptions | DefineVaporComponent;
 export type FunctionalVaporComponent<Props = {}, Emits extends EmitsOptions = {}, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>> = ((props: Readonly<Props & EmitsToProps<Emits>>, ctx: {
   emit: EmitFn<Emits>;
   slots: Slots;
   attrs: Record<string, any>;
   expose: <T extends Record<string, any> = Exposed>(exposed: T) => void;
-}) => VaporRenderResult) & Omit<ObjectVaporComponent<ComponentPropsOptions<Props>, Emits, string, Slots>, "setup"> & {
+}) => VaporRenderResult) & Omit<VaporComponentOptions<ComponentPropsOptions<Props>, Emits, string, Slots>, "setup"> & {
   displayName?: string;
 } & SharedInternalOptions;
-interface ObjectVaporComponent<Props = {}, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, InferredProps = (ComponentObjectPropsOptions extends Props ? {} : ExtractPropTypes<Props>)> extends ComponentInternalOptions, AsyncComponentInternalOptions<ObjectVaporComponent, VaporComponentInstance>, SharedInternalOptions {
+export interface VaporComponentOptions<Props = {}, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, InferredProps = (ComponentObjectPropsOptions extends Props ? {} : ExtractPropTypes<Props>)> extends ComponentInternalOptions, AsyncComponentInternalOptions<VaporComponentOptions, VaporComponentInstance>, SharedInternalOptions {
   inheritAttrs?: boolean;
   props?: Props;
   emits?: Emits | RuntimeEmitsKeys[];
@@ -281,6 +278,7 @@ export declare class VaporComponentInstance<Props extends Record<string, any> =
   renderEffects?: RenderEffect[];
   hasFallthrough: boolean;
   shapeFlag?: number;
+  key?: any;
   oncePropsCache?: Record<string | symbol, any>;
   isMounted: boolean;
   isUnmounted: boolean;
@@ -314,6 +312,10 @@ export declare class VaporComponentInstance<Props extends Record<string, any> =
   * fallthrough can be suppressed.
   */
   accessedAttrs: boolean;
+  /**
+  * @deprecated only used for JSX to detect props types.
+  */
+  $props: Props;
   constructor(comp: VaporComponent, rawProps?: RawProps | null, rawSlots?: RawSlots | null, appContext?: GenericAppContext, once?: boolean);
   /**
   * Expose `getKeysFromRawProps` on the instance so it can be used in code
@@ -351,7 +353,7 @@ export declare function defineVaporCustomElement<Props, RawBindings = object>(se
   slots: StaticSlots;
   emit: EmitFn;
   expose: (exposed: Record<string, any>) => void;
-}) => RawBindings | VaporRenderResult, options?: Pick<ObjectVaporComponent, "name" | "inheritAttrs" | "emits"> & CustomElementOptions & {
+}) => RawBindings | VaporRenderResult, options?: Pick<VaporComponentOptions, "name" | "inheritAttrs" | "emits"> & CustomElementOptions & {
   props?: (keyof Props)[];
 }): VaporElementConstructor<Props>;
 export declare function defineVaporCustomElement<Props, RawBindings = object>(setup: (props: Props, ctx: {
@@ -359,7 +361,7 @@ export declare function defineVaporCustomElement<Props, RawBindings = object>(se
   slots: StaticSlots;
   emit: EmitFn;
   expose: (exposed: Record<string, any>) => void;
-}) => RawBindings | VaporRenderResult, options?: Pick<ObjectVaporComponent, "name" | "inheritAttrs" | "emits"> & CustomElementOptions & {
+}) => RawBindings | VaporRenderResult, options?: Pick<VaporComponentOptions, "name" | "inheritAttrs" | "emits"> & CustomElementOptions & {
   props?: ComponentObjectPropsOptions<Props>;
 }): VaporElementConstructor<Props>;
 export declare function defineVaporCustomElement<RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, InferredProps = (string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : { [key in RuntimePropsKeys]?: any }), ResolvedProps = InferredProps & EmitsToProps<RuntimeEmitsOptions>>(options: CustomElementOptions & {
@@ -515,6 +517,5 @@ export declare const applyDynamicModel: VaporModelDirective;
 export declare const VaporTransition: FunctionalVaporComponent<TransitionProps>;
 //#endregion
 //#region temp/packages/runtime-vapor/src/components/TransitionGroup.d.ts
-export declare const VaporTransitionGroup: ObjectVaporComponent;
+export declare const VaporTransitionGroup: DefineVaporComponent<{}, string, TransitionGroupProps>;
 //#endregion
-export { VaporKeepAliveImpl as VaporKeepAlive, VaporTeleportImpl as VaporTeleport,  };

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

@@ -1,10 +1,10 @@
 /**
-  * @vue/runtime-vapor v3.6.0-beta.5
+  * @vue/runtime-vapor v3.6.0-beta.6
   * (c) 2018-present Yuxi (Evan) You and Vue contributors
   * @license MIT
   **/
-import { EffectScope, NULL_DYNAMIC_COMPONENT, TransitionPropsValidators, VueElementBase, activate, baseApplyTranslation, baseEmit, baseNormalizePropsOptions, baseResolveTransitionHooks, baseUseCssVars, callPendingCbs, callWithAsyncErrorHandling, callWithErrorHandling, checkTransitionMode, createAppAPI, createAsyncComponentContext, createCanSetSetupRefChecker, createInternalObject, createVNode, currentInstance, currentInstance as currentInstance$1, deactivate, devtoolsComponentAdded, endMeasure, ensureHydrationRenderer, ensureRenderer, ensureVaporSlotFallback, expose, flushOnAppMount, forceReflow, getAttributeMismatch, getComponentName, getFunctionalFallthrough, getInheritedScopeIds, handleError, handleMovedChildren, hasCSSTransform, initFeatureFlags, isAsyncWrapper, isEmitListener, isHydrating, isKeepAlive, isMapEqual, isMismatchAllowed, isRef, isSetEqual, isTeleportDeferred, isTeleportDisabled, isTemplateNode, isVNode, isValidHtmlOrSvgAttribute, leaveCbKey, markAsyncBoundary, matches, mergeProps, nextUid, normalizeContainer, normalizeRef, onBeforeUnmount, onBeforeUpdate, onMounted, onScopeDispose, onUpdated, patchStyle, performAsyncHydrate, performTransitionEnter, performTransitionLeave, popWarningContext, pushWarningContext, queueJob, queuePostFlushCb, registerHMR, renderSlot, resetShapeFlag, resolveDynamicComponent, resolvePropValue, resolveTeleportTarget, resolveTransitionProps, setCurrentInstance, setDevtoolsHook, setRef, setTransitionHooks, setVarsOnNode, shallowReactive, shallowRef, shouldSetAsProp, simpleSetCurrentInstance, startMeasure, toClassSet, toStyleMap, unregisterHMR, unsafeToTrustedHTML, useAsyncComponentState, useTransitionState, vModelCheckboxInit, vModelCheckboxUpdate, vModelGetValue, vModelSelectInit, vModelSetSelected, vModelTextInit, vModelTextUpdate, vShowHidden, vShowOriginalDisplay, validateProps, warn, warnExtraneousAttributes, warnPropMismatch, watch, xlinkNS } from "@vue/runtime-dom";
-import { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, YES, camelize, canSetValueDirectly, extend, getEscapedCssVarName, getGlobalThis, hasOwn, includeBooleanAttr, invokeArrayFns, isArray, isFunction, isObject, isOn, isPlainObject, isPromise, isReservedProp, isString, looseEqual, normalizeClass, normalizeCssVarValue, normalizeStyle, parseStringStyle, remove as remove$1, stringifyStyle, toDisplayString } from "@vue/shared";
+import { EffectScope, NULL_DYNAMIC_COMPONENT, TransitionPropsValidators, VueElementBase, activate, baseApplyTranslation, baseEmit, baseNormalizePropsOptions, baseResolveTransitionHooks, baseUseCssVars, callPendingCbs, callWithAsyncErrorHandling, callWithErrorHandling, checkTransitionMode, createAppAPI, createAsyncComponentContext, createCanSetSetupRefChecker, createInternalObject, createVNode, currentInstance, currentInstance as currentInstance$1, deactivate, devtoolsComponentAdded, endMeasure, ensureHydrationRenderer, ensureRenderer, ensureVaporSlotFallback, expose, flushOnAppMount, forceReflow, getAttributeMismatch, getComponentName, getFunctionalFallthrough, getInheritedScopeIds, handleError, handleMovedChildren, hasCSSTransform, initFeatureFlags, isAsyncWrapper, isEmitListener, isHydrating, isKeepAlive, isMapEqual, isMismatchAllowed, isRef, isSetEqual, isTeleportDeferred, isTeleportDisabled, isTemplateNode, isTemplateRefKey, isVNode, isValidHtmlOrSvgAttribute, knownTemplateRefs, leaveCbKey, markAsyncBoundary, matches, mergeProps, nextUid, normalizeContainer, normalizeRef, onBeforeUnmount, onBeforeUpdate, onMounted, onScopeDispose, onUpdated, patchStyle, performAsyncHydrate, performTransitionEnter, performTransitionLeave, popWarningContext, pushWarningContext, queueJob, queuePostFlushCb, registerHMR, renderSlot, resetShapeFlag, resolveDynamicComponent, resolvePropValue, resolveTeleportTarget, resolveTransitionProps, setCurrentInstance, setDevtoolsHook, setRef, setTransitionHooks, setVarsOnNode, shallowReactive, shallowRef, shouldSetAsProp, simpleSetCurrentInstance, startMeasure, toClassSet, toStyleMap, unregisterHMR, unsafeToTrustedHTML, useAsyncComponentState, useTransitionState, vModelCheckboxInit, vModelCheckboxUpdate, vModelGetValue, vModelSelectInit, vModelSetSelected, vModelTextInit, vModelTextUpdate, vShowHidden, vShowOriginalDisplay, validateProps, warn, warnExtraneousAttributes, warnPropMismatch, watch, xlinkNS } from "@vue/runtime-dom";
+import { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, camelize, canSetValueDirectly, extend, getEscapedCssVarName, getGlobalThis, hasOwn, includeBooleanAttr, invokeArrayFns, isArray, isFunction, isObject, isOn, isPlainObject, isPromise, isReservedProp, isString, looseEqual, normalizeClass, normalizeCssVarValue, normalizeStyle, parseStringStyle, remove as remove$1, stringifyStyle, toDisplayString } from "@vue/shared";
 import { EffectScope as EffectScope$1, ReactiveEffect, computed, isReactive, isReadonly, isRef as isRef$1, isShallow, markRaw, onEffectCleanup, onScopeDispose as onScopeDispose$1, pauseTracking, proxyRefs, resetTracking, setActiveSub, shallowReadArray, shallowRef as shallowRef$1, toRaw, toReactive, toReadonly, traverse, unref, watch as watch$1 } from "@vue/reactivity";
 
 //#region packages/runtime-vapor/src/insertionState.ts
@@ -62,7 +62,6 @@ function performHydration(fn, setup, cleanup) {
 		adoptTemplate = adoptTemplateImpl;
 		locateHydrationNode = locateHydrationNodeImpl;
 		Comment.prototype.$fe = void 0;
-		Node.prototype.$pns = void 0;
 		Node.prototype.$idx = void 0;
 		Node.prototype.$llc = void 0;
 		isOptimized$1 = true;
@@ -99,7 +98,7 @@ function locateNextSiblingOfParent(n) {
 	return n.parentNode.nextSibling || /* @__PURE__ */ locateNextSiblingOfParent(n.parentNode);
 }
 function advanceHydrationNode(node) {
-	const ret = node.nextSibling || node.$pns || (node.$pns = /* @__PURE__ */ locateNextSiblingOfParent(node));
+	const ret = node.nextSibling || /* @__PURE__ */ locateNextSiblingOfParent(node);
 	if (ret) setCurrentHydrationNode(ret);
 }
 /**
@@ -863,6 +862,13 @@ function setTransitionHooks$1(block, hooks) {
 	block.$transition = hooks;
 }
 
+//#endregion
+//#region packages/runtime-vapor/src/vdominteropState.ts
+let isInteropEnabled = false;
+function setInteropEnabled() {
+	isInteropEnabled = true;
+}
+
 //#endregion
 //#region packages/runtime-vapor/src/apiDefineComponent.ts
 /* @__NO_SIDE_EFFECTS__ */
@@ -885,7 +891,25 @@ function setCurrentKeepAliveCtx(ctx) {
 		currentKeepAliveCtx = ctx;
 	}
 }
-const KeepAliveImpl = /* @__PURE__ */ defineVaporComponent({
+const compositeKeyCache = /* @__PURE__ */ new WeakMap();
+const compositeKeyCachePrimitive = /* @__PURE__ */ new Map();
+function getCompositeKey(type, branchKey) {
+	const isObjectType = isObject(type) || isFunction(type);
+	const perType = isObjectType ? compositeKeyCache.get(type) || /* @__PURE__ */ new Map() : compositeKeyCachePrimitive.get(type) || /* @__PURE__ */ new Map();
+	if (isObjectType) {
+		if (!compositeKeyCache.has(type)) compositeKeyCache.set(type, perType);
+	} else if (!compositeKeyCachePrimitive.has(type)) compositeKeyCachePrimitive.set(type, perType);
+	let composite = perType.get(branchKey);
+	if (!composite) {
+		composite = {
+			type,
+			branchKey
+		};
+		perType.set(branchKey, composite);
+	}
+	return composite;
+}
+const VaporKeepAliveImpl = /* @__PURE__ */ defineVaporComponent({
 	name: "VaporKeepAlive",
 	__isKeepAlive: true,
 	props: {
@@ -908,6 +932,7 @@ const KeepAliveImpl = /* @__PURE__ */ defineVaporComponent({
 		const keys = /* @__PURE__ */ new Set();
 		const storageContainer = /* @__PURE__ */ createElement("div");
 		const keptAliveScopes = /* @__PURE__ */ new Map();
+		let currentBranchKey;
 		let current;
 		if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) keepAliveInstance.__v_cache = cache;
 		if (!!(process.env.NODE_ENV !== "production")) {
@@ -925,7 +950,10 @@ const KeepAliveImpl = /* @__PURE__ */ defineVaporComponent({
 		}
 		keepAliveInstance.ctx = {
 			getStorageContainer: () => storageContainer,
-			getCachedComponent: (comp) => cache.get(comp),
+			getCachedComponent: (comp, key) => {
+				if (isInteropEnabled && isVNode(comp)) return cache.get(resolveKey(comp.type, comp.key, currentBranchKey));
+				return cache.get(resolveKey(comp, key, currentBranchKey));
+			},
 			activate: (instance, parentNode, anchor) => {
 				current = instance;
 				activate$1(instance, parentNode, anchor);
@@ -955,16 +983,18 @@ const KeepAliveImpl = /* @__PURE__ */ defineVaporComponent({
 			}
 			const [innerBlock, interop] = getInnerBlock(block);
 			if (!innerBlock || !shouldCache(innerBlock, props, interop)) return;
-			innerCacheBlock(interop ? innerBlock.vnode.type : innerBlock.type, innerBlock);
+			innerCacheBlock(getCacheKey(innerBlock, interop, currentBranchKey), innerBlock);
 		};
 		const processShapeFlag = (block) => {
 			const [innerBlock, interop] = getInnerBlock(block);
 			if (!innerBlock || !shouldCache(innerBlock, props, interop)) return false;
-			if (interop) {
-				if (cache.has(innerBlock.vnode.type)) innerBlock.vnode.shapeFlag |= 512;
+			if (interop && isInteropEnabled) {
+				const cacheKey = getCacheKey(innerBlock, true, currentBranchKey);
+				if (cache.has(cacheKey)) innerBlock.vnode.shapeFlag |= 512;
 				innerBlock.vnode.shapeFlag |= 256;
 			} else {
-				if (cache.has(innerBlock.type)) innerBlock.shapeFlag |= 512;
+				const cacheKey = getCacheKey(innerBlock, false, currentBranchKey);
+				if (cache.has(cacheKey)) innerBlock.shapeFlag |= 512;
 				innerBlock.shapeFlag |= 256;
 			}
 			return true;
@@ -1002,7 +1032,7 @@ const KeepAliveImpl = /* @__PURE__ */ defineVaporComponent({
 				resetCachedShapeFlag(cached);
 				cache.delete(key);
 				if (current) {
-					if ((isVaporComponent(current) ? current.type : current.vnode.type) === key) {
+					if (getCacheKey(current, !isVaporComponent(current), currentBranchKey) === key) {
 						const da = instance.da;
 						da && queuePostFlushCb(da);
 						return;
@@ -1025,6 +1055,13 @@ const KeepAliveImpl = /* @__PURE__ */ defineVaporComponent({
 					keptAliveScopes.delete(key);
 					return scope;
 				}
+			},
+			setCurrentBranchKey(key) {
+				try {
+					return currentBranchKey;
+				} finally {
+					currentBranchKey = key;
+				}
 			}
 		});
 		let children = slots.default();
@@ -1039,10 +1076,10 @@ const KeepAliveImpl = /* @__PURE__ */ defineVaporComponent({
 		return children;
 	}
 });
-const VaporKeepAliveImpl = KeepAliveImpl;
+const VaporKeepAlive = VaporKeepAliveImpl;
 const shouldCache = (block, props, interop = false) => {
 	const isAsync = !interop && isAsyncWrapper(block);
-	const type = interop ? block.vnode.type : block.type;
+	const type = interop && isInteropEnabled ? block.vnode.type : block.type;
 	if (isAsync && !type.__asyncResolved) return false;
 	const { include, exclude } = props;
 	const name = getComponentName(isAsync ? type.__asyncResolved : type);
@@ -1050,11 +1087,24 @@ const shouldCache = (block, props, interop = false) => {
 };
 const resetCachedShapeFlag = (cached) => {
 	if (isVaporComponent(cached)) resetShapeFlag(cached);
-	else resetShapeFlag(cached.vnode);
+	else if (isInteropEnabled) resetShapeFlag(cached.vnode);
 };
+function resolveKey(type, key, branchKey) {
+	if (key != null) return getCompositeKey(type, key);
+	if (branchKey !== void 0) return getCompositeKey(type, branchKey);
+	return type;
+}
+function getCacheKey(block, interop, branchKey) {
+	if (interop && isInteropEnabled) {
+		const frag = block;
+		return resolveKey(frag.vnode.type, frag.$key !== void 0 ? frag.$key : frag.vnode.key, branchKey);
+	}
+	const instance = block;
+	return resolveKey(instance.type, instance.key, branchKey);
+}
 function getInnerBlock(block) {
 	if (isVaporComponent(block)) return [block, false];
-	else if (isInteropFragment(block)) return [block, true];
+	else if (isInteropEnabled && isInteropFragment(block)) return [block, true];
 	else if (isFragment(block)) return getInnerBlock(block.nodes);
 	return [void 0, false];
 }
@@ -1063,7 +1113,7 @@ function isInteropFragment(block) {
 }
 function getInstanceFromCache(cached) {
 	if (isVaporComponent(cached)) return cached;
-	return cached.vnode.component;
+	if (isInteropEnabled) return cached.vnode.component;
 }
 function activate$1(instance, parentNode, anchor) {
 	move(instance.block, parentNode, anchor, 0, instance);
@@ -1159,11 +1209,13 @@ const vaporInteropImpl = {
 			let selfAnchor;
 			const { slot, fallback } = n2.vs;
 			const propsRef = n2.vs.ref = shallowRef(n2.props);
-			const slotBlock = slot(new Proxy(propsRef, vaporSlotPropsProxyHandler));
-			if (fallback && isFragment(slotBlock)) {
-				setFragmentFallback(slotBlock, createFallback(fallback));
-				selfAnchor = slotBlock.anchor;
+			let slotBlock = slot(new Proxy(propsRef, vaporSlotPropsProxyHandler));
+			if (fallback) {
+				const vaporFallback = createVaporFallback(fallback, parentComponent);
+				const emptyFrag = attachSlotFallback(slotBlock, vaporFallback);
+				if (!isValidBlock(slotBlock)) slotBlock = renderSlotFallback(slotBlock, vaporFallback, emptyFrag);
 			}
+			if (isFragment(slotBlock)) selfAnchor = slotBlock.anchor;
 			simpleSetCurrentInstance(prev);
 			if (!selfAnchor) selfAnchor = /* @__PURE__ */ createTextNode();
 			insert(n2.el = n2.anchor = selfAnchor, container, anchor);
@@ -1346,64 +1398,91 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
 */
 function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallback) {
 	const frag = new VaporFragment([]);
+	if (fallback && !frag.fallback) frag.fallback = fallback;
 	let isMounted = false;
-	let fallbackNodes;
-	let oldVNode = null;
-	frag.fallback = fallback;
+	let currentBlock = null;
+	let currentVNode = null;
 	frag.insert = (parentNode, anchor) => {
 		if (isHydrating$1) return;
 		if (!isMounted) {
 			render(parentNode, anchor);
 			isMounted = true;
-		} else internals.m(oldVNode, parentNode, anchor, 2, parentComponent);
+		} else if (currentVNode) internals.m(currentVNode, parentNode, anchor, 2, parentComponent);
+		else if (currentBlock) insert(currentBlock, parentNode, anchor);
 		frag.remove = (parentNode) => {
-			if (fallbackNodes) remove(fallbackNodes, parentNode);
-			else if (oldVNode) internals.um(oldVNode, parentComponent, null);
+			if (currentBlock) remove(currentBlock, parentNode);
+			else if (currentVNode) internals.um(currentVNode, parentComponent, null);
 		};
 		if (isMounted && frag.onUpdated) frag.onUpdated.forEach((m) => m());
 	};
 	const render = (parentNode, anchor) => {
 		renderEffect(() => {
-			let vnode;
-			let isValidSlot = false;
+			const effectiveFallback = frag.fallback || fallback;
+			let slotContent;
+			let isEmpty = true;
+			let emptyFrag = null;
 			if (slotsRef.value) {
-				vnode = renderSlot(slotsRef.value, isFunction(name) ? name() : name, props);
-				let children = vnode.children;
-				ensureVaporSlotFallback(children, fallback);
-				isValidSlot = children.length > 0;
+				slotContent = renderSlot(slotsRef.value, isFunction(name) ? name() : name, props);
+				if (isVNode(slotContent)) {
+					const children = slotContent.children;
+					ensureVaporSlotFallback(children, effectiveFallback);
+					isEmpty = children.length === 0;
+				} else {
+					if (effectiveFallback && slotContent) emptyFrag = attachSlotFallback(slotContent, () => effectiveFallback(internals, parentComponent));
+					isEmpty = !isValidBlock(slotContent);
+				}
 			}
-			if (isValidSlot) if (isHydrating$1) {
-				if (isVNode(vnode)) {
-					hydrateVNode(vnode, parentComponent);
-					oldVNode = vnode;
-					frag.nodes = vnode.el;
+			let resolved = slotContent;
+			if (isEmpty && effectiveFallback) if (isVNode(slotContent)) resolved = effectiveFallback(internals, parentComponent);
+			else if (slotContent) resolved = renderSlotFallback(slotContent, () => effectiveFallback(internals, parentComponent), emptyFrag);
+			else resolved = effectiveFallback(internals, parentComponent);
+			if (isHydrating$1) {
+				if (isVNode(resolved)) {
+					hydrateVNode(resolved, parentComponent);
+					currentVNode = resolved;
+					currentBlock = null;
+					frag.nodes = resolved.el;
+				} else if (resolved) {
+					currentBlock = resolved;
+					currentVNode = null;
+					frag.nodes = resolved;
+				} else {
+					currentBlock = null;
+					currentVNode = null;
+					frag.nodes = [];
 				}
-			} else {
-				if (fallbackNodes) {
-					remove(fallbackNodes, parentNode);
-					fallbackNodes = void 0;
+				return;
+			}
+			if (isVNode(resolved)) {
+				if (currentBlock) {
+					remove(currentBlock, parentNode);
+					currentBlock = null;
 				}
-				internals.p(oldVNode, vnode, parentNode, anchor, parentComponent, null, void 0, vnode.slotScopeIds);
-				oldVNode = vnode;
-				frag.nodes = vnode.el;
+				internals.p(currentVNode, resolved, parentNode, anchor, parentComponent, null, void 0, resolved.slotScopeIds);
+				currentVNode = resolved;
+				frag.nodes = resolved.el;
+				return;
 			}
-			else {
-				fallback = frag.fallback;
-				if (fallback && !fallbackNodes) {
-					fallbackNodes = fallback(internals, parentComponent);
-					if (isHydrating$1) {
-						if (isVNode(fallbackNodes)) {
-							hydrateVNode(fallbackNodes, parentComponent);
-							frag.nodes = fallbackNodes.el;
-						}
-					} else {
-						if (oldVNode) internals.um(oldVNode, parentComponent, null, true);
-						insert(fallbackNodes, parentNode, anchor);
-						frag.nodes = fallbackNodes;
-					}
+			if (resolved) {
+				if (currentVNode) {
+					internals.um(currentVNode, parentComponent, null, true);
+					currentVNode = null;
 				}
-				oldVNode = null;
+				if (currentBlock) remove(currentBlock, parentNode);
+				insert(resolved, parentNode, anchor);
+				currentBlock = resolved;
+				frag.nodes = resolved;
+				return;
+			}
+			if (currentBlock) {
+				remove(currentBlock, parentNode);
+				currentBlock = null;
 			}
+			if (currentVNode) {
+				internals.um(currentVNode, parentComponent, null, true);
+				currentVNode = null;
+			}
+			frag.nodes = [];
 		});
 	};
 	frag.hydrate = () => {
@@ -1414,6 +1493,7 @@ function renderVDOMSlot(internals, slotsRef, name, props, parentComponent, fallb
 	return frag;
 }
 const vaporInteropPlugin = (app) => {
+	setInteropEnabled();
 	const internals = ensureRenderer().internals;
 	app._context.vapor = extend(vaporInteropImpl, {
 		vdomMount: createVDOMComponent.bind(null, internals),
@@ -1436,6 +1516,10 @@ function hydrateVNode(vnode, parentComponent, skipFragmentAnchor = false) {
 	if (nextNode) setCurrentHydrationNode(nextNode);
 	else advanceHydrationNode(node);
 }
+function createVaporFallback(fallback, parentComponent) {
+	const internals = ensureRenderer().internals;
+	return () => createFallback(fallback)(internals, parentComponent);
+}
 const createFallback = (fallback) => (internals, parentComponent) => {
 	const fallbackNodes = fallback();
 	if (isArray(fallbackNodes) && fallbackNodes.every(isVNode)) {
@@ -1514,7 +1598,7 @@ function getPropsProxyHandlers(comp, once) {
 	const propsOptions = normalizePropsOptions(comp)[0];
 	const emitsOptions = normalizeEmitsOptions(comp);
 	const isProp = propsOptions ? (key) => isString(key) && hasOwn(propsOptions, camelize(key)) : NO;
-	const isAttr = propsOptions ? (key) => key !== "$" && !isProp(key) && !isEmitListener(emitsOptions, key) : YES;
+	const isAttr = propsOptions ? (key) => isString(key) && key !== "$" && !isProp(key) && !isEmitListener(emitsOptions, key) : (key) => isString(key);
 	const getProp = (instance, key) => {
 		if (key === "__v_isReactive") return true;
 		if (!isProp(key)) return;
@@ -1565,7 +1649,7 @@ function getPropsProxyHandlers(comp, once) {
 		deleteProperty: propsDeleteDevTrap
 	});
 	const getAttr = (target, key) => {
-		if (!isProp(key) && !isEmitListener(emitsOptions, key)) return getAttrFromRawProps(target, key);
+		if (isString(key) && !isProp(key) && !isEmitListener(emitsOptions, key)) return getAttrFromRawProps(target, key);
 	};
 	const hasAttr = (target, key) => {
 		if (isAttr(key)) return hasAttrFromRawProps(target, key);
@@ -1577,7 +1661,7 @@ function getPropsProxyHandlers(comp, once) {
 		has: (target, key) => hasAttr(target.rawProps, key),
 		ownKeys: (target) => getKeysFromRawProps(target.rawProps).filter(isAttr),
 		getOwnPropertyDescriptor(target, key) {
-			if (hasAttr(target.rawProps, key)) return {
+			if (isString(key) && hasAttr(target.rawProps, key)) return {
 				configurable: true,
 				enumerable: true,
 				get: () => once ? getOnceAttr(target, key) : getAttr(target.rawProps, key)
@@ -1828,11 +1912,11 @@ function createSlot(name, rawProps, fallback, noSlotted, once) {
 	const rawSlots = instance.rawSlots;
 	const slotProps = rawProps ? new Proxy(rawProps, rawPropsProxyHandlers) : EMPTY_OBJ;
 	let fragment;
-	if (isRef(rawSlots._)) {
+	if (isRef(rawSlots._) && isInteropEnabled) {
 		if (isHydrating$1) locateHydrationNode();
 		fragment = instance.appContext.vapor.vdomSlot(rawSlots._, name, slotProps, instance, fallback);
 	} else {
-		fragment = isHydrating$1 || !!(process.env.NODE_ENV !== "production") ? new DynamicFragment("slot") : new DynamicFragment();
+		fragment = new SlotFragment();
 		const isDynamicName = isFunction(name);
 		const slotScopeIds = [];
 		if (!noSlotted) {
@@ -1852,19 +1936,24 @@ function createSlot(name, rawProps, fallback, noSlotted, once) {
 			}
 			const slot = getSlot(rawSlots, slotName);
 			if (slot) {
-				fragment.fallback = fallback;
-				fragment.update(slot._bound || (slot._bound = () => {
-					const prevSlotScopeIds = setCurrentSlotScopeIds(slotScopeIds.length > 0 ? slotScopeIds : null);
-					const prev = inOnceSlot;
-					try {
-						if (once) inOnceSlot = true;
-						return slot(slotProps);
-					} finally {
-						inOnceSlot = prev;
-						setCurrentSlotScopeIds(prevSlotScopeIds);
-					}
-				}));
-			} else fragment.update(fallback);
+				const boundMap = slot._boundMap || (slot._boundMap = /* @__PURE__ */ new WeakMap());
+				let bound = boundMap.get(fragment);
+				if (!bound) {
+					bound = () => {
+						const prevSlotScopeIds = setCurrentSlotScopeIds(slotScopeIds.length > 0 ? slotScopeIds : null);
+						const prev = inOnceSlot;
+						try {
+							if (once) inOnceSlot = true;
+							return slot(slotProps);
+						} finally {
+							inOnceSlot = prev;
+							setCurrentSlotScopeIds(prevSlotScopeIds);
+						}
+					};
+					boundMap.set(fragment, bound);
+				}
+				fragment.updateSlot(bound, fallback);
+			} else fragment.updateSlot(void 0, fallback);
 		};
 		if (!once && (isDynamicName || rawSlots.$)) renderEffect(renderSlot);
 		else renderSlot();
@@ -2033,21 +2122,6 @@ var DynamicFragment = class extends VaporFragment {
 			} else parent && remove(this.nodes, parent);
 		}
 		this.renderBranch(render, transition, parent, instance);
-		if (this.fallback) {
-			let invalidFragment = null;
-			if (isFragment(this.nodes)) setFragmentFallback(this.nodes, this.fallback, (frag) => {
-				if (!isValidBlock(frag.nodes)) invalidFragment = frag;
-			});
-			if (!invalidFragment && !isValidBlock(this.nodes)) invalidFragment = this;
-			if (invalidFragment) {
-				parent && remove(this.nodes, parent);
-				(this.scope || (this.scope = new EffectScope$1())).run(() => {
-					if (invalidFragment !== this) renderFragmentFallback(invalidFragment);
-					else this.nodes = this.fallback() || [];
-				});
-				parent && insert(this.nodes, parent, this.anchor);
-			}
-		}
 		setActiveSub(prevSub);
 		if (isHydrating$1) this.hydrate();
 	}
@@ -2059,9 +2133,12 @@ var DynamicFragment = class extends VaporFragment {
 			else this.scope = new EffectScope$1();
 			const prevOwner = setCurrentSlotOwner(this.slotOwner);
 			const prevCtx = setCurrentKeepAliveCtx(keepAliveCtx);
+			let prevBranchKey;
+			if (keepAliveCtx && this.keyed) prevBranchKey = keepAliveCtx.setCurrentBranchKey(this.current);
 			const prev = parent && instance ? setCurrentInstance(instance) : void 0;
 			this.nodes = this.scope.run(render) || [];
 			if (prev !== void 0) setCurrentInstance(...prev);
+			if (keepAliveCtx && this.keyed) keepAliveCtx.setCurrentBranchKey(prevBranchKey);
 			setCurrentKeepAliveCtx(prevCtx);
 			setCurrentSlotOwner(prevOwner);
 			if (this.keyed) setKey(this.nodes, this.current);
@@ -2084,33 +2161,122 @@ var DynamicFragment = class extends VaporFragment {
 		}
 	}
 };
-function setFragmentFallback(fragment, fallback, onFragment) {
-	if (fragment.fallback) {
-		const originalFallback = fragment.fallback;
-		fragment.fallback = () => {
-			const fallbackNodes = originalFallback();
-			if (isValidBlock(fallbackNodes)) return fallbackNodes;
-			return fallback();
+var SlotFragment = class extends DynamicFragment {
+	constructor() {
+		super(isHydrating$1 || !!(process.env.NODE_ENV !== "production") ? "slot" : void 0);
+	}
+	updateSlot(render, fallback, key = render) {
+		if (!render || !fallback) {
+			this.update(render || fallback, key);
+			return;
+		}
+		const wrapped = () => {
+			const block = render();
+			const emptyFrag = attachSlotFallback(block, fallback);
+			if (!isValidBlock(block)) return renderSlotFallback(block, fallback, emptyFrag);
+			return block;
 		};
-	} else fragment.fallback = fallback;
-	if (onFragment) onFragment(fragment);
-	if (isFragment(fragment.nodes)) setFragmentFallback(fragment.nodes, fragment.fallback, onFragment);
-}
-function renderFragmentFallback(fragment) {
-	if (fragment instanceof ForFragment) fragment.nodes[0] = [fragment.fallback() || []];
-	else if (fragment instanceof DynamicFragment) fragment.update(fragment.fallback);
-}
+		this.update(wrapped, key);
+	}
+};
 function isFragment(val) {
 	return val instanceof VaporFragment;
 }
 function isDynamicFragment(val) {
 	return val instanceof DynamicFragment;
 }
+function renderSlotFallback(block, fallback, emptyFragment) {
+	const frag = emptyFragment || findDeepestEmptyFragment(block);
+	if (frag) {
+		if (frag instanceof ForFragment) frag.nodes[0] = [fallback() || []];
+		else if (frag instanceof DynamicFragment) frag.update(fallback);
+		return block;
+	}
+	return fallback();
+}
+function attachSlotFallback(block, fallback) {
+	const state = { emptyFrag: null };
+	traverseForFallback(block, fallback, state);
+	return state.emptyFrag;
+}
+const slotFallbackState = /* @__PURE__ */ new WeakMap();
+function traverseForFallback(block, fallback, state) {
+	if (isVaporComponent(block)) {
+		if (block.block) traverseForFallback(block.block, fallback, state);
+		return;
+	}
+	if (isArray(block)) {
+		for (const item of block) traverseForFallback(item, fallback, state);
+		return;
+	}
+	if (block instanceof ForFragment) {
+		block.fallback = chainFallback(block.fallback, fallback);
+		if (!isValidBlock(block.nodes)) state.emptyFrag = block;
+		traverseForFallback(block.nodes, fallback, state);
+		return;
+	}
+	if (block instanceof VaporFragment && block.insert) {
+		block.fallback = chainFallback(block.fallback, fallback);
+		if (!isValidBlock(block.nodes)) state.emptyFrag = block;
+		traverseForFallback(block.nodes, fallback, state);
+		return;
+	}
+	if (block instanceof DynamicFragment) {
+		let slotState = slotFallbackState.get(block);
+		if (slotState) slotState.fallback = chainFallback(slotState.fallback, fallback);
+		else slotFallbackState.set(block, slotState = {
+			fallback,
+			wrapped: false
+		});
+		if (!slotState.wrapped) {
+			slotState.wrapped = true;
+			const original = block.update.bind(block);
+			block.update = (render, key) => {
+				original(render, key);
+				const emptyFrag = attachSlotFallback(block.nodes, slotState.fallback);
+				if (render !== slotState.fallback && !isValidBlock(block.nodes)) renderSlotFallback(block, slotState.fallback, emptyFrag);
+			};
+		}
+		if (!isValidBlock(block.nodes)) state.emptyFrag = block;
+		traverseForFallback(block.nodes, fallback, state);
+	}
+}
+function findDeepestEmptyFragment(block) {
+	let emptyFrag = null;
+	traverseForEmptyFragment(block, (frag) => emptyFrag = frag);
+	return emptyFrag;
+}
+function traverseForEmptyFragment(block, onFound) {
+	if (isVaporComponent(block)) {
+		if (block.block) traverseForEmptyFragment(block.block, onFound);
+		return;
+	}
+	if (isArray(block)) {
+		for (const item of block) traverseForEmptyFragment(item, onFound);
+		return;
+	}
+	if (isFragment(block)) {
+		if (!isValidBlock(block.nodes)) onFound(block);
+		traverseForEmptyFragment(block.nodes, onFound);
+	}
+}
+function chainFallback(existing, next) {
+	if (!existing) return next;
+	return (...args) => {
+		const res = existing(...args);
+		return !isValidBlock(res) ? next(...args) : res;
+	};
+}
 function setKey(block, key) {
 	if (block instanceof Node) block.$key = key;
-	else if (isVaporComponent(block)) setKey(block.block, key);
-	else if (isArray(block)) for (const b of block) setKey(b, key);
-	else setKey(block.nodes, key);
+	else if (isVaporComponent(block)) {
+		block.key = key;
+		setKey(block.block, key);
+	} else if (isArray(block)) for (const b of block) setKey(b, key);
+	else {
+		block.$key = key;
+		setKey(block.nodes, key);
+	}
 }
 
 //#endregion
@@ -2127,6 +2293,7 @@ var TeleportFragment = class extends VaporFragment {
 	constructor(props, slots) {
 		super([]);
 		this.__isTeleportFragment = true;
+		this.isMounted = false;
 		this.insert = (container, anchor) => {
 			if (isHydrating$1) return;
 			this.placeholder = !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("teleport start") : /* @__PURE__ */ createTextNode();
@@ -2139,6 +2306,7 @@ var TeleportFragment = class extends VaporFragment {
 				remove(this.nodes, this.mountContainer);
 				this.nodes = [];
 			}
+			this.isMounted = false;
 			if (this.targetStart) {
 				remove(this.targetStart, this.target);
 				this.targetStart = void 0;
@@ -2192,9 +2360,11 @@ var TeleportFragment = class extends VaporFragment {
 		this.parentComponent = currentInstance;
 		this.anchor = isHydrating$1 ? void 0 : !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ createComment("teleport end") : /* @__PURE__ */ createTextNode();
 		renderEffect(() => {
+			const prevTo = this.resolvedProps && this.resolvedProps.to;
+			const wasDisabled = this.isDisabled;
 			this.resolvedProps = extend({}, new Proxy(this.rawProps, rawPropsProxyHandlers));
 			this.isDisabled = isTeleportDisabled(this.resolvedProps);
-			this.handlePropsUpdate();
+			if (wasDisabled !== this.isDisabled || !this.isDisabled && prevTo !== this.resolvedProps.to) this.handlePropsUpdate();
 		});
 		if (!isHydrating$1) this.initChildren();
 	}
@@ -2228,8 +2398,12 @@ var TeleportFragment = class extends VaporFragment {
 		insert(this.nodes = children, this.mountContainer, this.mountAnchor);
 	}
 	mount(parent, anchor) {
-		if (this.$transition) applyTransitionHooks(this.nodes, this.$transition);
-		insert(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor);
+		if (this.$transition && !this.isMounted) applyTransitionHooks(this.nodes, this.$transition);
+		if (this.isMounted) move(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor, 2);
+		else {
+			insert(this.nodes, this.mountContainer = parent, this.mountAnchor = anchor);
+			this.isMounted = true;
+		}
 	}
 	mountToTarget() {
 		const target = this.target = resolveTeleportTarget(this.resolvedProps, querySelector);
@@ -2272,6 +2446,7 @@ var TeleportFragment = class extends VaporFragment {
 		runWithoutHydration(this.initChildren.bind(this));
 	}
 };
+const VaporTeleport = VaporTeleportImpl;
 /**
 * Use duck typing to check for VaporTeleport instead of direct reference
 * to VaporTeleportImpl, allowing tree-shaking when Teleport is not used.
@@ -2538,7 +2713,7 @@ function createComponent(component, rawProps, rawSlots, isSingleRoot, once, appC
 		const cached = currentInstance.ctx.getCachedComponent(component);
 		if (cached) return cached;
 	}
-	if (appContext.vapor && !component.__vapor) {
+	if (isInteropEnabled && appContext.vapor && !component.__vapor) {
 		const frag = appContext.vapor.vdomMount(component, currentInstance, rawProps, rawSlots, isSingleRoot);
 		if (!isHydrating$1) {
 			if (_insertionParent) insert(frag, _insertionParent, _insertionAnchor);
@@ -2746,8 +2921,11 @@ function createPlainElement(comp, rawProps, rawSlots, isSingleRoot, once) {
 			renderEffect(() => frag.update(getSlot(rawSlots, "default")));
 			if (!isHydrating$1) insert(frag, el);
 		} else {
-			const block = getSlot(rawSlots, "default")();
-			if (!isHydrating$1) insert(block, el);
+			let slot = getSlot(rawSlots, "default");
+			if (slot) {
+				const block = slot();
+				if (!isHydrating$1) insert(block, el);
+			}
 		}
 		if (isHydrating$1) setCurrentHydrationNode(nextNode);
 	}
@@ -3439,8 +3617,11 @@ const createFor = (src, renderItem, getKey, flags = 0, setup) => {
 		let activeOpers;
 		watch$1(source, (newValue) => {
 			if (activeOpers !== void 0) for (const oper of activeOpers) oper();
-			activeOpers = operMap.get(newValue);
-			if (activeOpers !== void 0) for (const oper of activeOpers) oper();
+			queuePostFlushCb(() => {
+				activeKey = newValue;
+				activeOpers = operMap.get(newValue);
+				if (activeOpers !== void 0) for (const oper of activeOpers) oper();
+			});
 		});
 		selectors.push({
 			deregister,
@@ -3591,12 +3772,19 @@ function setRef$1(instance, el, ref, oldRef, refFor = false, refKey) {
 	const setupState = !!(process.env.NODE_ENV !== "production") ? instance.setupState || {} : null;
 	const refValue = getRefValue(el);
 	const refs = instance.refs === EMPTY_OBJ ? instance.refs = {} : instance.refs;
-	const canSetSetupRef = !!(process.env.NODE_ENV !== "production") ? createCanSetSetupRefChecker(setupState) : NO;
+	const canSetSetupRef = !!(process.env.NODE_ENV !== "production") ? createCanSetSetupRefChecker(setupState, refs) : NO;
+	const canSetRef = (ref, key) => {
+		if (!!(process.env.NODE_ENV !== "production") && knownTemplateRefs.has(ref)) return false;
+		if (key && isTemplateRefKey(refs, key)) return false;
+		return true;
+	};
 	if (oldRef != null && oldRef !== ref) {
 		if (isString(oldRef)) {
 			refs[oldRef] = null;
 			if (!!(process.env.NODE_ENV !== "production") && canSetSetupRef(oldRef)) setupState[oldRef] = null;
-		} else if (isRef$1(oldRef)) oldRef.value = null;
+		} else if (isRef$1(oldRef)) {
+			if (canSetRef(oldRef)) oldRef.value = null;
+		}
 	}
 	if (isFunction(ref)) {
 		const invokeRefSetter = (value) => {
@@ -3611,7 +3799,7 @@ function setRef$1(instance, el, ref, oldRef, refFor = false, refKey) {
 		if (_isString || _isRef) {
 			const doSet = () => {
 				if (refFor) {
-					existing = _isString ? !!(process.env.NODE_ENV !== "production") && canSetSetupRef(ref) ? setupState[ref] : refs[ref] : ref.value;
+					existing = _isString ? !!(process.env.NODE_ENV !== "production") && canSetSetupRef(ref) ? setupState[ref] : refs[ref] : canSetRef(ref) || !refKey ? ref.value : refs[refKey];
 					if (!isArray(existing)) {
 						existing = [refValue];
 						if (_isString) {
@@ -3621,7 +3809,7 @@ function setRef$1(instance, el, ref, oldRef, refFor = false, refKey) {
 								existing = setupState[ref];
 							}
 						} else {
-							ref.value = existing;
+							if (canSetRef(ref, refKey)) ref.value = existing;
 							if (refKey) refs[refKey] = existing;
 						}
 					} else if (!existing.includes(refValue)) existing.push(refValue);
@@ -3629,7 +3817,7 @@ function setRef$1(instance, el, ref, oldRef, refFor = false, refKey) {
 					refs[ref] = refValue;
 					if (!!(process.env.NODE_ENV !== "production") && canSetSetupRef(ref)) setupState[ref] = refValue;
 				} else if (_isRef) {
-					ref.value = refValue;
+					if (canSetRef(ref, refKey)) ref.value = refValue;
 					if (refKey) refs[refKey] = refValue;
 				} else if (!!(process.env.NODE_ENV !== "production")) warn("Invalid template ref type:", ref, `(${typeof ref})`);
 			};
@@ -3641,7 +3829,7 @@ function setRef$1(instance, el, ref, oldRef, refFor = false, refKey) {
 						refs[ref] = null;
 						if (!!(process.env.NODE_ENV !== "production") && canSetSetupRef(ref)) setupState[ref] = null;
 					} else if (_isRef) {
-						ref.value = null;
+						if (canSetRef(ref, refKey)) ref.value = null;
 						if (refKey) refs[refKey] = null;
 					}
 				});
@@ -3692,9 +3880,9 @@ function createDynamicComponent(getter, rawProps, rawSlots, isSingleRoot, once)
 		const appContext = currentInstance && currentInstance.appContext || emptyContext;
 		frag.update(() => {
 			if (isBlock(value)) return value;
-			if (appContext.vapor && isVNode(value)) {
+			if (isInteropEnabled && appContext.vapor && isVNode(value)) {
 				if (isKeepAlive(currentInstance)) {
-					const frag = currentInstance.ctx.getCachedComponent(value.type);
+					const frag = currentInstance.ctx.getCachedComponent(value.type, value.key);
 					if (frag) return frag;
 				}
 				const frag = appContext.vapor.vdomMountVNode(value, currentInstance);
@@ -3834,10 +4022,9 @@ const positionMap = /* @__PURE__ */ new WeakMap();
 const newPositionMap = /* @__PURE__ */ new WeakMap();
 const decorate = (t) => {
 	delete t.props.mode;
-	t.__vapor = true;
 	return t;
 };
-const VaporTransitionGroupImpl = {
+const VaporTransitionGroupImpl = /* @__PURE__ */ defineVaporComponent({
 	name: "VaporTransitionGroup",
 	props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
 		tag: String,
@@ -3907,7 +4094,7 @@ const VaporTransitionGroupImpl = {
 			return container;
 		} else return slottedBlock;
 	}
-};
+});
 const VaporTransitionGroup = /* @__PURE__ */ decorate(VaporTransitionGroupImpl);
 function getTransitionBlocks(block) {
 	let children = [];
@@ -3944,4 +4131,4 @@ function getFirstConnectedChild(children) {
 }
 
 //#endregion
-export { VaporElement, VaporFragment, VaporKeepAliveImpl as VaporKeepAlive, VaporTeleportImpl as VaporTeleport, VaporTransition, VaporTransitionGroup, applyCheckboxModel, applyDynamicModel, applyRadioModel, applySelectModel, applyTextModel, applyVShow, child, createComponent, createComponentWithFallback, createDynamicComponent, createFor, createForSlots, createIf, createInvoker, createKeyedFragment, createPlainElement, createSlot, createTemplateRefSetter, createTextNode, createVaporApp, createVaporSSRApp, defineVaporAsyncComponent, defineVaporComponent, defineVaporCustomElement, defineVaporSSRCustomElement, delegate, delegateEvents, getDefaultValue, getRestElement, insert, isFragment, isVaporComponent, next, nthChild, on, prepend, remove, renderEffect, setAttr, setBlockHtml, setBlockText, setClass, setDOMProp, setDynamicEvents, setDynamicProps, setElementText, setHtml, setInsertionState, setProp, setStyle, setText, setValue, template, txt, useVaporCssVars, vaporInteropPlugin, withVaporCtx, withVaporDirectives };
+export { DynamicFragment, VaporElement, VaporFragment, VaporKeepAlive, VaporTeleport, VaporTransition, VaporTransitionGroup, applyCheckboxModel, applyDynamicModel, applyRadioModel, applySelectModel, applyTextModel, applyVShow, child, createComponent, createComponentWithFallback, createDynamicComponent, createFor, createForSlots, createIf, createInvoker, createKeyedFragment, createPlainElement, createSlot, createTemplateRefSetter, createTextNode, createVaporApp, createVaporSSRApp, defineVaporAsyncComponent, defineVaporComponent, defineVaporCustomElement, defineVaporSSRCustomElement, delegate, delegateEvents, getDefaultValue, getRestElement, insert, isFragment, isVaporComponent, next, nthChild, on, prepend, remove, renderEffect, setAttr, setBlockHtml, setBlockText, setClass, setDOMProp, setDynamicEvents, setDynamicProps, setElementText, setHtml, setInsertionState, setProp, setStyle, setText, setValue, template, txt, useVaporCssVars, vaporInteropPlugin, withVaporCtx, withVaporDirectives };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/runtime-vapor",
-  "version": "3.6.0-beta.5",
+  "version": "3.6.0-beta.6",
   "description": "@vue/runtime-vapor",
   "main": "index.js",
   "module": "dist/runtime-vapor.esm-bundler.js",
@@ -38,10 +38,10 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/dev/packages/runtime-vapor#readme",
   "dependencies": {
-    "@vue/shared": "3.6.0-beta.5",
-    "@vue/reactivity": "3.6.0-beta.5"
+    "@vue/shared": "3.6.0-beta.6",
+    "@vue/reactivity": "3.6.0-beta.6"
   },
   "peerDependencies": {
-    "@vue/runtime-dom": "3.6.0-beta.5"
+    "@vue/runtime-dom": "3.6.0-beta.6"
   }
 }