@vue/compiler-vapor 3.6.0-beta.8 → 3.6.0-rc.1

package/dist/compiler-vapor.d.ts

@@ -1,5 +1,5 @@
 import { AllNode, BaseCodegenResult, CodegenOptions as CodegenOptions$1, CodegenSourceMapGenerator, CommentNode, CompilerCompatOptions, CompilerError, CompilerOptions as CompilerOptions$1, CompoundExpressionNode, DirectiveNode, ElementNode, RootNode, SimpleExpressionNode, SourceLocation, TemplateChildNode, TemplateNode, TransformOptions, parse } from "@vue/compiler-dom";
-import { IfAny, IsKeyValues, LooseRequired, Namespace, NormalizedStyle, OverloadParameters, PatchFlags, Prettify, SlotFlags, UnionToIntersection, camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from "@vue/shared";
+import { IfAny, IsKeyValues, LooseRequired, Namespace, NormalizedStyle, OverloadParameters, PatchFlags, Prettify, SlotFlags, UnionToIntersection, VaporSlotFlags, camelize, capitalize, extend, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from "@vue/shared";
 //#endregion
 //#region packages/reactivity/src/constants.d.ts
 declare enum TrackOpTypes {
@@ -286,10 +286,11 @@ type Reactive<T> = UnwrapNestedRefs<T> & (T extends readonly any[] ? ReactiveMar
 * @see {@link https://vuejs.org/api/reactivity-core.html#reactive}
 */
 declare function reactive<T extends object>(target: T): Reactive<T>;
-declare const ShallowReactiveMarker: unique symbol;
-type ShallowReactive<T> = T & {
-  [ShallowReactiveMarker]?: true;
-};
+declare class ShallowReactiveBrandClass {
+  private __shallowReactiveBrand?;
+}
+type ShallowReactiveBrand = ShallowReactiveBrandClass;
+type ShallowReactive<T> = T & ShallowReactiveBrand;
 /**
 * Shallow version of {@link reactive}.
 *
@@ -599,9 +600,9 @@ declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
 * that contains refs.
 */
 declare function proxyRefs<T extends object>(objectWithRefs: T): ShallowUnwrapRef<T>;
-type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
+type CustomRefFactory<T, S = T> = (track: () => void, trigger: () => void) => {
   get: () => T;
-  set: (value: T) => void;
+  set: (value: S) => void;
 };
 /**
 * Creates a customized ref with explicit control over its dependency tracking
@@ -610,8 +611,11 @@ type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
 * @param factory - The function that receives the `track` and `trigger` callbacks.
 * @see {@link https://vuejs.org/api/reactivity-advanced.html#customref}
 */
-declare function customRef<T>(factory: CustomRefFactory<T>): Ref<T>;
+declare function customRef<T, S = T>(factory: CustomRefFactory<T, S>): Ref<T, S>;
 type ToRefs<T = any> = { [K in keyof T]: ToRef<T[K]> };
+type ArrayStringKey<T> = T extends readonly any[] ? number extends T["length"] ? `${number}` : never : never;
+type ToRefKey<T> = keyof T | ArrayStringKey<T>;
+type ToRefValue<T extends object, K extends ToRefKey<T>> = K extends keyof T ? T[K] : T extends readonly (infer V)[] ? K extends ArrayStringKey<T> ? V : never : never;
 /**
 * Converts a reactive object to a plain object where each property of the
 * resulting object is a ref pointing to the corresponding property of the
@@ -666,8 +670,8 @@ type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>;
 * @see {@link https://vuejs.org/api/reactivity-utilities.html#toref}
 */
 declare function toRef<T>(value: T): T extends (() => infer R) ? Readonly<Ref<R>> : T extends Ref ? T : Ref<UnwrapRef<T>>;
-declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
-declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
+declare function toRef<T extends object, K extends ToRefKey<T>>(object: T, key: K): ToRef<ToRefValue<T, K>>;
+declare function toRef<T extends object, K extends ToRefKey<T>>(object: T, key: K, defaultValue: ToRefValue<T, K>): ToRef<Exclude<ToRefValue<T, K>, undefined>>;
 /**
 * This is a special exported interface for other packages to declare
 * additional types that should bail out for ref unwrapping. For example
@@ -682,14 +686,12 @@ declare function toRef<T extends object, K extends keyof T>(object: T, key: K, d
 * ```
 */
 interface RefUnwrapBailTypes {}
-type ShallowUnwrapRef<T> = { [K in keyof T]: DistributeRef<T[K]> };
+type ShallowUnwrapRef<T> = T extends ShallowReactiveBrand ? T : { [K in keyof T]: DistributeRef<T[K]> };
 type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
 type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
 type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
   [RawSymbol]?: true;
-} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]> } : T extends object & {
-  [ShallowReactiveMarker]?: never;
-} ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]> } : T;
+} ? T : T extends ShallowReactiveBrand ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]> } : T extends object ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]> } : T;
 //#endregion
 //#region packages/reactivity/src/watch.d.ts
 declare enum WatchErrorCodes {
@@ -819,7 +821,7 @@ declare function nextTick<T, R>(this: T, fn: (this: T) => R | Promise<R>): Promi
 /**
 * @internal for runtime-vapor only
 */
-declare function queueJob(job: SchedulerJob, id?: number, isPre?: boolean): void;
+declare function queueJob(job: SchedulerJob, id?: number, isPre?: boolean, order?: number): void;
 declare function queuePostFlushCb(jobs: SchedulerJobs, id?: number): void;
 /**
 * @internal
@@ -1068,6 +1070,8 @@ type DefineModelOptions<T = any, G = T, S = T> = {
   get?: (v: T) => G;
   set?: (v: S) => any;
 };
+type DefineModelRuntimeOptions<T, G, S> = Omit<PropOptions<T>, "default"> & DefineModelOptions<T, G, S>;
+type DefineModelDefault<T> = InferDefault<Data, T>;
 /**
 * Vue `<script setup>` compiler macro for declaring a
 * two-way binding prop that can be consumed via `v-model` from the parent
@@ -1102,17 +1106,17 @@ type DefineModelOptions<T = any, G = T, S = T> = {
 * ```
 */
 declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options: ({
-  default: any;
+  default: DefineModelDefault<T>;
 } | {
   required: true;
-}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
+}) & DefineModelRuntimeOptions<T, G, S>): ModelRef<T, M, G, S>;
+declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options?: DefineModelRuntimeOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
 declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options: ({
-  default: any;
+  default: DefineModelDefault<T>;
 } | {
   required: true;
-}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
+}) & DefineModelRuntimeOptions<T, G, S>): ModelRef<T, M, G, S>;
+declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options?: DefineModelRuntimeOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
 type NotUndefined<T> = T extends undefined ? never : T;
 type MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
 type InferDefaults<T> = { [K in keyof T]?: InferDefault<T, T[K]> };
@@ -1178,12 +1182,12 @@ declare function createPropsRestProxy(props: any, excludedKeys: string[]): Recor
 * ```
 * @internal
 */
-declare function withAsyncContext(getAwaitable: () => any): [any, () => void];
+declare function withAsyncContext$1(getAwaitable: () => any): [any, () => void];
 //#endregion
 //#region packages/runtime-core/src/componentEmits.d.ts
-type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
+type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null | any[]>;
 type EmitsOptions = ObjectEmitsOptions | string[];
-type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? { [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any } : T extends ObjectEmitsOptions ? { [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends ((...args: infer P) => any) ? P : T[K] extends null ? any[] : never) => any } : {};
+type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? { [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any } : T extends ObjectEmitsOptions ? { [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends ((...args: infer P) => any) ? P : T[K] extends null ? any[] : T[K] extends any[] ? T[K] : never) => any } : {};
 type TypeEmitsToOptions<T extends ComponentTypeEmits> = { [K in keyof T & string]: T[K] extends [...args: infer Args] ? (...args: Args) => any : () => any } & (T extends ((...args: any[]) => any) ? ParametersToFns<OverloadParameters<T>> : {});
 type ParametersToFns<T extends any[]> = { [K in T[0]]: IsStringLiteral<K> extends true ? (...args: T extends [e: infer E, ...args: infer P] ? K extends E ? P : never : never) => any : never };
 type IsStringLiteral<T> = T extends string ? string extends T ? false : true : false;
@@ -1238,6 +1242,7 @@ type DirectiveArguments$1 = Array<[Directive$1 | undefined] | [Directive$1 | und
 * Adds directives to a VNode.
 */
 declare function withDirectives<T extends VNode>(vnode: T, directives: DirectiveArguments$1): T;
+declare function invokeDirectiveHook(vnode: VNode, prevVNode: VNode | null, instance: ComponentInternalInstance | null, name: keyof ObjectDirective): void;
 //#endregion
 //#region packages/runtime-core/src/componentPublicInstance.d.ts
 /**
@@ -1292,9 +1297,9 @@ type CreateComponentPublicInstance<P = {}, B = {}, D = {}, C extends ComputedOpt
 * inference everywhere internally, but it has to be a new type to avoid
 * breaking types that relies on previous arguments order (#10842)
 */
-type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive$1> = {}, Exposed extends string = string, TypeRefs extends Data = {}, TypeEl extends Element = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, "P"> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, "B"> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, "D"> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, "C"> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, "M"> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, "Defaults"> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
+type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive$1> = {}, Exposed extends string = string, TypeRefs extends Data = {}, TypeEl = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, "P"> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, "B"> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, "D"> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, "C"> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, "M"> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, "Defaults"> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
 type ExposedKeys<T, Exposed extends string & keyof T> = "" extends Exposed ? T : Pick<T, Exposed>;
-type ComponentPublicInstance<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = "", TypeRefs extends Data = {}, TypeEl extends Element = any> = {
+type ComponentPublicInstance<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = "", TypeRefs extends Data = {}, TypeEl = any> = {
   $: ComponentInternalInstance;
   $data: D;
   $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
@@ -1339,6 +1344,10 @@ interface SuspenseProps {
   onResolve?: () => void;
   onPending?: () => void;
   onFallback?: () => void;
+  /**
+  * Switch to fallback content if it takes longer than `timeout` milliseconds to render the new default content.
+  * A `timeout` value of `0` will cause the fallback content to be displayed immediately when default content is replaced.
+  */
   timeout?: string | number;
   /**
   * Allow suspense to be captured by parent suspense
@@ -1372,6 +1381,7 @@ interface SuspenseBoundary {
   container: RendererElement;
   hiddenContainer: RendererElement;
   activeBranch: VNode | null;
+  isFallbackMountPending: boolean;
   pendingBranch: VNode | null;
   deps: number;
   pendingId: number;
@@ -1402,6 +1412,7 @@ declare let isHydrating: boolean;
 type RootHydrateFunction = (vnode: VNode<Node, Element>, container: (Element | ShadowRoot) & {
   _vnode?: VNode;
 }) => void;
+declare const logMismatchError: () => void;
 declare function createHydrationFunctions(rendererInternals: RendererInternals<Node, Element>): [RootHydrateFunction, (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized?: boolean) => Node | null];
 declare const isTemplateNode: (node: Node) => node is HTMLTemplateElement;
 declare function getAttributeMismatch(el: Element, key: string, clientValue: any): {
@@ -1573,6 +1584,7 @@ declare enum MoveType {
 */
 declare function createRenderer<HostNode = RendererNode, HostElement = RendererElement>(options: RendererOptions<HostNode, HostElement>): Renderer<HostElement>;
 declare function createHydrationRenderer(options: RendererOptions<Node, Element>): HydrationRenderer;
+declare function invalidateMount(hooks: LifecycleHook | undefined): void;
 declare function performTransitionEnter(el: RendererElement, transition: TransitionHooks, insert: () => void, parentSuspense: SuspenseBoundary | null, force?: boolean): void;
 declare function performTransitionLeave(el: RendererElement, transition: TransitionHooks, remove: () => void, isElement?: boolean, force?: boolean): void;
 /**
@@ -1898,7 +1910,7 @@ declare function hasInjectionContext(): boolean;
 //#region packages/runtime-core/src/apiDefineComponent.d.ts
 type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
 type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
-type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive$1> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
+type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive$1> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
 type DefineSetupFnComponent<P extends Record<string, any>, E extends EmitsOptions = {}, S extends SlotsType = SlotsType, Props = P & EmitsToProps<E>, PP = PublicProps> = new (props: Props & PP) => CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, E, PP, {}, false, {}, S>;
 type ToResolvedProps<Props, Emits extends EmitsOptions> = Readonly<Props> & Readonly<EmitsToProps<Emits>>;
 declare function defineComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
@@ -1911,7 +1923,7 @@ declare function defineComponent<Props extends Record<string, any>, E extends Em
   emits?: E | EE[];
   slots?: S;
 }): DefineSetupFnComponent<Props, E, S>;
-declare function defineComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Data = {}, SetupBindings = {}, Computed extends ComputedOptions = {}, Methods extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, InjectOptions extends ComponentInjectOptions = {}, InjectKeys extends string = string, Slots extends SlotsType = {}, LocalComponents extends Record<string, Component> = {}, Directives extends Record<string, Directive$1> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, 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> = {}, TypeEl extends Element = any>(options: {
+declare function defineComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Data = {}, SetupBindings = {}, Computed extends ComputedOptions = {}, Methods extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, InjectOptions extends ComponentInjectOptions = {}, InjectKeys extends string = string, Slots extends SlotsType = {}, LocalComponents extends Record<string, Component> = {}, Directives extends Record<string, Directive$1> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, 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> = {}, TypeEl = any>(options: {
   props?: (RuntimePropsOptions & ThisType<void>) | RuntimePropsKeys[];
   /**
   * @private for language-tools use only
@@ -2015,19 +2027,19 @@ interface AppConfig extends GenericAppConfig {
 * The vapor in vdom implementation is in runtime-vapor/src/vdomInterop.ts
 */
 interface VaporInteropInterface {
-  mount(vnode: VNode, container: any, anchor: any, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, onBeforeMount?: () => void): GenericComponentInstance;
-  update(n1: VNode, n2: VNode, shouldUpdate: boolean, onBeforeUpdate?: () => void): void;
+  mount(vnode: VNode, container: any, anchor: any, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, onBeforeMount?: () => void, onVnodeBeforeMount?: () => void): GenericComponentInstance;
+  update(n1: VNode, n2: VNode, shouldUpdate: boolean, onBeforeUpdate?: () => void, onVnodeBeforeUpdate?: () => void): void;
   unmount(vnode: VNode, doRemove?: boolean): void;
   move(vnode: VNode, container: any, anchor: any, moveType: MoveType): void;
   slot(n1: VNode | null, n2: VNode, container: any, anchor: any, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null): void;
-  hydrate(vnode: VNode, node: any, container: any, anchor: any, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null): Node;
-  hydrateSlot(vnode: VNode, node: any): Node;
+  hydrate(vnode: VNode, node: any, container: any, anchor: any, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, onBeforeMount?: () => void, onVnodeBeforeMount?: () => void): Node;
+  hydrateSlot(vnode: VNode, node: any, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null): Node;
   activate(vnode: VNode, container: any, anchor: any, parentComponent: ComponentInternalInstance): void;
   deactivate(vnode: VNode, container: any): void;
   setTransitionHooks(component: ComponentInternalInstance, transition: TransitionHooks): void;
-  vdomMount: (component: ConcreteComponent, parentComponent: any, props?: any, slots?: any) => any;
+  vdomMount: (component: ConcreteComponent, parentComponent: any, props?: any, slots?: any, once?: boolean) => any;
   vdomUnmount: UnmountComponentFn;
-  vdomSlot: (slots: any, name: string | (() => string), props: Record<string, any>, parentComponent: any, fallback?: any) => any;
+  vdomSlot: (slots: any, name: string | (() => string), props: Record<string, any>, parentComponent: any, fallback?: any, once?: boolean, slotRoot?: boolean) => any;
   vdomMountVNode: (vnode: VNode, parentComponent: any) => any;
 }
 /**
@@ -2312,7 +2324,10 @@ interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraPro
   vs?: {
     slot: (props: any) => any;
     fallback: (() => VNodeArrayChildren) | undefined;
+    outletFallback?: (() => VNodeArrayChildren) | undefined;
+    state?: unknown;
     ref?: ShallowRef<any>;
+    scope?: EffectScope;
   };
   /**
   * @internal Vapor slot Block
@@ -2703,6 +2718,11 @@ interface GenericComponentInstance {
   */
   asyncResolved: boolean;
   /**
+  * restore renderer-specific async context after `withAsyncContext()`
+  * @internal
+  */
+  restoreAsyncContext?: () => void | (() => void);
+  /**
   * `updateTeleportCssVars`
   * For updating css vars on contained teleports
   * @internal
@@ -3055,7 +3075,7 @@ type AsyncComponentContext<T, C = ConcreteComponent> = {
   setPendingRequest: (request: Promise<C> | null) => void;
 };
 declare function createAsyncComponentContext<T, C = ConcreteComponent>(source: AsyncComponentLoader<T> | AsyncComponentOptions<T>): AsyncComponentContext<T, C>;
-declare const useAsyncComponentState: (delay: number | undefined, timeout: number | undefined, onError: (err: Error) => void) => {
+declare const useAsyncComponentState: (delay: number | undefined, timeout: number | undefined, onError: (err: Error) => void, instance?: GenericComponentInstance | null) => {
   loaded: Ref<boolean>;
   error: Ref<Error | undefined>;
   delayed: Ref<boolean>;
@@ -3271,11 +3291,15 @@ declare function renderList<T>(source: T, renderItem: <K extends keyof T>(value:
 declare function toHandlers(obj: Record<string, any>, preserveCaseIfNecessary?: boolean): Record<string, any>;
 //#endregion
 //#region packages/runtime-core/src/helpers/renderSlot.d.ts
+type SlotFallback = {
+  (): VNodeArrayChildren;
+  __vdom?: boolean;
+};
 /**
 * Compiler runtime helper for rendering `<slot/>`
 * @private
 */
-declare function renderSlot(slots: Slots, name: string, props?: Data, fallback?: () => VNodeArrayChildren, noSlotted?: boolean): VNode;
+declare function renderSlot(slots: Slots, name: string, props?: Data, fallback?: SlotFallback, noSlotted?: boolean, branchKey?: PropertyKey): VNode;
 declare function ensureValidVNode(vnodes: VNodeArrayChildren): VNodeArrayChildren | null;
 declare function ensureVaporSlotFallback(vnodes: VNodeArrayChildren | null | undefined, fallback?: () => VNodeArrayChildren): void;
 //#endregion
@@ -3303,6 +3327,7 @@ declare function renderComponentRoot(instance: ComponentInternalInstance): VNode
 */
 declare function warnExtraneousAttributes(attrs: Record<string, any>): void;
 declare const getFunctionalFallthrough: (attrs: Data) => Data | undefined;
+declare function shouldUpdateComponent(prevVNode: VNode, nextVNode: VNode, optimized?: boolean): boolean;
 //#endregion
 //#region packages/runtime-core/src/compat/globalConfig.d.ts
 type LegacyConfig = {
@@ -25101,7 +25126,10 @@ declare abstract class VueElementBase<E = Element, C = Component, Def extends Cu
   protected abstract _mount(def: Def): void;
   protected abstract _update(): void;
   protected abstract _unmount(): void;
-  protected abstract _updateSlotNodes(slot: Map<Node, Node[]>): void;
+  protected abstract _updateSlotNodes(slot: Map<Node, {
+    nodes: Node[];
+    usedFallback: boolean;
+  }>): void;
   constructor(def: Def, props: Record<string, any> | undefined, createAppFn: CreateAppFunction<E, C>);
   connectedCallback(): void;
   disconnectedCallback(): void;
@@ -25170,7 +25198,10 @@ declare class VueElement extends VueElementBase<Element, Component, InnerCompone
   /**
   * Only called when shadowRoot is false
   */
-  protected _updateSlotNodes(replacements: Map<Node, Node[]>): void;
+  protected _updateSlotNodes(replacements: Map<Node, {
+    nodes: Node[];
+    usedFallback: boolean;
+  }>): void;
   private _createVNode;
 }
 declare function useHost(caller?: string): VueElementBase | null;
@@ -25204,10 +25235,13 @@ declare function setVarsOnNode(el: Node, vars: Record<string, string>): void;
 type Style = string | null | undefined | Record<string, unknown>;
 declare function patchStyle(el: Element, prev: Style, next: Style): void;
 //#endregion
+//#region packages/runtime-dom/src/modules/events.d.ts
+declare function parseEventName(name: string): [string, EventListenerOptions | undefined];
+//#endregion
 //#region packages/runtime-dom/src/modules/attrs.d.ts
 declare const xlinkNS = "http://www.w3.org/1999/xlink";
 declare namespace index_d_exports$1 {
-  export { AllowedAttrs, AllowedComponentProps, AnchorHTMLAttributes, App, AppConfig, AppContext, AppMountFn, AppUnmountFn, AreaHTMLAttributes, AriaAttributes, AsyncComponentInternalOptions, AsyncComponentLoader, AsyncComponentOptions, Attrs, AudioHTMLAttributes, BaseHTMLAttributes, BaseTransition, BaseTransitionProps, BaseTransitionPropsValidators, BlockquoteHTMLAttributes, ButtonHTMLAttributes, CSSProperties, CanvasHTMLAttributes, ClassValue, ColHTMLAttributes, ColgroupHTMLAttributes, Comment$2 as Comment, CompatVue, Component, ComponentCustomElementInterface, ComponentCustomOptions, ComponentCustomProperties, ComponentCustomProps, ComponentInjectOptions, ComponentInstance, ComponentInternalInstance, ComponentInternalOptions, ComponentObjectPropsOptions, ComponentOptions, ComponentOptionsBase, ComponentOptionsMixin, ComponentOptionsWithArrayProps, ComponentOptionsWithObjectProps, ComponentOptionsWithoutProps, ComponentPropsOptions, ComponentProvideOptions, ComponentPublicInstance, ComponentTypeEmits, ComputedGetter, ComputedOptions, ComputedRef, ComputedSetter, ConcreteComponent, CreateAppFunction, CreateComponentPublicInstance, CreateComponentPublicInstanceWithMixins, CustomElementOptions, CustomRefFactory, DataHTMLAttributes, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, DeepReadonly, DefineComponent, DefineProps, DefineSetupFnComponent, DelHTMLAttributes, DeprecationTypes, DetailsHTMLAttributes, DialogHTMLAttributes, Directive$1 as Directive, DirectiveArguments$1 as DirectiveArguments, DirectiveBinding, DirectiveHook, DirectiveModifiers, EffectScheduler, EffectScope, ElementNamespace, ElementWithTransition, EmbedHTMLAttributes, EmitFn, EmitsOptions, EmitsToProps, ErrorCodes, ErrorTypeStrings, Events, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, FieldsetHTMLAttributes, FormHTMLAttributes, Fragment, FunctionDirective, FunctionPlugin, FunctionalComponent, GenericAppContext, GenericComponent, GenericComponentInstance, GlobalComponents, GlobalDirectives, HMRRuntime, HTMLAttributes, HtmlHTMLAttributes, HydrationRenderer, HydrationStrategy, HydrationStrategyFactory, IframeHTMLAttributes, ImgHTMLAttributes, InjectionKey, InputAutoCompleteAttribute, InputHTMLAttributes, InputTypeHTMLAttribute, InsHTMLAttributes, IntrinsicElementAttributes, KeepAlive, KeepAliveContext, KeepAliveProps, KeygenHTMLAttributes, LabelHTMLAttributes, LegacyConfig, LiHTMLAttributes, LifecycleHook, LinkHTMLAttributes, MapHTMLAttributes, MaybeRef, MaybeRefOrGetter, MediaHTMLAttributes, MenuHTMLAttributes, MetaHTMLAttributes, MeterHTMLAttributes, MethodOptions, MismatchTypes, ModelRef, MoveType, MultiWatchSources, NULL_DYNAMIC_COMPONENT, NativeElements, NormalizedPropsOptions, ObjectDirective, ObjectEmitsOptions, ObjectHTMLAttributes, ObjectPlugin, OlHTMLAttributes, OptgroupHTMLAttributes, OptionHTMLAttributes, OptionMergeFunction, OutputHTMLAttributes, ParamHTMLAttributes, Plugin, ProgressHTMLAttributes, Prop, PropType, PublicProps, QuoteHTMLAttributes, Raw, Reactive, ReactiveEffect, ReactiveEffectOptions, ReactiveEffectRunner, ReactiveFlags$1 as ReactiveFlags, Ref, RenderFunction, Renderer, RendererElement, RendererInternals, RendererNode, RendererOptions, ReservedProps, RootHydrateFunction, RootRenderFunction, RuntimeCompilerOptions, SVGAttributes, SchedulerJob, SchedulerJobFlags, ScriptHTMLAttributes, SelectHTMLAttributes, SetupContext, ShallowReactive, ShallowRef, ShallowUnwrapRef, ShortEmitsToObject, Slot, Slots, SlotsType, SourceHTMLAttributes, Static, StyleHTMLAttributes, StyleValue, Suspense, SuspenseBoundary, SuspenseProps, TableHTMLAttributes, TdHTMLAttributes, Teleport, TeleportProps, TeleportTargetElement, TemplateRef, Text$1 as Text, TextareaHTMLAttributes, ThHTMLAttributes, TimeHTMLAttributes, ToRef, ToRefs, TrackHTMLAttributes, TrackOpTypes, Transition, TransitionElement, TransitionGroup, TransitionGroupProps, TransitionHooks, TransitionHooksContext, TransitionProps, TransitionPropsValidators, TransitionState, TriggerOpTypes, TypeEmitsToOptions, UnwrapNestedRefs, UnwrapRef, VNode, VNodeArrayChildren, VNodeChild, VNodeNormalizedChildren, VNodeNormalizedRef, VNodeProps, VNodeRef, VNodeTypes, VShowElement, VaporInteropInterface, VideoHTMLAttributes, VueElement, VueElementBase, VueElementConstructor, WatchCallback, WatchEffect, WatchHandle, WatchOptions, WatchEffectOptions as WatchOptionsBase, WatchSource, WatchStopHandle, WebViewHTMLAttributes, WritableComputedOptions, WritableComputedRef, activate, assertNumber, baseApplyTranslation, baseEmit, baseNormalizePropsOptions, baseResolveTransitionHooks, baseUseCssVars, callPendingCbs, callWithAsyncErrorHandling, callWithErrorHandling, camelize, capitalize, checkTransitionMode, cloneVNode, compatUtils, computed, createApp, createAppAPI, createAsyncComponentContext, createBlock, createCanSetSetupRefChecker, createCommentVNode, createElementBlock, createBaseVNode as createElementVNode, createHydrationRenderer, createInternalObject, createPropsRestProxy, createRenderer, createSSRApp, createSlots, createStaticVNode, createTextVNode, createVNode, currentInstance, customRef, deactivate, defineAsyncComponent, defineComponent, defineCustomElement, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSSRCustomElement, defineSlots, devtools, devtoolsComponentAdded, effect, effectScope, endMeasure, ensureHydrationRenderer, ensureRenderer, ensureVaporSlotFallback, expose, flushOnAppMount, forceReflow, getAttributeMismatch, getComponentName, getCurrentInstance, getCurrentScope, getCurrentWatcher, getFunctionalFallthrough, getInheritedScopeIds, getTransitionRawChildren, guardReactiveProps, h, handleError, handleMovedChildren, hasCSSTransform, hasInjectionContext, hydrate, hydrateOnIdle, hydrateOnInteraction, hydrateOnMediaQuery, hydrateOnVisible, initCustomFormatter, initDirectivesForSSR, initFeatureFlags, inject, isAsyncWrapper, isEmitListener, isHydrating, isKeepAlive, isMapEqual, isMemoSame, isMismatchAllowed, isProxy, isReactive, isReadonly, isRef, isRuntimeOnly, isSetEqual, isShallow, isTeleportDeferred, isTeleportDisabled, isTemplateNode, isTemplateRefKey, isVNode, isValidHtmlOrSvgAttribute, knownTemplateRefs, leaveCbKey, markAsyncBoundary, markRaw, matches, mergeDefaults, mergeModels, mergeProps, nextTick, nextUid, nodeOps, normalizeClass, normalizeContainer, normalizeProps, normalizeRef, normalizeStyle, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onScopeDispose, onServerPrefetch, onUnmounted, onUpdated, onWatcherCleanup, openBlock, patchProp, patchStyle, performAsyncHydrate, performTransitionEnter, performTransitionLeave, popScopeId, popWarningContext, provide, proxyRefs, pushScopeId, pushWarningContext, queueJob, queuePostFlushCb, reactive, readonly, ref$1 as ref, registerHMR, registerRuntimeCompiler, render, renderList, renderSlot, resetShapeFlag, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolvePropValue, resolveTarget as resolveTeleportTarget, resolveTransitionHooks, resolveTransitionProps, setBlockTracking, setCurrentInstance, setCurrentRenderingInstance, setDevtoolsHook, setIsHydratingEnabled, setRef, setTransitionHooks, setVarsOnNode, shallowReactive, shallowReadonly, shallowRef, shouldSetAsProp, shouldSetAsPropForVueCE, simpleSetCurrentInstance, ssrContextKey, ssrUtils, startMeasure, stop, svgNS, toClassSet, toDisplayString, toHandlerKey, toHandlers, toRaw, toRef, toRefs, toStyleMap, toValue, transformVNodeArgs, triggerRef, unref, unregisterHMR, unsafeToTrustedHTML, useAsyncComponentState, useAttrs, useCssModule, useCssVars, useHost, useId, useInstanceOption, useModel, useSSRContext, useShadowRoot, useSlots, useTemplateRef, useTransitionState, vModelCheckbox, vModelCheckboxInit, vModelCheckboxUpdate, vModelDynamic, getValue as vModelGetValue, vModelRadio, vModelSelect, vModelSelectInit, vModelSetSelected, vModelText, vModelTextInit, vModelTextUpdate, vShow, vShowHidden, vShowOriginalDisplay, validateComponentName, validateProps, version, warn, warnExtraneousAttributes, warnPropMismatch, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withKeys, withMemo, withModifiers, withScopeId, xlinkNS };
+  export { AllowedAttrs, AllowedComponentProps, AnchorHTMLAttributes, App, AppConfig, AppContext, AppMountFn, AppUnmountFn, AreaHTMLAttributes, AriaAttributes, AsyncComponentInternalOptions, AsyncComponentLoader, AsyncComponentOptions, Attrs, AudioHTMLAttributes, BaseHTMLAttributes, BaseTransition, BaseTransitionProps, BaseTransitionPropsValidators, BlockquoteHTMLAttributes, ButtonHTMLAttributes, CSSProperties, CanvasHTMLAttributes, ClassValue, ColHTMLAttributes, ColgroupHTMLAttributes, Comment$2 as Comment, CompatVue, Component, ComponentCustomElementInterface, ComponentCustomOptions, ComponentCustomProperties, ComponentCustomProps, ComponentInjectOptions, ComponentInstance, ComponentInternalInstance, ComponentInternalOptions, ComponentObjectPropsOptions, ComponentOptions, ComponentOptionsBase, ComponentOptionsMixin, ComponentOptionsWithArrayProps, ComponentOptionsWithObjectProps, ComponentOptionsWithoutProps, ComponentPropsOptions, ComponentProvideOptions, ComponentPublicInstance, ComponentTypeEmits, ComputedGetter, ComputedOptions, ComputedRef, ComputedSetter, ConcreteComponent, CreateAppFunction, CreateComponentPublicInstance, CreateComponentPublicInstanceWithMixins, CustomElementOptions, CustomRefFactory, DataHTMLAttributes, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, DeepReadonly, DefineComponent, DefineProps, DefineSetupFnComponent, DelHTMLAttributes, DeprecationTypes, DetailsHTMLAttributes, DialogHTMLAttributes, Directive$1 as Directive, DirectiveArguments$1 as DirectiveArguments, DirectiveBinding, DirectiveHook, DirectiveModifiers, EffectScheduler, EffectScope, ElementNamespace, ElementWithTransition, EmbedHTMLAttributes, EmitFn, EmitsOptions, EmitsToProps, ErrorCodes, ErrorTypeStrings, Events, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, FieldsetHTMLAttributes, FormHTMLAttributes, Fragment, FunctionDirective, FunctionPlugin, FunctionalComponent, GenericAppContext, GenericComponent, GenericComponentInstance, GlobalComponents, GlobalDirectives, HMRRuntime, HTMLAttributes, HtmlHTMLAttributes, HydrationRenderer, HydrationStrategy, HydrationStrategyFactory, IframeHTMLAttributes, ImgHTMLAttributes, InjectionKey, InputAutoCompleteAttribute, InputHTMLAttributes, InputTypeHTMLAttribute, InsHTMLAttributes, IntrinsicElementAttributes, KeepAlive, KeepAliveContext, KeepAliveProps, KeygenHTMLAttributes, LabelHTMLAttributes, LegacyConfig, LiHTMLAttributes, LifecycleHook, LinkHTMLAttributes, MapHTMLAttributes, MaybeRef, MaybeRefOrGetter, MediaHTMLAttributes, MenuHTMLAttributes, MetaHTMLAttributes, MeterHTMLAttributes, MethodOptions, MismatchTypes, ModelRef, MoveType, MultiWatchSources, NULL_DYNAMIC_COMPONENT, NativeElements, NormalizedPropsOptions, ObjectDirective, ObjectEmitsOptions, ObjectHTMLAttributes, ObjectPlugin, OlHTMLAttributes, OptgroupHTMLAttributes, OptionHTMLAttributes, OptionMergeFunction, OutputHTMLAttributes, ParamHTMLAttributes, Plugin, ProgressHTMLAttributes, Prop, PropType, PublicProps, QuoteHTMLAttributes, Raw, Reactive, ReactiveEffect, ReactiveEffectOptions, ReactiveEffectRunner, ReactiveFlags$1 as ReactiveFlags, Ref, RenderFunction, Renderer, RendererElement, RendererInternals, RendererNode, RendererOptions, ReservedProps, RootHydrateFunction, RootRenderFunction, RuntimeCompilerOptions, SVGAttributes, SchedulerJob, SchedulerJobFlags, ScriptHTMLAttributes, SelectHTMLAttributes, SetupContext, ShallowReactive, ShallowRef, ShallowUnwrapRef, ShortEmitsToObject, Slot, Slots, SlotsType, SourceHTMLAttributes, Static, StyleHTMLAttributes, StyleValue, Suspense, SuspenseBoundary, SuspenseProps, TableHTMLAttributes, TdHTMLAttributes, Teleport, TeleportProps, TeleportTargetElement, TemplateRef, Text$1 as Text, TextareaHTMLAttributes, ThHTMLAttributes, TimeHTMLAttributes, ToRef, ToRefs, TrackHTMLAttributes, TrackOpTypes, Transition, TransitionElement, TransitionGroup, TransitionGroupProps, TransitionHooks, TransitionHooksContext, TransitionProps, TransitionPropsValidators, TransitionState, TriggerOpTypes, TypeEmitsToOptions, UnwrapNestedRefs, UnwrapRef, VNode, VNodeArrayChildren, VNodeChild, VNodeNormalizedChildren, VNodeNormalizedRef, VNodeProps, VNodeRef, VNodeTypes, VShowElement, VaporInteropInterface, VaporSlot$1 as VaporSlot, VideoHTMLAttributes, VueElement, VueElementBase, VueElementConstructor, WatchCallback, WatchEffect, WatchHandle, WatchOptions, WatchEffectOptions as WatchOptionsBase, WatchSource, WatchStopHandle, WebViewHTMLAttributes, WritableComputedOptions, WritableComputedRef, activate, assertNumber, baseApplyTranslation, baseEmit, baseNormalizePropsOptions, baseResolveTransitionHooks, baseUseCssVars, callPendingCbs, callWithAsyncErrorHandling, callWithErrorHandling, camelize, capitalize, checkTransitionMode, cloneVNode, compatUtils, computed, createApp, createAppAPI, createAsyncComponentContext, createBlock, createCanSetSetupRefChecker, createCommentVNode, createElementBlock, createBaseVNode as createElementVNode, createHydrationRenderer, createInternalObject, createPropsRestProxy, createRenderer, createSSRApp, createSlots, createStaticVNode, createTextVNode, createVNode, currentInstance, customRef, deactivate, defineAsyncComponent, defineComponent, defineCustomElement, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSSRCustomElement, defineSlots, devtools, devtoolsComponentAdded, effect, effectScope, endMeasure, ensureHydrationRenderer, ensureRenderer, ensureValidVNode, ensureVaporSlotFallback, expose, flushOnAppMount, forceReflow, getAttributeMismatch, getComponentName, getCurrentInstance, getCurrentScope, getCurrentWatcher, getFunctionalFallthrough, getInheritedScopeIds, getTransitionRawChildren, guardReactiveProps, h, handleError, handleMovedChildren, hasCSSTransform, hasInjectionContext, hydrate, hydrateOnIdle, hydrateOnInteraction, hydrateOnMediaQuery, hydrateOnVisible, initCustomFormatter, initDirectivesForSSR, initFeatureFlags, inject, invalidateMount, invokeDirectiveHook, isAsyncWrapper, isEmitListener, isHydrating, isKeepAlive, isMapEqual, isMemoSame, isMismatchAllowed, isProxy, isReactive, isReadonly, isRef, isRuntimeOnly, isSetEqual, isShallow, isTeleportDeferred, isTeleportDisabled, isTemplateNode, isTemplateRefKey, isVNode, isValidHtmlOrSvgAttribute, knownTemplateRefs, leaveCbKey, logMismatchError, markAsyncBoundary, markRaw, matches, mergeDefaults, mergeModels, mergeProps, nextTick, nextUid, nodeOps, normalizeClass, normalizeContainer, normalizeProps, normalizeRef, normalizeStyle, normalizeVNode, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onScopeDispose, onServerPrefetch, onUnmounted, onUpdated, onWatcherCleanup, openBlock, parseEventName, patchProp, patchStyle, performAsyncHydrate, performTransitionEnter, performTransitionLeave, popScopeId, popWarningContext, provide, proxyRefs, pushScopeId, pushWarningContext, queueJob, queuePostFlushCb, reactive, readonly, ref$1 as ref, registerHMR, registerRuntimeCompiler, render, renderList, renderSlot, resetShapeFlag, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolvePropValue, resolveTarget as resolveTeleportTarget, resolveTransitionHooks, resolveTransitionProps, setBlockTracking, setCurrentInstance, setCurrentRenderingInstance, setDevtoolsHook, setIsHydratingEnabled, setRef, setTransitionHooks, setVarsOnNode, shallowReactive, shallowReadonly, shallowRef, shouldSetAsProp, shouldSetAsPropForVueCE, shouldUpdateComponent, simpleSetCurrentInstance, ssrContextKey, ssrUtils, startMeasure, stop, svgNS, toClassSet, toDisplayString, toHandlerKey, toHandlers, toRaw, toRef, toRefs, toStyleMap, toValue, transformVNodeArgs, triggerRef, unref, unregisterHMR, unsafeToTrustedHTML, useAsyncComponentState, useAttrs, useCssModule, useCssVars, useHost, useId, useInstanceOption, useModel, useSSRContext, useShadowRoot, useSlots, useTemplateRef, useTransitionState, vModelCheckbox, vModelCheckboxInit, vModelCheckboxUpdate, vModelDynamic, getValue as vModelGetValue, vModelRadio, vModelSelect, vModelSelectInit, vModelSetSelected, vModelText, vModelTextInit, vModelTextUpdate, vShow, vShowHidden, vShowOriginalDisplay, validateComponentName, validateProps, version, warn, warnExtraneousAttributes, warnPropMismatch, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext$1 as withAsyncContext, withCtx, withDefaults, withDirectives, withKeys, withMemo, withModifiers, withScopeId, xlinkNS };
 }
 /**
 * This is a stub implementation to prevent the need to use dom types.
@@ -25260,120 +25294,93 @@ type NodeRef = string | Ref | ((ref: Element | VaporComponentInstance, refs: Rec
 type RefEl = Element | VaporComponentInstance | DynamicFragment | VaporFragment;
 type setRefFn = (el: RefEl, ref: NodeRef, refFor?: boolean, refKey?: string) => NodeRef | undefined;
 declare function createTemplateRefSetter(): setRefFn;
+declare function setStaticTemplateRef(el: RefEl, ref: NodeRef, refFor?: boolean, refKey?: string): NodeRef | undefined;
+declare function setTemplateRefBinding(el: RefEl, getter: () => any, setter?: setRefFn, refFor?: boolean, refKey?: string): void;
 //#endregion
-//#region packages/runtime-vapor/src/componentSlots.d.ts
-type RawSlots = Record<string, VaporSlot> & {
-  $?: DynamicSlotSource[];
-};
-type StaticSlots = Record<string, VaporSlot>;
-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 instance (slot owner)
-* 2. elements inherit the slot owner's scopeId
-*/
-declare function withVaporCtx(fn: Function): BlockFn;
-declare function createSlot(name: string | (() => string), rawProps?: LooseRawProps | null, fallback?: VaporSlot, noSlotted?: boolean, once?: boolean): Block$1;
-//#endregion
-//#region packages/runtime-vapor/src/apiDefineComponent.d.ts
-type VaporPublicProps = ReservedProps & AllowedComponentProps & ComponentCustomProps;
-type VaporRenderResult<T = Block$1> = VNode | T | VaporRenderResult<T>[];
-type VaporComponentInstanceConstructor<T extends VaporComponentInstance> = {
-  __isFragment?: never;
-  __isTeleport?: never;
-  __isSuspense?: never;
-  new (...args: any[]): T;
-};
-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$1 = Block$1, 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$1 = Block$1, ResolvedProps extends Record<string, any> = Props & EmitsToProps<Emits> & VaporPublicProps> = new () => VaporComponentInstance<ResolvedProps, Emits, Slots, Exposed, TypeBlock>;
-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$1 = Block$1>(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>;
-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$1 = Block$1>(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>;
-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$1 = Block$1>(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$1 ? Record<string, any> : Exposed, TypeBlock, TypeRefs, unknown extends TypeProps ? true : false>;
+//#region packages/runtime-vapor/src/slotBoundary.d.ts
+interface SlotBoundaryContext {
+  parent: SlotBoundaryContext | null;
+  getFallback: () => BlockFn | undefined;
+  run<R>(fn: () => R, scope?: EffectScope): R;
+  markDirty: (force?: boolean) => void;
+  onContentInvalid?: (() => void)[];
+}
 //#endregion
-//#region packages/runtime-vapor/src/components/KeepAlive.d.ts
+//#region packages/runtime-vapor/src/keepAlive.d.ts
 interface VaporKeepAliveContext {
-  processShapeFlag(block: Block$1): boolean;
-  cacheBlock(): void;
-  cacheScope(key: any, scope: EffectScope): void;
-  getScope(key: any): EffectScope | undefined;
-  setCurrentBranchKey(key: any): any;
+  acquireBranchScope(key: any): EffectScope | undefined;
+  runBranchRender(frag: DynamicFragment, fn: () => void): void;
+  processShapeFlag(block: Block$1): any | false;
+  cacheBlock(block?: Block$1): void;
+  cacheScope(cacheKey: any, scopeLookupKey: any, scope: EffectScope): void;
+  getStorageContainer(): ParentNode;
 }
-declare const VaporKeepAlive: DefineVaporComponent<{}, string, KeepAliveProps>;
 //#endregion
 //#region packages/runtime-vapor/src/fragment.d.ts
 declare class VaporFragment<T extends Block$1 = Block$1> implements TransitionOptions {
+  /**
+  * @internal marker for duck typing to avoid direct instanceof check
+  * which prevents tree-shaking of VaporFragment
+  */
+  readonly __vf = true;
   $key?: any;
   $transition?: VaporTransitionHooks | undefined;
   nodes: T;
   vnode?: VNode | null;
   anchor?: Node;
-  parentComponent?: GenericComponentInstance | null;
-  fallback?: BlockFn;
+  isBlockValid?: (componentAsValid?: boolean) => boolean;
   insert?: (parent: ParentNode, anchor: Node | null, transitionHooks?: TransitionHooks) => void;
   remove?: (parent?: ParentNode, transitionHooks?: TransitionHooks) => void;
-  hydrate?: (...args: any[]) => void;
+  hydrate?(...args: any[]): void;
   setRef?: (instance: VaporComponentInstance, ref: NodeRef, refFor: boolean, refKey: string | undefined) => void;
+  onBeforeInsert?: ((nodes: Block$1) => void)[];
+  onBeforeRemove?: ((scope: EffectScope) => boolean)[];
+  onRemove?: (() => void)[];
+  onBeforeUpdate?: (() => void)[];
   onUpdated?: ((nodes?: Block$1) => void)[];
   constructor(nodes: T);
 }
+declare class RenderContextFragment<T extends Block$1 = Block$1> extends VaporFragment<T> {
+  readonly renderInstance: GenericComponentInstance | null;
+  readonly slotOwner: VaporComponentInstance | null;
+  readonly keepAliveCtx?: VaporKeepAliveContext | null;
+  readonly slotBoundary: SlotBoundaryContext | null;
+  constructor(nodes: T);
+  protected runWithRenderCtx<R>(fn: () => R, scope?: EffectScope): R;
+}
 declare class ForFragment extends VaporFragment<Block$1[]> {
-  constructor(nodes: Block$1[]);
+  resetListeners?: (() => void)[];
+  constructor(nodes: Block$1[], trackSlotBoundary: boolean, onInvalid?: () => void);
+  onReset(fn: () => void): void;
 }
-declare class DynamicFragment extends VaporFragment {
+declare class DynamicFragment extends RenderContextFragment {
+  /**
+  * @internal marker for duck typing to avoid direct instanceof check
+  * which prevents tree-shaking of DynamicFragment
+  */
+  readonly __df = true;
   anchor: Node;
   scope: EffectScope | undefined;
   current?: BlockFn;
   pending?: {
     render?: BlockFn;
     key: any;
+    noScope: boolean;
   };
   anchorLabel?: string;
   keyed?: boolean;
-  attrs?: Record<string, any>;
-  keepAliveCtx: VaporKeepAliveContext | null;
-  slotOwner: VaporComponentInstance | null;
-  constructor(anchorLabel?: string, keyed?: boolean, locate?: boolean);
-  update(render?: BlockFn, key?: any): void;
-  renderBranch(render: BlockFn | undefined, transition: VaporTransitionHooks | undefined, parent: ParentNode | null): void;
-  hydrate: (isEmpty?: boolean) => void;
-}
-declare function isFragment(val: NonNullable<unknown>): val is VaporFragment;
+  isSlot?: boolean;
+  forwarded?: boolean;
+  nativeChildren?: boolean;
+  inTransition?: boolean;
+  hasFallthroughAttrs?: true;
+  constructor(anchorLabel?: string, keyed?: boolean, locate?: boolean, trackSlotBoundary?: boolean, onInvalid?: () => void);
+  protected get autoHydrate(): boolean;
+  update(render?: BlockFn, key?: any, noScope?: boolean): void;
+  protected getBranchParent(): ParentNode | null;
+  renderBranch(render: BlockFn | undefined, transition: VaporTransitionHooks | undefined, parent: ParentNode | null, key: any, noScope?: boolean, notifyUpdated?: boolean): void;
+}
+declare function isFragment(val: unknown): val is VaporFragment;
 //#endregion
 //#region packages/runtime-vapor/src/block.d.ts
 interface VaporTransitionHooks extends TransitionHooks {
@@ -25381,7 +25388,7 @@ interface VaporTransitionHooks extends TransitionHooks {
   props: TransitionProps;
   instance: VaporComponentInstance;
   disabled?: boolean;
-  applyGroup?: (block: Block$1, hooks: VaporTransitionHooks) => void;
+  applyGroup?: (block: Block$1, props: TransitionProps, state: TransitionState, instance: VaporComponentInstance) => void;
 }
 interface TransitionOptions {
   $key?: any;
@@ -25395,64 +25402,91 @@ declare function insert$1(block: Block$1, parent: ParentNode & {
 declare function prepend(parent: ParentNode, ...blocks: Block$1[]): void;
 declare function remove(block: Block$1, parent?: ParentNode): void;
 //#endregion
-//#region packages/runtime-vapor/src/vdomInterop.d.ts
+//#region packages/runtime-vapor/src/vdomInteropState.d.ts
 declare const interopKey: unique symbol;
-declare const vaporInteropPlugin: Plugin;
 //#endregion
 //#region packages/runtime-vapor/src/componentProps.d.ts
-type RawProps = Record<string, () => unknown> & {
+type RawProps = Record<string, unknown> & {
   $?: DynamicPropsSource[] & {
     [interopKey]?: boolean;
   };
 };
-type DynamicPropsSource = (() => Record<string, unknown>) | Record<string, () => unknown>;
+type DynamicPropsSource = (() => Record<string, unknown>) | Record<string, unknown>;
 //#endregion
 //#region packages/runtime-vapor/src/renderEffect.d.ts
 declare class RenderEffect extends ReactiveEffect {
-  render: () => void;
   i: VaporComponentInstance | null;
   job: SchedulerJob;
-  updateJob: SchedulerJob;
-  constructor(render: () => void);
+  updateJob?: SchedulerJob;
+  render: () => void;
+  order: number;
+  constructor(render: () => void, noLifecycle?: boolean);
   fn(): void;
   notify(): void;
 }
 declare function renderEffect(fn: () => void, noLifecycle?: boolean): void;
 //#endregion
-//#region packages/runtime-vapor/src/components/Teleport.d.ts
-declare class TeleportFragment extends VaporFragment {
+//#region packages/runtime-vapor/src/componentSlots.d.ts
+type RawSlots = Record<string, VaporSlot> & {
+  $?: DynamicSlotSource[];
+};
+type LooseRawSlots = VaporSlot | (Record<string, VaporSlot | DynamicSlotSource[]> & {
+  $?: DynamicSlotSource[];
+});
+type StaticSlots = Record<string, VaporSlot>;
+type VaporSlot = BlockFn & {
+  _?: VaporSlotFlags.NON_STABLE;
+};
+type DynamicSlot = {
+  name: string;
+  fn: VaporSlot;
+};
+type DynamicSlotFn = () => DynamicSlot | DynamicSlot[];
+type DynamicSlotSource = StaticSlots | DynamicSlotFn;
+declare function createSlot(name?: string | (() => string), rawProps?: LooseRawProps | null, fallback?: VaporSlot, flags?: number): Block$1;
+//#endregion
+//#region packages/runtime-vapor/src/apiDefineComponent.d.ts
+type VaporPublicProps = ReservedProps & AllowedComponentProps & ComponentCustomProps;
+type VaporRenderResult<T = Block$1> = VNode | T | VaporRenderResult<T>[];
+type VaporComponentInstanceConstructor<T extends VaporComponentInstance> = {
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  new (...args: any[]): T;
+};
+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$1 = Block$1, 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$1 = Block$1, ResolvedProps extends Record<string, any> = Props & EmitsToProps<Emits> & VaporPublicProps> = new () => VaporComponentInstance<ResolvedProps, Emits, Slots, Exposed, TypeBlock>;
+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$1 = Block$1>(setup: (props: Props, ctx: {
+  emit: EmitFn<Emits>;
+  slots: Slots;
+  attrs: Record<string, any>;
+  expose: (exposed: Exposed) => void;
+}) => VaporRenderResult<TypeBlock> | void, extraOptions?: VaporComponentOptions<(keyof NoInfer<Props>)[], Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props, Emits, Slots, Exposed, TypeBlock>;
+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$1 = Block$1>(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>;
+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$1 = Block$1>(options: VaporComponentOptions<RuntimePropsOptions | RuntimePropsKeys[], ResolvedEmits, RuntimeEmitsKeys, Slots, Exposed, TypeBlock, InferredProps> & {
+  [key: string]: any;
   /**
-  * @internal marker for duck typing to avoid direct instanceof check
-  * which prevents tree-shaking of TeleportFragment
+  * @private for language-tools use only
   */
-  readonly __isTeleportFragment = true;
-  anchor?: Node;
-  private rawProps?;
-  private resolvedProps?;
-  private rawSlots?;
-  isDisabled?: boolean;
-  private isMounted;
-  target?: ParentNode | null;
-  targetAnchor?: Node | null;
-  targetStart?: Node | null;
-  placeholder?: Node;
-  mountContainer?: ParentNode | null;
-  mountAnchor?: Node | null;
-  constructor(props: LooseRawProps, slots: LooseRawSlots);
-  get parent(): ParentNode | null;
-  private initChildren;
-  private registerUpdateCssVars;
-  private handleChildrenUpdate;
-  private mount;
-  private mountToTarget;
-  private handlePropsUpdate;
-  insert: (container: ParentNode, anchor: Node | null) => void;
-  remove: (parent?: ParentNode | undefined) => void;
-  private hydrateDisabledTeleport;
-  private mountChildren;
-  hydrate: () => void;
-}
-declare const VaporTeleport: DefineVaporSetupFnComponent<TeleportProps>;
+  __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$1 ? Record<string, any> : Exposed, TypeBlock, TypeRefs, unknown extends TypeProps ? true : false>;
 //#endregion
 //#region packages/runtime-vapor/src/component.d.ts
 type VaporComponent = FunctionalVaporComponent<any> | VaporComponentOptions | DefineVaporComponent;
@@ -25479,10 +25513,6 @@ interface VaporComponentOptions<Props = {}, Emits extends EmitsOptions = {}, Run
   name?: string;
   vapor?: boolean;
   components?: Record<string, VaporComponent>;
-  /**
-  * @internal custom element interception hook
-  */
-  ce?: (instance: VaporComponentInstance) => void;
 }
 interface SharedInternalOptions {
   /**
@@ -25500,13 +25530,10 @@ interface SharedInternalOptions {
   */
   __emitsOptions?: ObjectEmitsOptions;
 }
-type LooseRawProps = Record<string, (() => unknown) | DynamicPropsSource[]> & {
+type LooseRawProps = Record<string, unknown> & {
   $?: DynamicPropsSource[];
 };
-type LooseRawSlots = Record<string, VaporSlot | DynamicSlotSource[]> & {
-  $?: DynamicSlotSource[];
-};
-declare function createComponent(component: VaporComponent, rawProps?: LooseRawProps | null, rawSlots?: LooseRawSlots | null, isSingleRoot?: boolean, once?: boolean, appContext?: GenericAppContext): VaporComponentInstance;
+declare function createComponent(component: VaporComponent, rawProps?: LooseRawProps | null, rawSlots?: LooseRawSlots | null, isSingleRoot?: boolean, once?: boolean, appContext?: GenericAppContext, managedMount?: boolean, ce?: (instance: VaporComponentInstance) => void): VaporComponentInstance;
 declare class VaporComponentInstance<Props extends Record<string, any> = {}, Emits extends EmitsOptions = {}, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block$1 = Block$1, TypeRefs extends Record<string, any> = Record<string, any>> implements GenericComponentInstance {
   vapor: true;
   uid: number;
@@ -25537,11 +25564,13 @@ declare class VaporComponentInstance<Props extends Record<string, any> = {}, Emi
   suspenseId: number;
   asyncDep: Promise<any> | null;
   asyncResolved: boolean;
-  renderEffects?: RenderEffect[];
+  restoreAsyncContext?: () => void | (() => void);
+  deferredHydrationBoundary?: () => void;
   hasFallthrough: boolean;
   shapeFlag?: number;
-  key?: any;
+  $key?: any;
   oncePropsCache?: Record<string | symbol, any>;
+  isOnce: boolean;
   isMounted: boolean;
   isUnmounted: boolean;
   isDeactivated: boolean;
@@ -25560,14 +25589,15 @@ declare class VaporComponentInstance<Props extends Record<string, any> = {}, Emi
   rtc?: LifecycleHook;
   ec?: LifecycleHook;
   sp?: LifecycleHook<() => Promise<unknown>>;
+  effectCount: number;
   setupState?: Exposed extends Block$1 ? undefined : ShallowUnwrapRef<Exposed>;
   devtoolsRawSetupState?: any;
   hmrRerender?: () => void;
   hmrReload?: (newComp: VaporComponent) => void;
-  parentTeleport?: TeleportFragment | null;
   propsOptions?: NormalizedPropsOptions;
   emitsOptions?: ObjectEmitsOptions | null;
   isSingleRoot?: boolean;
+  renderEffects?: RenderEffect[];
   /**
   * dev only flag to track whether $attrs was used during render.
   * If $attrs was used during render then the warning for failed attrs
@@ -25578,7 +25608,7 @@ declare class VaporComponentInstance<Props extends Record<string, any> = {}, Emi
   * @deprecated only used for JSX to detect props types.
   */
   $props: Props;
-  constructor(comp: VaporComponent, rawProps?: RawProps | null, rawSlots?: RawSlots | null, appContext?: GenericAppContext, once?: boolean);
+  constructor(comp: VaporComponent, rawProps?: RawProps | null, rawSlots?: LooseRawSlots | null, appContext?: GenericAppContext, once?: boolean, ce?: (instance: VaporComponentInstance) => void);
   /**
   * Expose `getKeysFromRawProps` on the instance so it can be used in code
   * paths where it's needed, e.g. `useModel`
@@ -25587,6 +25617,12 @@ declare class VaporComponentInstance<Props extends Record<string, any> = {}, Emi
 }
 declare function isVaporComponent(value: unknown): value is VaporComponentInstance;
 /**
+* Resolve an asset component by name before passing it to the fallback helper;
+* a string passed directly to `createComponentWithFallback` is plain element
+* fallback, not a component name.
+*/
+declare function createAssetComponent(name: string, rawProps?: LooseRawProps | null, rawSlots?: LooseRawSlots | null, isSingleRoot?: boolean, once?: boolean, maybeSelfReference?: boolean, appContext?: GenericAppContext): HTMLElement | VaporComponentInstance;
+/**
 * Used when a component cannot be resolved at compile time
 * and needs rely on runtime resolution - where it might fallback to a plain
 * element if the resolution fails.
@@ -25601,11 +25637,20 @@ declare const createVaporSSRApp: CreateAppFunction<ParentNode, VaporComponent>;
 //#region packages/runtime-vapor/src/apiDefineAsyncComponent.d.ts
 declare function defineVaporAsyncComponent<T extends VaporComponent>(source: AsyncComponentLoader<T> | AsyncComponentOptions<T>): T;
 //#endregion
+//#region packages/runtime-vapor/src/vdomInterop.d.ts
+declare const vaporInteropPlugin: Plugin;
+//#endregion
 //#region packages/runtime-vapor/src/directives/custom.d.ts
 type VaporDirective = (node: Element | VaporComponentInstance, value?: () => any, argument?: string, modifiers?: DirectiveModifiers) => (() => void) | void;
 type VaporDirectiveArguments = Array<[VaporDirective | undefined] | [VaporDirective | undefined, () => any] | [VaporDirective | undefined, (() => any) | undefined, argument: string] | [VaporDirective | undefined, value: (() => any) | undefined, argument: string | undefined, modifiers: DirectiveModifiers]>;
 declare function withVaporDirectives(node: Element | VaporComponentInstance, dirs: VaporDirectiveArguments): void;
 //#endregion
+//#region packages/runtime-vapor/src/components/Teleport.d.ts
+declare const VaporTeleport: DefineVaporSetupFnComponent<TeleportProps>;
+//#endregion
+//#region packages/runtime-vapor/src/components/KeepAlive.d.ts
+declare const VaporKeepAlive: DefineVaporComponent<{}, string, KeepAliveProps>;
+//#endregion
 //#region packages/runtime-vapor/src/apiDefineCustomElement.d.ts
 type VaporElementConstructor<P = {}> = {
   new (initialProps?: Record<string, any>): VaporElement & P;
@@ -25616,7 +25661,7 @@ declare function defineVaporCustomElement<Props, RawBindings = object>(setup: (p
   emit: EmitFn;
   expose: (exposed: Record<string, any>) => void;
 }) => RawBindings | VaporRenderResult, options?: Pick<VaporComponentOptions, "name" | "inheritAttrs" | "emits"> & CustomElementOptions & {
-  props?: (keyof Props)[];
+  props?: (keyof NoInfer<Props>)[];
 }): VaporElementConstructor<Props>;
 declare function defineVaporCustomElement<Props, RawBindings = object>(setup: (props: Props, ctx: {
   attrs: Record<string, any>;
@@ -25649,7 +25694,10 @@ declare class VaporElement extends VueElementBase<ParentNode, VaporComponent, Va
   /**
   * Only called when shadowRoot is false
   */
-  protected _updateSlotNodes(replacements: Map<Node, Node[]>): void;
+  protected _updateSlotNodes(replacements: Map<Node, {
+    nodes: Node[];
+    usedFallback: boolean;
+  }>): void;
   /**
   * Replace slot nodes with their replace content
   * @internal
@@ -25670,10 +25718,10 @@ type InsertionParent = ParentNode & {
 */
 declare function setInsertionState(parent: ParentNode & {
   $fc?: Node | null;
-}, anchor?: Node | 0 | null, logicalIndex?: number, last?: boolean): void;
+}, anchor?: Node | 0 | null, logicalIndex?: number | undefined): void;
 //#endregion
 //#region packages/runtime-vapor/src/dom/template.d.ts
-declare function template(html: string, root?: boolean, ns?: Namespace): () => Node & {
+declare function template(html: string, flags?: number, ns?: Namespace): () => Node & {
   $root?: true;
 };
 //#endregion
@@ -25681,7 +25729,7 @@ declare function template(html: string, root?: boolean, ns?: Namespace): () => N
 declare function createTextNode(value?: string): Text;
 declare function txt(node: ParentNode): Node;
 declare function child(node: InsertionParent, logicalIndex?: number): Node;
-declare function nthChild(node: InsertionParent, i: number): Node;
+declare function nthChild(node: InsertionParent, i: number, logicalIndex?: number): Node;
 declare function next(node: Node, logicalIndex?: number): Node;
 //#endregion
 //#region packages/runtime-vapor/src/dom/prop.d.ts
@@ -25689,6 +25737,7 @@ type TargetElement = Element & {
   $root?: true;
   $html?: string;
   $cls?: string;
+  $clsFlags?: number;
   $sty?: NormalizedStyle | string | undefined;
   value?: string;
   _value?: any;
@@ -25696,7 +25745,8 @@ type TargetElement = Element & {
 declare function setProp(el: any, key: string, value: any): void;
 declare function setAttr(el: any, key: string, value: any, isSVG?: boolean): void;
 declare function setDOMProp(el: any, key: string, value: any, forceHydrate?: boolean, attrName?: string): void;
-declare function setClass(el: TargetElement, value: any, isSVG?: boolean): void;
+declare function setClass(el: TargetElement, value: any, isSVG?: boolean, isNormalized?: boolean): void;
+declare function setClassName(el: TargetElement, flags: number, cls: string | string[], prefix?: string, suffix?: string): void;
 declare function setStyle(el: TargetElement, value: any): void;
 declare function setValue(el: TargetElement, value: any, forceHydrate?: boolean): void;
 /**
@@ -25723,16 +25773,20 @@ declare function setBlockHtml(block: Block$1 & {
 declare function setDynamicProps(el: any, args: any[], isSVG?: boolean): void;
 //#endregion
 //#region packages/runtime-vapor/src/dom/event.d.ts
-declare function on(el: Element, event: string, handler: (e: Event) => any | ((e: Event) => any)[], options?: AddEventListenerOptions & {
-  effect?: boolean;
-}): void;
-declare function delegate(el: any, event: string, handler: (e: Event) => any): void;
+type EventHandler = (...args: any[]) => any;
+type EventHandlerValue = EventHandler | EventHandler[];
+type MaybeEventHandlerValue = EventHandlerValue | null | undefined;
+declare function on(el: Element, event: string, handler: EventHandlerValue, options?: AddEventListenerOptions): void;
+declare function onBinding(el: Element, event: string, handler: EventHandlerValue, options?: AddEventListenerOptions): void;
+declare function delegate(el: any, event: string, handler: EventHandler): void;
 declare const delegateEvents: (...names: string[]) => void;
-declare function setDynamicEvents(el: HTMLElement, events: Record<string, (...args: any[]) => any>): void;
-declare function createInvoker(handler: (...args: any[]) => any): (...args: any[]) => any;
+declare function setDynamicEvents(el: HTMLElement, events: Record<string, EventHandlerValue>): void;
+declare function withVaporModifiers<T extends (event: Event, ...args: unknown[]) => any>(fn: T | null | undefined, modifiers: string[]): T;
+declare function withVaporKeys<T extends (event: KeyboardEvent) => any>(fn: T | null | undefined, modifiers: string[]): T;
+declare function createInvoker(handler: MaybeEventHandlerValue): EventHandler;
 //#endregion
 //#region packages/runtime-vapor/src/apiCreateIf.d.ts
-declare function createIf(condition: () => any, b1: BlockFn, b2?: BlockFn, blockShape?: number, once?: boolean, index?: number): Block$1;
+declare function createIf(condition: () => any, b1: BlockFn, b2?: BlockFn, flags?: number): Block$1;
 //#endregion
 //#region packages/runtime-vapor/src/apiCreateFragment.d.ts
 /**
@@ -25749,179 +25803,219 @@ declare function createKeyedFragment(key: () => any, render: BlockFn): Block$1;
 //#endregion
 //#region packages/runtime-vapor/src/apiCreateFor.d.ts
 type Source = any[] | Record<any, any> | number | Set<any> | Map<any, any>;
-declare const createFor: (src: () => Source, renderItem: (item: ShallowRef<any>, key: ShallowRef<any>, index: ShallowRef<number | undefined>) => Block$1, getKey?: (item: any, key: any, index?: number) => any, flags?: number, setup?: (_: {
-  createSelector: (source: () => any) => (cb: () => void) => void;
-}) => void) => ForFragment;
+declare const createFor: (src: () => Source, renderItem: (item: ShallowRef<any>, key: ShallowRef<any>, index: ShallowRef<number | undefined>) => Block$1, getKey?: (item: any, key: any, index?: number) => any, flags?: number) => ForFragment;
+interface ForSelector {
+  (key: any, oper: () => void): void;
+  /**
+  * Bulk-reset the selector's internal state. Hook into a v-for's fast-reset
+  * paths via `forFragment.onReset(selector.reset)` so the lazy per-item
+  * `onScopeDispose` teardowns short-circuit instead of doing N individual
+  * Map.delete() calls.
+  */
+  reset(): void;
+}
+/**
+* Builds a key-indexed selector that activates only the opers registered with
+* the key matching the current source value. Compared to letting each item
+* subscribe directly, this keeps re-renders on source change O(2) instead of
+* O(N) (only previous and new active item re-run).
+*
+* Selector cleanup follows the current scope. Per-item teardown is auto-wired
+* via `onScopeDispose` so callers (typically v-for item scopes) don't need
+* explicit deregistration. For bulk-reset hot paths, attach the selector to
+* the v-for via `frag.onReset(selector.reset)` to skip the per-item Map ops.
+*/
+declare function createSelector(source: () => any): ForSelector;
 declare function createForSlots(rawSource: Source, getSlot: (item: any, key: any, index?: number) => DynamicSlot): DynamicSlot[];
 declare function getRestElement(val: any, keys: string[]): any;
-declare function getDefaultValue(val: any, defaultVal: any): any;
+declare function getDefaultValue(val: any, getDefaultVal: () => any): any;
 //#endregion
 //#region packages/runtime-vapor/src/helpers/useCssVars.d.ts
 declare function useVaporCssVars(getter: () => Record<string, string>): void;
 //#endregion
+//#region packages/runtime-vapor/src/helpers/setKey.d.ts
+declare function setBlockKey(block: (Block$1 & {
+  $key?: any;
+}) | null | undefined, key: any): void;
+//#endregion
 //#region packages/runtime-vapor/src/apiCreateDynamicComponent.d.ts
-declare function createDynamicComponent(getter: () => any, rawProps?: RawProps | null, rawSlots?: RawSlots | null, isSingleRoot?: boolean, once?: boolean): VaporFexport ragment;
+declare function createDynamicComponent(getter: () => any, rawProps?: RawProps | null, rawSlots?: LooseRawSlots | null, flags?: number): VaporFragment;
+//#endregion
+//#region packages/runtime-vapor/src/apiSetupHelpers.d.ts
+declare function withAsyncContext(getAwaitable: () => any): [any, () => void];
 //#endregion
 //#region packages/runtime-vapor/src/directives/vShow.d.ts
-declare function applyexport VShow(target: Block$1, source: () => any): void;
+declare function applyVShow(target: Block$1, source: () => any): void;
 //#endregion
-//#regioexport n packages/runtime-vapor/src/diexport rectives/vModel.d.ts
-type VaporModelDirective<T extends HTMLElement = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement, export Modifiers extends string = string> = (el: T, get: () => any, set: (v: any) => void, modifieexport rs?: { [key in Modifiers]?: true }) => void;
-declare const applyTextModel: VaporModexport elDirective<HTMLInputElement | HTMLTextAreaElement, "trim" | "number" | "lazy">;
-dexport eclare const applyCheckboxModel: VaporModelDirective<HTMLInputElement>;
-declare const applyRadioModel: Vaexport porModelDirective<HTMLInputElement>;
-declare const applySelectModel: VaporModelDirective<HTMLSelectexport Element, "number">;
+//#region packages/runtime-vapor/src/directives/vModel.d.ts
+type VaporModelDirective<T extends HTMLElement = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement, Modifiers extends string = string> = (el: T, get: () => any, set: (v: any) => void, modifiers?: { [key in Modifiers]?: true }) => void;
+declare const applyTextModel: VaporModelDirective<HTMLInputElement | HTMLTextAreaElement, "trim" | "number" | "lazy">;
+declare const applyCheckboxModel: VaporModelDirective<HTMLInputElement>;
+declare const applyRadioModel: VaporModelDirective<HTMLInputElement>;
+declare const applySelectModel: VaporModelDirective<HTMLSelectElement, "number">;
 declare const applyDynamicModel: VaporModelDirective;
 //#endregion
-//#region packages/runtime-vapoexport r/src/components/Transition.d.ts
+//#region packages/runtime-vapor/src/components/Transition.d.ts
 declare const VaporTransition: FunctionalVaporComponent<TransitionProps>;
 //#endregion
-//#regionexport  packages/runtime-vapor/src/components/TransitionGroup.d.ts
+//#region packages/runtime-vapor/src/components/TransitionGroup.d.ts
 declare const VaporTransitionGroup: DefineVaporComponent<{}, string, TransitionGroupProps>;
 declare namespace index_d_exports {
-  export { Bloexport ck$1 as Block, DefineVaporComponent, DynamicFragment, FunctionalVaporComponent, VaporComponent, Vaexport porComponentInstance, VaporComponentOptions, VaporDirective, VaporElement, VaporElementCexport onstructor, VaporFragment, VaporKeepAlive, VaporKeepAliveContext, VaporPublicProps, VaporRenderResult, VaporSlot, VaporTeleport, VaporTrexport ansition, VaporTransitionGroup, VaporTransitionHooks, applyCheckboxModel, applyDynamicModel, applyRadioModel, applySelectModel, applyTextModel, applyVShow, child, createComponent, createComponentWithFallback, createDynamicComponent, createFor, createForSlots, createIf, createInvoker, createKeyedFragment, createPlainElement, createSlot, createTemplateRefSetter, cexport reateTextNode, createVaporApp, createVaporSSRAexport pp, defineVaporAsyncComponent, defineVaporComponenexport t, defineVaporCustomElement, defineVaporSSRCustomexport Element, delegate, delegateEvents, getDefaultValue, getRestElement, insert$1 as insert, isFragment, isVaporComponent, next, nthChild, on, prepend, remove, renderEffect, setAttr, setBlockHtml, setBlockText, setClass, setDOMProp,export  setDynamicEvents, setDynamicProps, setElementText, setHtml, setInsertionState, setProp, setStyle, setText, setValue, template, txt, useVaporCssVars, vaporInteropPlugin, withVaporCtx, withVaporDirectives };
+  export { Block$1 as Block, DefineVaporComponent, DynamicFragment, FunctionalVaporComponent, VaporComponent, VaporComponentInstance, VaporComponentOptions, VaporDirective, VaporElement, VaporElementConstructor, VaporFragment, VaporKeepAlive, VaporKeepAliveContext, VaporPublicProps, VaporRenderResult, VaporSlot, VaporTeleport, VaporTransition, VaporTransitionGroup, VaporTransitionHooks, applyCheckboxModel, applyDynamicModel, applyRadioModel, applySelectModel, applyTextModel, applyVShow, child, createAssetComponent, createComponent, createComponentWithFallback, createDynamicComponent, createFor, createForSlots, createIf, createInvoker, createKeyedFragment, createPlainElement, createSelector, createSlot, createTemplateRefSetter, createTextNode, createVaporApp, createVaporSSRApp, defineVaporAsyncComponent, defineVaporComponent, defineVaporCustomElement, defineVaporSSRCustomElement, delegate, delegateEvents, extend, getDefaultValue, getRestElement, insert$1 as insert, isFragment, isVaporComponent, next, nthChild, on, onBinding, prepend, remove, renderEffect, setAttr, setBlockHtml, setBlockKey, setBlockText, setClass, setClassName, setDOMProp, setDynamicEvents, setDynamicProps, setElementText, setHtml, setInsertionState, setProp, setStaticTemplateRef, setStyle, setTemplateRefBinding, setText, setValue, template, txt, useVaporCssVars, vaporInteropPlugin, withAsyncContext, withVaporDirectives, withVaporKeys, withVaporModifiers };
 }
 //#endregion
 //#region temp/packages/compiler-vapor/src/ir/component.d.ts
-interface IRProp extends Omit<DirectiveTransforexport mResult, "value"> {
+export interface IRProp extends Omit<DirectiveTransformResult, "value"> {
   values: SimpleExpressionNode[];
 }
-declare enum IRDynamicPropsKind {
+export declare enum IRDynamicPropsKind {
   EXPRESSION = 0,
   ATTRIBUTE = 1
 }
-type IRPropsStatic = IRProp[];
-interface IRPropsDynamicExpression {
+export type IRPropsStatic = IRProp[];
+export interface IRPropsDynamicExpression {
   kind: IRDynamicPropsKind.EXPRESSION;
   value: SimpleExpressionNode;
   handler?: boolean;
 }
-interface IRPropsDynamicAttribute extends IRProp export {
+export interface IRPropsDynamicAttribute extends IRProp {
   kind: IRDynamicPropsKind.ATTRIBUTE;
 }
-type IRProps = IRPropsStatic | IRPropsDynamicAttribute | IRPropsDynamicExpression;
-interface SlotBlockIRexport Node extends BlockIRNode {
+export type IRProps = IRPropsStatic | IRPropsDynamicAttribute | IRPropsDynamicExpression;
+export interface SlotBlockIRNode extends BlockIRNode {
   props?: SimpleExpressionNode;
 }
-declare enum IRSlotType {
+export declare enum IRSlotType {
   STATIC = 0,
   DYNAMIC = 1,
   LOOP = 2,
   CONDITIONAL = 3,
   EXPRESSION = 4
 }
-type IRSlotsStatic = {
+export type IRSlotsStatic = {
   slotType: IRSlotType.STATIC;
   slots: Record<string, SlotBlockIRNode>;
 };
-interface IRSlotDynamicBasic {
-  slotType: export IRSlotType.DYNAMIC;
+export interface IRSlotDynamicBasic {
+  slotType: IRSlotType.DYNAMIC;
   name: SimpleExpressionNode;
   fn: SlotBlockIRNode;
 }
-interface IRSlotDynamicLoop {
+export interface IRSlotDynamicLoop {
   slotType: IRSlotType.LOOP;
   name: SimpleExpressionNode;
   fn: SlotBlockIRNode;
   loop: IRFor;
 }
-interface IRSlotDynamicConditionexport al {
+export interface IRSlotDynamicConditional {
   slotType: IRSlotType.CONDITIONAL;
   condition: SimpleExpressionNode;
   positive: IRSlotDynamicBasic;
-  negative?: IRSlotexport DynamicBasic | IRSlotDynamicConditional;
+  negative?: IRSlotDynamicBasic | IRSlotDynamicConditional;
 }
-interface IRSlotsExpression {
+export interface IRSlotsExpression {
   slotType: IRSlotType.EXPRESSION;
   slots: SimpleExpressionNode;
 }
-type IRexport SlotDynamic = IRSlotDynamicBasic | IRSlotDynamicLoop | IRSlotDynamicConditional;
-type IRSlots = IRSlotsStatic | IRSlotDynamic | IRSlotsExpression;export 
+export type IRSlotDynamic = IRSlotDynamicBasic | IRSlotDynamicLoop | IRSlotDynamicConditional;
+export type IRSlots = IRSlotsStatic | IRSlotDynamic | IRSlotsExpression;
 //#endregion
 //#region temp/packages/compiler-vapor/src/ir/index.d.ts
-declare enum IRNodeTypes {
+export declare enum IRNodeTypes {
   ROOT = 0,
   BLOCK = 1,
-  SET_PROP = 2,
-  SET_DYNAMIC_PROPS = 3,
-  SET_TEXT = 4export ,
-  SET_EVENT = 5,
-  SET_DYNAMIC_EVENTS = 6,
-  SET_HTML export = 7,
-  SET_TEMPLATE_REF = 8,
-  INSERT_NODE = 9,
-  PREPEND_NODE = 10,
-  CREATE_COMPONENT_NODE = 11,
-  SLOT_OUTLET_NODE = 12,
-  DIRECTIVE = 13,
-  IF = 14,
-  FOR = 15,
-  KEY = 16,
-  GET_TEXT_CHILD = 17
-}
-interface BaseIRNode {
+  SET_BLOCK_KEY = 2,
+  SET_PROP = 3,
+  SET_DYNAMIC_PROPS = 4,
+  SET_TEXT = 5,
+  SET_EVENT = 6,
+  SET_DYNAMIC_EVENTS = 7,
+  SET_HTML = 8,
+  SET_TEMPLATE_REF = 9,
+  INSERT_NODE = 10,
+  PREPEND_NODE = 11,
+  CREATE_COMPONENT_NODE = 12,
+  SLOT_OUTLET_NODE = 13,
+  DIRECTIVE = 14,
+  IF = 15,
+  FOR = 16,
+  KEY = 17,
+  GET_TEXT_CHILD = 18
+}
+export interface BaseIRNode {
   type: IRNodeTypes;
 }
-type CoreHelper = keyof typeof index_d_exports$1;
-type VaporHelper = keyof typeof index_d_exports;
+export interface EffectBoundary {
+  operationIndex?: number;
+  effectIndex?: number;
+}
+export type CoreHelper = keyof typeof index_d_exports$1;
+export type VaporHelper = keyof typeof index_d_exports;
 export interface BlockIRNode extends BaseIRNode {
   type: IRNodeTypes.BLOCK;
   node: RootNode | TemplateChildNode;
   dynamic: IRDynamicInfo;
   tempId: number;
-export   effect: IREffect[];
+  effect: IREffect[];
   operation: OperationNode[];
   returns: number[];
 }
-interface RootIRNode {
+export interface RootIRNode {
   type: IRNodeTypes.ROOT;
   node: RootNode;
   source: string;
-  template: Map<striexport ng, Namespace>;
-  templateIndexMap: Map<string, number>;
-  rootTemplateIndexes: Set<number>;
+  template: TemplateRegistry;
   component: Set<string>;
-  directive: Set<stringexport >;
+  directive: Set<string>;
   block: BlockIRNode;
   hasTemplateRef: boolean;
-  hasDeferredVShow: boolean;
 }
-interface IfIRNode extends BaseIRNode {
-  export type: IRNodeTypes.IF;
+export interface IRTemplate {
+  content: string;
+  ns: Namespace;
+  root: boolean;
+  static: boolean;
+}
+export declare class TemplateRegistry {
+  entries: IRTemplate[];
+  keys(): string[];
+}
+export interface IfIRNode extends BaseIRNode, EffectBoundary {
+  type: IRNodeTypes.IF;
   id: number;
   blockShape: number;
   condition: SimpleExpressionNode;
   positive: BlockIRNode;
   negative?: BlockIRNode | IfIRNode;
   once?: boolean;
+  slotRoot?: boolean;
   index?: number;
   parent?: number;
   anchor?: number;
   logicalIndex?: number;
-  append?: booleanexport ;
-  last?: boolean;
+  append?: boolean;
 }
-interface IRFor {
+export interface IRFor {
   source: SimpleExpressionNode;
   value?: SimpleExpressionNode;
   key?: SimpleExpressionNode;
   index?: SimpleExpressionNode;
 }
-interface ForIRNode extends BaseIRNode, IRFor {
+export interface ForIRNode extends BaseIRNode, IRFor, EffectBoundary {
   type: IRNodeTypes.FOR;
   id: number;
   keyProp?: SimpleExpressionNode;
   render: BlockIRNode;
   once: boolean;
+  slotRoot?: boolean;
   component: boolean;
   onlyChild: boolean;
-  parent?export : number;
+  parent?: number;
   anchor?: number;
   logicalIndex?: number;
   append?: boolean;
-  last?: boolean;
 }
-interface KeyIRNode extends BaseIRNode {
+export interface KeyIRNode extends BaseIRNode, EffectBoundary {
   type: IRNodeTypes.KEY;
   id: number;
   value: SimpleExpressionNode;
@@ -25930,37 +26024,41 @@ interface KeyIRNode extends BaseIRNode {
   anchor?: number;
   logicalIndex?: number;
   append?: boolean;
-  last?: bexport oolean;
 }
-interface SetPropIRNode extends BaseIRNode {
+export interface SetBlockKeyIRNode extends BaseIRNode {
+  type: IRNodeTypes.SET_BLOCK_KEY;
+  element: number;
+  value: SimpleExpressionNode;
+}
+export interface SetPropIRNode extends BaseIRNode {
   type: IRNodeTypes.SET_PROP;
   element: number;
-  export prop: IRProp;
+  prop: IRProp;
   tag: string;
 }
-interface Sexport etDynamicPropsIRNode extends BaseIRNode {
+export interface SetDynamicPropsIRNode extends BaseIRNode {
   type: IRNodeTypes.SET_DYNAMIC_PROPS;
   element: number;
   props: IRProps[];
   tag: string;
 }
-interface SetDynamicEventsIRNode extends BaseIRNode {
+export interface SetDynamicEventsIRNode extends BaseIRNode {
   type: IRNodeTypes.SET_DYNAMIC_EVENTS;
   element: number;
   event: SimpleExpressionNode;
 }
-interface SetTextIRNode extendexport s BaseIRNode {
+export interface SetTextIRNode extends BaseIRNode {
   type: IRNodeTypes.SET_TEXT;
   element: number;
   values: SimpleExpressionNode[];
   generated?: boolean;
   isComponent?: boolean;
 }
-type KeyOverride = [find: string, replacement: string];
-interface SetEventIRNode extends BaseIRNode {
+export type KeyOverride = [find: string, replacement: string];
+export interface SetEventIRNode extends BaseIRNode {
   type: IRNodeTypes.SET_EVENT;
   element: number;
-  key: SimpleExpressionNoexport de;
+  key: SimpleExpressionNode;
   value?: SimpleExpressionNode;
   modifiers: {
     options: string[];
@@ -25970,33 +26068,33 @@ interface SetEventIRNode extends BaseIRNode {
   keyOverride?: KeyOverride;
   delegate: boolean;
   /** Whether it's in effect */
-  effect: booexport lean;
+  effect: boolean;
 }
-interface SetHtmlIRNode extends BaseIRNode {
+export interface SetHtmlIRNode extends BaseIRNode {
   type: IRNodeTypes.SET_HTML;
   element: number;
   value: SimpleExpressionNode;
   isComponent?: boolean;
 }
-interface SetTemplateRefIRNodexport e extends BaseIRNode {
+export interface SetTemplateRefIRNode extends BaseIRNode {
   type: IRNodeTypes.SET_TEMPLATE_REF;
   element: number;
   value: SimpleExpressionNode;
   refFor: boolean;
   effect: boolean;
 }
-interfacexport e InsertNodeIRNode extends BaseIRNode {
+export interface InsertNodeIRNode extends BaseIRNode {
   type: IRNodeTypes.INSERT_NODE;
   elements: number[];
   parent: number;
   anchor?: number;
 }
-interface PrependNodeIRNode extends BaseIRNode export {
+export interface PrependNodeIRNode extends BaseIRNode {
   type: IRNodeTypes.PREPEND_NODE;
   elements: number[];
   parent: number;
 }
-interface DirectiveIRNode export extends BaseIRNode {
+export interface DirectiveIRNode extends BaseIRNode {
   type: IRNodeTypes.DIRECTIVE;
   element: number;
   dir: VaporDirectiveNode;
@@ -26004,9 +26102,8 @@ interface DirectiveIRNode export extends BaseIRNode {
   builtin?: boolean;
   asset?: boolean;
   modelType?: "text" | "dynamic" | "radio" | "checkbox" | "select";
-  deferred?: boolean;
 }
-interface CreateComponentIRNode extends BaseIRNode {
+export interface CreateComponentIRNode extends BaseIRNode, EffectBoundary {
   type: IRNodeTypes.CREATE_COMPONENT_NODE;
   id: number;
   tag: string;
@@ -26015,35 +26112,33 @@ interface CreateComponentIRNode extends BaseIRNode {
   asset: boolean;
   root: boolean;
   once: boolean;
+  slotRoot?: boolean;
   dynamic?: SimpleExpressionNode;
-  isCustomElement: boolean;
+  useCreateElement: boolean;
   parent?: number;
   anchor?: number;
   logicalIndex?: number;
   append?: boolean;
-  last?: boolean;
 }
-interface SlotOutletIRNode extends BaseIRNode {
+export interface SlotOutletIRNode extends BaseIRNode, EffectBoundary {
   type: IRNodeTypes.SLOT_OUTLET_NODE;
   id: number;
   name: SimpleExpressionNode;
   props: IRProps[];
   fallback?: BlockIRNode;
-  noSlotted?: boolean;
-  once?: boolean;
+  flags: number;
   parent?: number;
   anchor?: number;
   logicalIndex?: number;
   append?: boolean;
-  last?: boolean;
 }
-interface GetTextChildIRNode extends BaseIRNode {
+export interface GetTextChildIRNode extends BaseIRNode {
   type: IRNodeTypes.GET_TEXT_CHILD;
   parent: number;
 }
-type IRNode = OperationNode | RootIRNode;
-type OperationNode = SetPropIRNode | SetDynamicPropsIRNode | SetTextIRNode | SetEventIRNode | SetDynamicEventsIRNode | SetHtmlIRNode | SetTemplateRefIRNode | InsertNodeIRNode | PrependNodeIRNode | DirectiveIRNode | IfIRNode | ForIRNode | KeyIRNode | CreateComponentIRNode | SlotOutletIRNode | GetTextChildIRNode;
-declare enum DynamicFlag {
+export type IRNode = OperationNode | RootIRNode;
+export type OperationNode = SetBlockKeyIRNode | SetPropIRNode | SetDynamicPropsIRNode | SetTextIRNode | SetEventIRNode | SetDynamicEventsIRNode | SetHtmlIRNode | SetTemplateRefIRNode | InsertNodeIRNode | PrependNodeIRNode | DirectiveIRNode | IfIRNode | ForIRNode | KeyIRNode | CreateComponentIRNode | SlotOutletIRNode | GetTextChildIRNode;
+export declare enum DynamicFlag {
   NONE = 0,
   /**
   * This node is referenced and needs to be saved as a variable.
@@ -26058,7 +26153,7 @@ declare enum DynamicFlag {
   */
   INSERT = 4
 }
-interface IRDynamicInfo {
+export interface IRDynamicInfo {
   id?: number;
   flags: DynamicFlag;
   anchor?: number;
@@ -26068,21 +26163,21 @@ interface IRDynamicInfo {
   hasDynamicChild?: boolean;
   operation?: OperationNode;
 }
-interface IREffect {
+export interface IREffect {
   expressions: SimpleExpressionNode[];
   operations: OperationNode[];
 }
 type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & Pick<U, Extract<keyof U, keyof T>>;
-type HackOptions<T> = Prettify<Overwrite<T, {
+export type HackOptions<T> = Prettify<Overwrite<T, {
   nodeTransforms?: NodeTransform[];
   directiveTransforms?: Record<string, DirectiveTransform | undefined>;
 }>>;
-type VaporDirectiveNode = Overwrite<DirectiveNode, {
+export type VaporDirectiveNode = Overwrite<DirectiveNode, {
   exp: Exclude<DirectiveNode["exp"], CompoundExpressionNode>;
   arg: Exclude<DirectiveNode["arg"], CompoundExpressionNode>;
 }>;
-type InsertionStateTypes = IfIRNode | ForIRNode | KeyIRNode | SlotOutletIRNode | CreateComponentIRNode;
-declare function isBlockOperation(op: OperationNode): op is InsertionStateTypes;
+export type InsertionStateTypes = IfIRNode | ForIRNode | KeyIRNode | SlotOutletIRNode | CreateComponentIRNode;
+export declare function isBlockOperation(op: OperationNode): op is InsertionStateTypes;
 //#endregion
 //#region packages/compiler-core/src/runtimeHelpers.d.ts
 declare const FRAGMENT: unique symbol;
@@ -26100,7 +26195,7 @@ interface ImportItem {
 //#region packages/compiler-core/src/transforms/transformElement.d.ts
 type PropsExpression = ObjectExpression | CallExpression | ExpressionNode;
 //#endregion
-//#region node_modules/.pnpm/@babel+types@7.29.0/node_modules/@babel/types/lib/index-legacy.d.ts
+//#region node_modules/.pnpm/@babel+types@7.29.7/node_modules/@babel/types/lib/index-legacy.d.ts
 // NOTE: This file is autogenerated. Do not modify.
 // See packages/babel-types/scripts/generators/typescript-legacy.ts for script used.
 interface BaseComment {
@@ -27897,21 +27992,21 @@ interface SequenceExpression extends Node$1 {
 }
 interface ReturnStatement extends Node$1 {
   type: NodeTypes.JS_RETURN_STATEMENT;
-  returns: TemplateChildNode$1 | Teexport mplateChildNode$1[] | JSChildNode;
+  returns: TemplateChildNode$1 | TemplateChildNode$1[] | JSChildNode;
 }
 interface DirectiveArguments extends ArrayExpression {
   elements: DirectiveArgumentNode[];
 }
-interface DirectiveArgumeexport ntNode extends ArrayExpression {
+interface DirectiveArgumentNode extends ArrayExpression {
   elements: [string] | [string, ExpressionNode] | [string, ExpressionNode, ExpressionNode] | [string, ExpressionNode, ExpressionNode, ObjectExpression];
 }
 interface RenderSlotCall extends CallExpression {
   callee: typeof RENDER_SLOT;
-  arguments: [string, string | ExpressionNode] | [string, string | ExpressionNode, PropsExpression] | [string, string | ExpressionNode, PropsExpressioexport n | "{}", TemplateChildNode$1[]];
+  arguments: [string, string | ExpressionNode] | [string, string | ExpressionNode, PropsExpression | "{}"] | [string, string | ExpressionNode, PropsExpression | "{}", FunctionExpression | string] | [string, string | ExpressionNode, PropsExpression | "{}", FunctionExpression | string, string] | [string, string | ExpressionNode, PropsExpression | "{}", FunctionExpression | string, string, JSChildNode];
 }
 type SlotsExpression = SlotsObjectExpression | DynamicSlotsExpression;
 interface SlotsObjectExpression extends ObjectExpression {
-  properties: SlotsObjectProperty[];export 
+  properties: SlotsObjectProperty[];
 }
 interface SlotsObjectProperty extends Property {
   value: SlotFunctionExpression;
@@ -27952,21 +28047,21 @@ interface ForCodegenNode extends VNodeCall {
   isBlock: true;
   tag: typeof FRAGMENT;
   props: undefined;
-  children: ForRendexport erListExpression;
+  children: ForRenderListExpression;
   patchFlag: PatchFlags;
   disableTracking: boolean;
 }
-interface Forexport RenderListExpression extends CallExpression {
+interface ForRenderListExpression extends CallExpression {
   callee: typeof RENDER_LIST;
   arguments: [ExpressionNode, ForIteratorExpression];
 }
 interface ForIteratorExpression extends FunctionExpression {
-  reexport turns?: BlockCodegenNode;
+  returns?: BlockCodegenNode;
 }
 //#endregion
-//#region temp/packages/export compiler-vapor/src/transform.d.ts
-type NodeTransform = (node: RootNode | TemplateChildNode, context: TransformContext<RootNode | TemplateChildNode>) => void | (() => void) | (() => void)[];
-type DirectiveTransform = (dir: VaporDirectiveNode, node: ElementNode, context: TransformContext<ElementNode>) => DirectiveTransformResult | void;
+//#region temp/packages/compiler-vapor/src/transform.d.ts
+export type NodeTransform = (node: RootNode | TemplateChildNode, context: TransformContext<RootNode | TemplateChildNode>) => void | (() => void) | (() => void)[];
+export type DirectiveTransform = (dir: VaporDirectiveNode, node: ElementNode, context: TransformContext<ElementNode>) => DirectiveTransformResult | void;
 interface DirectiveTransformResult {
   key: SimpleExpressionNode;
   value: SimpleExpressionNode;
@@ -27977,12 +28072,12 @@ interface DirectiveTransformResult {
   model?: boolean;
   modelModifiers?: string[];
 }
-type StructuralDirectiveTransform = (node: ElementNode, dir: VaporDirectiveNode, context: TransformContext<ElementNode>) => void | (() => void);
-type TransformOptions$1 = HackOptions<TransformOptions>export ;
-declare class TransformContext<T extends AllNode = AllNode> {
+export type StructuralDirectiveTransform = (node: ElementNode, dir: VaporDirectiveNode, context: TransformContext<ElementNode>) => void | (() => void);
+type TransformOptions$1 = HackOptions<TransformOptions>;
+export declare class TransformContext<T extends AllNode = AllNode> {
   ir: RootIRNode;
   node: T;
-  selfNamexport e: string | null;
+  selfName: string | null;
   parent: TransformContext<RootNode | ElementNode> | null;
   effectiveParent: TransformContext<RootNode | ElementNode> | null;
   root: TransformContext<RootNode>;
@@ -27990,19 +28085,25 @@ declare class TransformContext<T extends AllNode = AllNode> {
   block: BlockIRNode;
   options: Required<Omit<TransformOptions$1, "filename" | keyof CompilerCompatOptions>>;
   template: string;
+  templateRoot: boolean;
+  templateIndexMap: Map<string, number>;
   childrenTemplate: (string | null)[];
   dynamic: IRDynamicInfo;
-  imports: ImportItem[export ];
+  imports: ImportItem[];
   inVOnce: boolean;
   inVFor: number;
   comment: CommentNode[];
   component: Set<string>;
   directive: Set<string>;
   slots: IRSlots[];
+  effectIndex: number;
+  operationIndex: number;
   isLastEffectiveChild: boolean;
   isOnRightmostPath: boolean;
-  hasInlineAncestorNeedingClose: boolean;
-  private gloexport balId;
+  isSingleRoot: boolean;
+  templateCloseTags: Set<string> | undefined;
+  templateCloseBlocks: boolean;
+  private globalId;
   private nextIdMap;
   private ifIndex;
   constructor(ir: RootIRNode, node: T, options?: TransformOptions$1);
@@ -28011,94 +28112,153 @@ declare class TransformContext<T extends AllNode = AllNode> {
   private initNextIdMap;
   reference(): number;
   nextIfIndex(): number;
-  pushexport Template(content: string): number;
+  private getTemplateNamespace;
+  private canUseStaticTemplate;
+  pushTemplate(content: string, {
+    root,
+    static: isStatic
+  }?: {
+    root?: boolean;
+    static?: boolean;
+  }): number;
   registerTemplate(): number;
-  registerEffect(expressions: SimpleExpressionNode[], operatioexport n: OperationNode | OperationNode[], getIndex?: () => number): void;
+  registerEffect(expressions: SimpleExpressionNode[], operation: OperationNode | OperationNode[], getIndex?: () => number): void;
   registerOperation(...node: OperationNode[]): void;
-  createexport <T extends TemplateChildNode>(node: T, index: number): TransformContext<T>;
-  private isEffectivelyLastChild;
+  effectBoundary(): {
+    operationIndex: number;
+    effectIndex: number;
+  };
+  create<T extends TemplateChildNode>(node: T, index: number): TransformContext<T>;
+  private shiftEffectBoundaries;
+  private getChildContextInfo;
+  private isSingleRootChild;
 }
-declare function transform(node: RootNode, options?: TransformOptions$1): RootIRNode;
-declare function createStrexport ucturalDirectiveTransform(name: string | string[], fn: StructuralDirectiveTransform): NodeTransform;
+export declare function transform(node: RootNode, options?: TransformOptions$1): RootIRNode;
+export declare function createStructuralDirectiveTransform(name: string | string[], fn: StructuralDirectiveTransform): NodeTransform;
 //#endregion
-//#region temp/packages/compiler-vaexport por/src/generate.d.ts
-type CodegenOptions = Omit<CodegenOptions$1, "optimizeImports">;
-declare classexport  CodegenContext {
+//#region temp/packages/compiler-vapor/src/generate.d.ts
+export type CodegenOptions = Omit<CodegenOptions$1, "optimizeImports">;
+export declare class CodegenContext {
   ir: RootIRNode;
-  options: Requiredexport <CodegenOptions>;
+  options: Required<CodegenOptions>;
   bindingNames: Set<string>;
   helpers: Map<string, string>;
+  needsTemplateRefSetter: boolean;
+  staticTemplateRefHelperCandidate?: SetTemplateRefIRNode;
+  inSlotBlock: boolean;
   helper: (name: CoreHelper | VaporHelper) => string;
-  delegates: export Set<string>;
+  delegates: Set<string>;
+  singleUseAssetComponentNames?: Set<string>;
   identifiers: Record<string, (string | SimpleExpressionNode)[]>;
- export  seenInlineHandlerNames: Record<string, number>;
+  expressionReplacements: Map<SimpleExpressionNode, SimpleExpressionNode>[];
+  withExpressionReplacements<T>(map: Map<SimpleExpressionNode, SimpleExpressionNode>, fn: () => T): T;
+  getExpressionReplacement(node: SimpleExpressionNode): SimpleExpressionNode;
+  seenInlineHandlerNames: Record<string, number>;
   block: BlockIRNode;
-  withId<T>(fn: () => T, map: Record<export string, string | SimpleExpressionNode | null>): T;
-  enterBlock(block: BlockIRNode)export : () => BlockIRNode;
+  withId<T>(fn: () => T, map: Record<string, string | SimpleExpressionNode | null>): T;
+  enterBlock(block: BlockIRNode): () => BlockIRNode;
+  enterSlotBlock(): () => boolean;
   scopeLevel: number;
   enterScope(): [level: number, exit: () => number];
   private templateVars;
   private nextIdMap;
-  private lastIexport dMap;
+  private lastIdMap;
+  private isHelperNameAvailable;
   private lastTIndex;
   private initNextIdMap;
   tName(i: number): string;
   pName(i: number): string;
-  constructor(ir: RootIRNodeexport , options: CodegenOptions);
+  constructor(ir: RootIRNode, options: CodegenOptions);
 }
-interface VaporCodegenResult extends BaseCodegenResult {
+export interface VaporCodegenResult extends BaseCodegenResult {
   ast: RootIRNode;
   helpers: Set<string>;
 }
-declare fexport unction generate(ir: RootIRNode, options?: CodegenOptions): VaporCodegenResult;
+export declare function generate(ir: RootIRNode, options?: CodegenOptions): VaporCodegenResult;
 //#endregion
-//#region temp/packages/compiler-vapor/src/gexport enerators/utils.d.ts
+//#region temp/packages/compiler-vapor/src/generators/utils.d.ts
 declare const NEWLINE: unique symbol;
 /** increase offset but don't push actual code */
-declare constexport  LF: unique symbol;
+declare const LF: unique symbol;
 declare const INDENT_START: unique symbol;
 declare const INDENT_END: unique symbol;
-type FalsyValue = false export | null | undefined;
-type CodeFragment = typeof NEWLINE | typeof LF | typeof INDENT_START | typeof INDENT_END | string | [code:export  string, newlineIndex?: number, loc?: SourceLocation, name?: string] | FalsyValue;
-type CodeFragments = Exclude<CodeFragment, export any[]> | CodeFragment[];
-declare function buildCodeFragment(...frag: CodeFragment[]): [CodeFragment[], (...items: CodeFragmexport ent[]) => number, (...items: CodeFragment[]) => number];
-type CodeFragmentDelimiters = [left: CodeFragments, right: CodeFragmentexport s, delimiter: CodeFragments, placeholder?: CodeFragments];
-declare function genMulti([left, right, seg, placeholder]: CodeFragexport mentDelimiters, ...frags: CodeFragments[]): CodeFragment[];
-declare function genCall(name: string | [name: string, placeexport holder?: CodeFragments], ...frags: CodeFragments[]): CodeFragment[];
-declare function codeFragmentToString(code: CodeFragment[], export context: CodegenContext): [code: string, map: CodegenSourceMapGenerator | undefined];
+type FalsyValue = false | null | undefined;
+export type CodeFragment = typeof NEWLINE | typeof LF | typeof INDENT_START | typeof INDENT_END | string | [code: string, newlineIndex?: number, loc?: SourceLocation, name?: string] | FalsyValue;
+type CodeFragments = Exclude<CodeFragment, any[]> | CodeFragment[];
+export declare function buildCodeFragment(...frag: CodeFragment[]): [CodeFragment[], (...items: CodeFragment[]) => number, (...items: CodeFragment[]) => number];
+type CodeFragmentDelimiters = [left: CodeFragments, right: CodeFragments, delimiter: CodeFragments, placeholder?: CodeFragments];
+export declare function genMulti([left, right, seg, placeholder]: CodeFragmentDelimiters, ...frags: CodeFragments[]): CodeFragment[];
+export declare function genCall(name: string | [name: string, placeholder?: CodeFragments], ...frags: CodeFragments[]): CodeFragment[];
+export declare function codeFragmentToString(code: CodeFragment[], context: CodegenContext): [code: string, map: CodegenSourceMapGenerator | undefined];
+//#endregion
+//#region temp/packages/compiler-vapor/src/transforms/utils.d.ts
+export declare function wrapTemplate(node: ElementNode, dirs: string[]): TemplateNode;
+//#endregion
+//#region temp/packages/compiler-vapor/src/compile.d.ts
+export declare function compile(source: string | RootNode, options?: CompilerOptions): VaporCodegenResult;
+export type CompilerOptions = HackOptions<CompilerOptions$1>;
+export type TransformPreset = [NodeTransform[], Record<string, DirectiveTransform>];
+//#endregion
+//#region temp/packages/compiler-vapor/src/errors.d.ts
+export interface VaporCompilerError extends CompilerError {
+  code: VaporErrorCodes;
+}
+export declare function createVaporCompilerError(code: VaporErrorCodes, loc?: SourceLocation): VaporCompilerError;
+export declare enum VaporErrorCodes {
+  X_V_PLACEHOLDER = 100,
+  __EXTEND_POINT__ = 101
+}
+export declare const VaporErrorMessages: Record<VaporErrorCodes, string>;
+//#endregion
+//#region temp/packages/compiler-vapor/src/transforms/transformElement.d.ts
+export declare const transformElement: NodeTransform;
+//#endregion
+//#region temp/packages/compiler-vapor/src/transforms/transformChildren.d.ts
+export declare const transformChildren: NodeTransform;
+//#endregion
+//#region temp/packages/compiler-vapor/src/transforms/transformTemplateRef.d.ts
+export declare const transformTemplateRef: NodeTransform;
+//#endregion
+//#region temp/packages/compiler-vapor/src/transforms/transformText.d.ts
+export declare const transformText: NodeTransform;
+//#endregion
+//#region temp/packages/compiler-vapor/src/transforms/vBind.d.ts
+export declare const transformVBind: DirectiveTransform;
+//#endregion
+//#region temp/packages/compiler-vapor/src/transforms/vHtml.d.ts
+export declare const transformVHtml: DirectiveTransform;
 //#endregion
-//#region temp/packagesexport /compiler-vapor/src/transforms/utils.d.ts
-declare function wrapTemplate(node: ElementNode, dirs: string[]): TemplateNode;
+//#region temp/packages/compiler-vapor/src/transforms/vOn.d.ts
+export declare const transformVOn: DirectiveTransform;
 //#endregion
-//#reexport gion temp/packages/compiler-vapor/src/compile.d.ts
-declare function compile(source: string | RootNode, options?: CompilerOptions): VaporCodexport egenResult;
-type CompilerOptions = HackOptions<CompilerOptions$1>;
-type TransformPreset = [NodeTransform[], Record<string, Direcexport tiveTransform>];
+//#region temp/packages/compiler-vapor/src/transforms/vOnce.d.ts
+export declare const transformVOnce: NodeTransform;
 //#endregion
-//#region temp/packages/compiler-vapo/compilShow: DirectiveTransform;
+//#region temp/packages/compiler-vapor/src/transforms/vShow.d.ts
+export declare const transformVShow: DirectiveTransform;
 //#endregion
 //#region temp/packages/compiler-vapor/src/transforms/vText.d.ts
-declare const transformVText: DirectiveTransform;
+export declare const transformVText: DirectiveTransform;
 //#endregion
 //#region temp/packages/compiler-vapor/src/transforms/vIf.d.ts
-declare const transformVIf: NodeTransform;
+export declare const transformVIf: NodeTransform;
 //#endregion
 //#region temp/packages/compiler-vapor/src/transforms/vFor.d.ts
-declare const transformVFor: NodeTransform;
+export declare const transformVFor: NodeTransform;
 //#endregion
 //#region temp/packages/compiler-vapor/src/transforms/transformKey.d.ts
-declare const transformKey: NodeTransform;
+export declare const transformKey: NodeTransform;
 //#endregion
 //#region temp/packages/compiler-vapor/src/transforms/vModel.d.ts
-declare const transformVModel: DirectiveTransform;
+export declare const transformVModel: DirectiveTransform;
 //#endregion
 //#region temp/packages/compiler-vapor/src/transforms/transformComment.d.ts
-declare const transformComment: NodeTransform;
+export declare const transformComment: NodeTransform;
 //#endregion
 //#region temp/packages/compiler-vapor/src/transforms/transformSlotOutlet.d.ts
-declare const transformSlotOutlet: NodeTransform;
+export declare const transformSlotOutlet: NodeTransform;
 //#endregion
 //#region temp/packages/compiler-vapor/src/transforms/vSlot.d.ts
-declare const transformVSlot: NodeTransform;
+export declare const transformVSlot: NodeTransform;
 //#endregion
-export { BaseIRNode, BlockIRNode, type CodeFragment, type CodegenContext, type CodegenOptions, type CompilerOptions, CoreHelper, CreateComponentIRNode, DirectiveIRNode, type DirectiveTransform, DynamicFlag, ForIRNode, GetTextChildIRNode, HackOptions, IRDynamicInfo, IRDynamicPropsKind, IREffect, IRFor, IRNode, IRNodeTypes, IRProp, IRProps, IRPropsDynamicAttribute, IRPropsDynamicExpression, IRPropsStatic, IRSlotDynamic, IRSlotDynamicBasic, IRSlotDynamicConditional, IRSlotDynamicLoop, IRSlotType, IRSlots, IRSlotsExpression, IRSlotsStatic, IfIRNode, InsertNodeIRNode, InsertionStateTypes, KeyIRNode, KeyOverride, type NodeTransform, OperationNode, PrependNodeIRNode, RootIRNode, SetDynamicEventsIRNode, SetDynamicPropsIRNode, SetEventIRNode, SetHtmlIRNode, SetPropIRNode, SetTemplateRefIRNode, SetTextIRNode, SlotBlockIRNode, SlotOutletIRNode, type StructuralDirectiveTransform, type TransformContext, type TransformPreset, type VaporCodegenResult, type VaporCompilerError, VaporDirectiveNode, VaporErrorCodes, VaporErrorMessages, VaporHelper, buildCodeFragment, codeFragmentToString, compile, createStructuralDirectiveTransform, createVaporCompilerError, genCall, genMulti, generate, isBlockOperation, parse, transform, transformChildren, transformComment, transformElement, transformKey, transformSlotOutlet, transformTemplateRef, transformText, transformVBind, transformVFor, transformVHtml, transformVIf, transformVModel, transformVOn, transformVOnce, transformVShow, transformVSlot, transformVText, wrapTemplate };
+export { parse,  };