@vue/compat 3.6.0-rc.1 → 3.6.0-rc.10

package/dist/vue-compat.d.ts

@@ -1,30 +1,30 @@
 //#region packages/shared/src/slotFlags.d.ts
 declare enum SlotFlags {
   /**
-  * Stable slots that only reference slot props or context state. The slot
-  * can fully capture its own dependencies so when passed down the parent won't
-  * need to force the child to update.
-  */
+   * Stable slots that only reference slot props or context state. The slot
+   * can fully capture its own dependencies so when passed down the parent won't
+   * need to force the child to update.
+   */
   STABLE = 1,
   /**
-  * Slots that reference scope variables (v-for or an outer slot prop), or
-  * has conditional structure (v-if, v-for). The parent will need to force
-  * the child to update because the slot does not fully capture its dependencies.
-  */
+   * Slots that reference scope variables (v-for or an outer slot prop), or
+   * has conditional structure (v-if, v-for). The parent will need to force
+   * the child to update because the slot does not fully capture its dependencies.
+   */
   DYNAMIC = 2,
   /**
-  * `<slot/>` being forwarded into a child component. Whether the parent needs
-  * to update the child is dependent on what kind of slots the parent itself
-  * received. This has to be refined at runtime, when the child's vnode
-  * is being created (in `normalizeChildren`)
-  */
+   * `<slot/>` being forwarded into a child component. Whether the parent needs
+   * to update the child is dependent on what kind of slots the parent itself
+   * received. This has to be refined at runtime, when the child's vnode
+   * is being created (in `normalizeChildren`)
+   */
   FORWARDED = 3
 }
 //#endregion
 //#region packages/shared/src/typeUtils.d.ts
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
+type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P]; };
 type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
 //#endregion
 //#region packages/reactivity/src/constants.d.ts
@@ -56,25 +56,25 @@ declare class EffectScope implements ReactiveNode {
   subsTail: Link | undefined;
   flags: number;
   /**
-  * @internal
-  */
+   * @internal
+   */
   cleanups: (() => void)[];
   /**
-  * @internal
-  */
+   * @internal
+   */
   cleanupsLength: number;
   constructor(detached?: boolean);
   get active(): boolean;
   pause(): void;
   /**
-  * Resumes the effect scope, including all child scopes and effects.
-  */
+   * Resumes the effect scope, including all child scopes and effects.
+   */
   resume(): void;
   run<T>(fn: () => T): T | undefined;
   stop(): void;
   /**
-  * @internal
-  */
+   * @internal
+   */
   reset(): void;
 }
 //#endregion
@@ -133,12 +133,12 @@ declare class ReactiveEffect<T = any> implements ReactiveEffectOptions, Reactive
   subsTail: Link | undefined;
   flags: number;
   /**
-  * @internal
-  */
+   * @internal
+   */
   cleanups: (() => void)[];
   /**
-  * @internal
-  */
+   * @internal
+   */
   cleanupsLength: number;
   onTrack?: (event: DebuggerEvent) => void;
   onTrigger?: (event: DebuggerEvent) => void;
@@ -161,15 +161,15 @@ interface WritableComputedOptions<T, S = T> {
   set: ComputedSetter<S>;
 }
 /**
-* @private exported by @vue/reactivity for Vue core use, but not exported from
-* the main vue package
-*/
+ * @private exported by @vue/reactivity for Vue core use, but not exported from
+ * the main vue package
+ */
 declare class ComputedRefImpl<T = any> implements ReactiveNode {
   fn: ComputedGetter<T>;
   private readonly setter;
   /**
-  * @internal
-  */
+   * @internal
+   */
   _value: T | undefined;
   subs: Link | undefined;
   subsTail: Link | undefined;
@@ -177,24 +177,24 @@ declare class ComputedRefImpl<T = any> implements ReactiveNode {
   depsTail: Link | undefined;
   flags: ReactiveFlags;
   /**
-  * @internal
-  */
+   * @internal
+   */
   readonly __v_isRef = true;
   /**
-  * @internal
-  */
+   * @internal
+   */
   readonly __v_isReadonly: boolean;
   get effect(): this;
   get dep(): ReactiveNode;
   /**
-  * @internal
-  * for backwards compat
-  */
+   * @internal
+   * for backwards compat
+   */
   get _dirty(): boolean;
   /**
-  * @internal
-  * for backwards compat
-  */
+   * @internal
+   * for backwards compat
+   */
   set _dirty(v: boolean);
   onTrack?: (event: DebuggerEvent) => void;
   onTrigger?: (event: DebuggerEvent) => void;
@@ -212,20 +212,20 @@ interface ReactiveMarker {
 }
 type Reactive<T> = UnwrapNestedRefs<T> & (T extends readonly any[] ? ReactiveMarker : {});
 /**
-* Returns a reactive proxy of the object.
-*
-* The reactive conversion is "deep": it affects all nested properties. A
-* reactive object also deeply unwraps any properties that are refs while
-* maintaining reactivity.
-*
-* @example
-* ```js
-* const obj = reactive({ count: 0 })
-* ```
-*
-* @param target - The source object.
-* @see {@link https://vuejs.org/api/reactivity-core.html#reactive}
-*/
+ * Returns a reactive proxy of the object.
+ *
+ * The reactive conversion is "deep": it affects all nested properties. A
+ * reactive object also deeply unwraps any properties that are refs while
+ * maintaining reactivity.
+ *
+ * @example
+ * ```js
+ * const obj = reactive({ count: 0 })
+ * ```
+ *
+ * @param target - The source object.
+ * @see {@link https://vuejs.org/api/reactivity-core.html#reactive}
+ */
 declare function reactive<T extends object>(target: T): Reactive<T>;
 declare class ShallowReactiveBrandClass {
   private __shallowReactiveBrand?;
@@ -241,10 +241,10 @@ interface Ref<T = any, S = T> {
   get value(): T;
   set value(_: S);
   /**
-  * Type differentiator only.
-  * We need this to be in public d.ts but don't want it to show up in IDE
-  * autocomplete, so we use a private Symbol instead.
-  */
+   * Type differentiator only.
+   * We need this to be in public d.ts but don't want it to show up in IDE
+   * autocomplete, so we use a private Symbol instead.
+   */
   [RefSymbol]: true;
 }
 declare const ShallowRefMarker: unique symbol;
@@ -252,25 +252,25 @@ type ShallowRef<T = any, S = T> = Ref<T, S> & {
   [ShallowRefMarker]?: true;
 };
 /**
-* This is a special exported interface for other packages to declare
-* additional types that should bail out for ref unwrapping. For example
-* \@vue/runtime-dom can declare it like so in its d.ts:
-*
-* ``` ts
-* declare module '@vue/reactivity' {
-*   export interface RefUnwrapBailTypes {
-*     runtimeDOMBailTypes: Node | Window
-*   }
-* }
-* ```
-*/
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module '@vue/reactivity' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ */
 interface RefUnwrapBailTypes {}
-type ShallowUnwrapRef<T> = T extends ShallowReactiveBrand ? 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 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;
+} ? 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
 type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
@@ -287,24 +287,24 @@ declare const SlotSymbol: unique symbol;
 type SlotsType<T extends Record<string, any> = Record<string, any>> = {
   [SlotSymbol]?: T;
 };
-type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{ [K in keyof T]: NonNullable<T[K]> extends ((...args: any[]) => any) ? T[K] : Slot<T[K]> }>>;
+type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{ [K in keyof T]: NonNullable<T[K]> extends ((...args: any[]) => any) ? T[K] : Slot<T[K]>; }>>;
 type RawSlots = {
   [name: string]: unknown;
   $stable?: boolean;
   /**
-  * for tracking slot owner instance. This is attached during
-  * normalizeChildren when the component vnode is created.
-  * @internal
-  */
+   * for tracking slot owner instance. This is attached during
+   * normalizeChildren when the component vnode is created.
+   * @internal
+   */
   _ctx?: ComponentInternalInstance | null;
   /**
-  * indicates compiler generated slots
-  * we use a reserved property instead of a vnode patchFlag because the slots
-  * object may be directly passed down to a child component in a manual
-  * render function, and the optimization hint need to be on the slot object
-  * itself to be preserved.
-  * @internal
-  */
+   * indicates compiler generated slots
+   * we use a reserved property instead of a vnode patchFlag because the slots
+   * object may be directly passed down to a child component in a manual
+   * render function, and the optimization hint need to be on the slot object
+   * itself to be preserved.
+   * @internal
+   */
   _?: SlotFlags;
 };
 //#endregion
@@ -312,34 +312,39 @@ type RawSlots = {
 declare enum SchedulerJobFlags {
   QUEUED = 1,
   /**
-  * Indicates whether the effect is allowed to recursively trigger itself
-  * when managed by the scheduler.
-  *
-  * By default, a job cannot trigger itself because some built-in method calls,
-  * e.g. Array.prototype.push actually performs reads as well (#1740) which
-  * can lead to confusing infinite loops.
-  * The allowed cases are component update functions and watch callbacks.
-  * Component update functions may update child component props, which in turn
-  * trigger flush: "pre" watch callbacks that mutates state that the parent
-  * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
-  * triggers itself again, it's likely intentional and it is the user's
-  * responsibility to perform recursive state mutation that eventually
-  * stabilizes (#1727).
-  */
+   * Indicates whether the effect is allowed to recursively trigger itself
+   * when managed by the scheduler.
+   *
+   * By default, a job cannot trigger itself because some built-in method calls,
+   * e.g. Array.prototype.push actually performs reads as well (#1740) which
+   * can lead to confusing infinite loops.
+   * The allowed cases are component update functions and watch callbacks.
+   * Component update functions may update child component props, which in turn
+   * trigger flush: "pre" watch callbacks that mutates state that the parent
+   * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
+   * triggers itself again, it's likely intentional and it is the user's
+   * responsibility to perform recursive state mutation that eventually
+   * stabilizes (#1727).
+   */
   ALLOW_RECURSE = 2,
-  DISPOSED = 4
+  DISPOSED = 4,
+  /**
+   * Requeue a Suspense effect if its pending branch is discarded.
+   * @internal
+   */
+  REQUEUE_ON_SUSPENSE_DISCARD = 8
 }
 interface SchedulerJob extends Function {
   order?: number;
   /**
-  * flags can technically be undefined, but it can still be used in bitwise
-  * operations just like 0.
-  */
+   * flags can technically be undefined, but it can still be used in bitwise
+   * operations just like 0.
+   */
   flags?: SchedulerJobFlags;
   /**
-  * Attached by renderer.ts when setting up a component's render effect
-  * Used to obtain component information when reporting max recursive updates.
-  */
+   * Attached by renderer.ts when setting up a component's render effect
+   * Used to obtain component information when reporting max recursive updates.
+   */
   i?: GenericComponentInstance;
 }
 declare function nextTick(): Promise<void>;
@@ -347,7 +352,7 @@ declare function nextTick<T, R>(this: T, fn: (this: T) => R | Promise<R>): Promi
 //#endregion
 //#region packages/runtime-core/src/componentProps.d.ts
 type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | string[];
-type ComponentObjectPropsOptions<P = Data> = { [K in keyof P]: Prop<P[K]> | null };
+type ComponentObjectPropsOptions<P = Data> = { [K in keyof P]: Prop<P[K]> | null; };
 type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
 type DefaultFactory<T> = (props: Data) => T | null | undefined;
 interface PropOptions<T = any, D = T> {
@@ -356,12 +361,12 @@ interface PropOptions<T = any, D = T> {
   default?: D | DefaultFactory<D> | null | undefined | object;
   validator?(value: unknown, props: Data): boolean;
   /**
-  * @internal
-  */
+   * @internal
+   */
   skipCheck?: boolean;
   /**
-  * @internal
-  */
+   * @internal
+   */
   skipFactory?: boolean;
 }
 type PropType<T> = PropConstructor<T> | (PropConstructor<T> | null)[];
@@ -370,11 +375,11 @@ type PropConstructor<T = any> = {
 } | {
   (): T;
 } | PropMethod<T>;
-type PropMethod<T, TConstructor = any> = [T] extends [((...args: any) => any) | undefined] ? {
+type PropMethod<T, TConstructor = any> = {
   new (): TConstructor;
   (): T;
   readonly prototype: TConstructor;
-} : never;
+};
 type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
   required: true;
 } | {
@@ -383,7 +388,7 @@ type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
   type: BooleanConstructor;
 } ? T[K] extends {
   default: undefined | (() => undefined);
-} ? never : K : never }[keyof T];
+} ? never : K : never; }[keyof T];
 type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
 type DefaultKeys<T> = { [K in keyof T]: T[K] extends {
   default: any;
@@ -392,7 +397,7 @@ type DefaultKeys<T> = { [K in keyof T]: T[K] extends {
 } ? T[K] extends {
   type: BooleanConstructor;
   required: true;
-} ? never : K : never }[keyof T];
+} ? never : K : never; }[keyof T];
 type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [T] extends [{
   type: null | true;
 }] ? any : [T] extends [ObjectConstructor | {
@@ -403,32 +408,32 @@ type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends
   type: DateConstructor;
 }] ? Date : [T] extends [(infer U)[] | {
   type: (infer U)[];
-}] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? IfAny<V, V, D> : V : V : T;
+}] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? IfAny<V, V, unknown extends D ? V : D> : V : V : T;
 /**
-* Extract prop types from a runtime props options object.
-* The extracted types are **internal** - i.e. the resolved props received by
-* the component.
-* - Boolean props are always present
-* - Props with default values are always present
-*
-* To extract accepted props from the parent, use {@link ExtractPublicPropTypes}.
-*/
+ * Extract prop types from a runtime props options object.
+ * The extracted types are **internal** - i.e. the resolved props received by
+ * the component.
+ * - Boolean props are always present
+ * - Props with default values are always present
+ *
+ * To extract accepted props from the parent, use {@link ExtractPublicPropTypes}.
+ */
 type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: O[K] extends {
   default: any;
-} ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]> } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]> };
+} ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]>; } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>; };
 declare enum BooleanFlags {
   shouldCast = 0,
   shouldCastTrue = 1
 }
-type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]> } : {};
+type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>; } : {};
 type NormalizedProp = PropOptions & {
   [BooleanFlags.shouldCast]?: boolean;
   [BooleanFlags.shouldCastTrue]?: boolean;
 };
 /**
-* normalized value is a tuple of the actual normalized options
-* and an array of prop keys that need value casting (booleans and defaults)
-*/
+ * normalized value is a tuple of the actual normalized options
+ * and an array of prop keys that need value casting (booleans and defaults)
+ */
 type NormalizedProps = Record<string, NormalizedProp>;
 type NormalizedPropsOptions = [NormalizedProps, string[]] | [];
 //#endregion
@@ -438,9 +443,9 @@ type ComponentTypeEmits = ((...args: any[]) => any) | Record<string, any>;
 //#region packages/runtime-core/src/componentEmits.d.ts
 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[] : T[K] extends any[] ? T[K] : never) => any } : {};
-type ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any } : E;
-type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{ [key in Event]: Options[key] extends ((...args: infer Args) => any) ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void }[Event]>;
+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 ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any; } : E;
+type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{ [key in Event]: Options[key] extends ((...args: infer Args) => any) ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void; }[Event]>;
 //#endregion
 //#region packages/runtime-core/src/directives.d.ts
 interface DirectiveBinding<Value = any, Modifiers extends string = string, Arg = any> {
@@ -455,10 +460,10 @@ type DirectiveHook<HostElement = any, Prev = VNode<any, HostElement> | null, Val
 type SSRDirectiveHook<Value = any, Modifiers extends string = string, Arg = any> = (binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode) => Data | undefined;
 interface ObjectDirective<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> {
   /**
-  * @internal without this, ts-expect-error in directives.test-d.ts somehow
-  * fails when running tsc, but passes in IDE and when testing against built
-  * dts. Could be a TS bug.
-  */
+   * @internal without this, ts-expect-error in directives.test-d.ts somehow
+   * fails when running tsc, but passes in IDE and when testing against built
+   * dts. Could be a TS bug.
+   */
   __mod?: Modifiers;
   created?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
   beforeMount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
@@ -476,30 +481,30 @@ type DirectiveModifiers<K extends string = string> = Partial<Record<K, boolean>>
 //#endregion
 //#region packages/runtime-core/src/componentPublicInstance.d.ts
 /**
-* Custom properties added to component instances in any way and can be accessed through `this`
-*
-* @example
-* Here is an example of adding a property `$router` to every component instance:
-* ```ts
-* import { createApp } from 'vue'
-* import { Router, createRouter } from 'vue-router'
-*
-* declare module 'vue' {
-*   interface ComponentCustomProperties {
-*     $router: Router
-*   }
-* }
-*
-* // effectively adding the router to every component instance
-* const app = createApp({})
-* const router = createRouter()
-* app.config.globalProperties.$router = router
-*
-* const vm = app.mount('#app')
-* // we can access the router from the instance
-* vm.$router.push('/')
-* ```
-*/
+ * Custom properties added to component instances in any way and can be accessed through `this`
+ *
+ * @example
+ * Here is an example of adding a property `$router` to every component instance:
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { Router, createRouter } from 'vue-router'
+ *
+ * declare module 'vue' {
+ *   interface ComponentCustomProperties {
+ *     $router: Router
+ *   }
+ * }
+ *
+ * // effectively adding the router to every component instance
+ * const app = createApp({})
+ * const router = createRouter()
+ * app.config.globalProperties.$router = router
+ *
+ * const vm = app.mount('#app')
+ * // we can access the router from the instance
+ * vm.$router.push('/')
+ * ```
+ */
 interface ComponentCustomProperties {}
 type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
 type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any, any, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
@@ -516,12 +521,12 @@ type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props,
   new (...args: any[]): T;
 };
 /**
-* This is the same as `CreateComponentPublicInstance` but adds local components,
-* global directives, exposed, and provide inference.
-* It changes the arguments order so that we don't need to repeat mixin
-* inference everywhere internally, but it has to be a new type to avoid
-* breaking types that relies on previous arguments order (#10842)
-*/
+ * This is the same as `CreateComponentPublicInstance` but adds local components,
+ * global directives, exposed, and provide inference.
+ * It changes the arguments order so that we don't need to repeat mixin
+ * 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> = {}, 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 = any> = {
@@ -566,15 +571,15 @@ interface SuspenseProps {
   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.
-  */
+   * 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
-  *
-  * @default false
-  */
+   * Allow suspense to be captured by parent suspense
+   *
+   * @default false
+   */
   suspensible?: boolean;
 }
 declare const SuspenseImpl: {
@@ -769,23 +774,39 @@ declare function configureCompat(config: CompatConfig): void;
 //#endregion
 //#region packages/runtime-core/src/componentOptions.d.ts
 /**
-* Interface for declaring custom options.
-*
-* @example
-* ```ts
-* declare module 'vue' {
-*   interface ComponentCustomOptions {
-*     beforeRouteUpdate?(
-*       to: Route,
-*       from: Route,
-*       next: () => void
-*     ): void
-*   }
-* }
-* ```
-*/
+ * Interface for declaring custom options.
+ *
+ * @example
+ * ```ts
+ * declare module 'vue' {
+ *   interface ComponentCustomOptions {
+ *     beforeRouteUpdate?(
+ *       to: Route,
+ *       from: Route,
+ *       next: () => void
+ *     ): void
+ *   }
+ * }
+ * ```
+ */
 interface ComponentCustomOptions {}
-type RenderFunction = () => VNodeChild;
+/**
+ * Registry for additional render result types.
+ *
+ * @example
+ * ```ts
+ * import type { VaporRenderResult } from 'vue'
+ *
+ * declare module 'vue' {
+ *   interface RenderResultExtensions {
+ *     vapor: VaporRenderResult
+ *   }
+ * }
+ * ```
+ */
+interface RenderResultExtensions {}
+type RenderResult = VNodeChild | RenderResultExtensions[keyof RenderResultExtensions] | RenderResult[];
+type RenderFunction = () => RenderResult;
 interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II, Provide>, ComponentInternalOptions, AsyncComponentInternalOptions, ComponentCustomOptions {
   setup?: (this: void, props: LooseRequired<Props & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, "P">>>, ctx: SetupContext<E, S>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
   name?: string;
@@ -800,16 +821,16 @@ interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions,
   serverPrefetch?(): void | Promise<any>;
   compilerOptions?: RuntimeCompilerOptions;
   /**
-  * SSR only. This is produced by compiler-ssr and attached in compiler-sfc
-  * not user facing, so the typing is lax and for test only.
-  * @internal
-  */
+   * SSR only. This is produced by compiler-ssr and attached in compiler-sfc
+   * not user facing, so the typing is lax and for test only.
+   * @internal
+   */
   ssrRender?: (ctx: any, push: (item: any) => void, parentInstance: ComponentInternalInstance, attrs: Data | undefined, $props: ComponentInternalInstance["props"], $setup: ComponentInternalInstance["setupState"], $data: ComponentInternalInstance["data"], $options: ComponentInternalInstance["ctx"]) => void;
   /**
-  * Only generated by compiler-sfc to mark a ssr render function inlined and
-  * returned from setup()
-  * @internal
-  */
+   * Only generated by compiler-sfc to mark a ssr render function inlined and
+   * returned from setup()
+   * @internal
+   */
   __ssrInlineRender?: boolean;
   call?: (this: unknown, ...args: unknown[]) => never;
   __isFragment?: never;
@@ -818,8 +839,8 @@ interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions,
   __defaults?: Defaults;
 }
 /**
-* Subset of compiler options that makes sense for the runtime.
-*/
+ * Subset of compiler options that makes sense for the runtime.
+ */
 interface RuntimeCompilerOptions {
   isCustomElement?: (tag: string) => boolean;
   whitespace?: "preserve" | "condense";
@@ -834,7 +855,7 @@ interface MethodOptions {
 }
 type ExtractComputedReturns<T extends any> = { [key in keyof T]: T[key] extends {
   get: (...args: any[]) => infer TReturn;
-} ? TReturn : T[key] extends ((...args: any[]) => infer TReturn) ? TReturn : never };
+} ? TReturn : T[key] extends ((...args: any[]) => infer TReturn) ? TReturn : never; };
 type ObjectWatchOptionItem = {
   handler: WatchCallback | string;
 } & WatchOptions;
@@ -848,7 +869,7 @@ type ObjectInjectOptions = Record<string | symbol, string | symbol | {
   from?: string | symbol;
   default?: unknown;
 }>;
-type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? { [K in T[number]]?: unknown } : T extends ObjectInjectOptions ? { [K in keyof T]?: unknown } : never;
+type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? { [K in T[number]]?: unknown; } : T extends ObjectInjectOptions ? { [K in keyof T]?: unknown; } : never;
 interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string, Provide extends ComponentProvideOptions = ComponentProvideOptions> {
   compatConfig?: CompatConfig;
   [key: string]: any;
@@ -879,18 +900,18 @@ interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOpt
   renderTriggered?: DebuggerHook;
   errorCaptured?: ErrorCapturedHook;
   /**
-  * runtime compile only
-  * @deprecated use `compilerOptions.delimiters` instead.
-  */
+   * runtime compile only
+   * @deprecated use `compilerOptions.delimiters` instead.
+   */
   delimiters?: [string, string];
   /**
-  * #3468
-  *
-  * type-only, used to assist Mixin's type inference,
-  * TypeScript will try to simplify the inferred `Mixin` type,
-  * with the `__differentiator`, TypeScript won't be able to combine different mixins,
-  * because the `__differentiator` will be different
-  */
+   * #3468
+   *
+   * type-only, used to assist Mixin's type inference,
+   * TypeScript will try to simplify the inferred `Mixin` type,
+   * with the `__differentiator`, TypeScript won't be able to combine different mixins,
+   * because the `__differentiator` will be different
+   */
   __differentiator?: keyof D | keyof C | keyof M;
 }
 type MergedHook<T = () => void> = T | T[];
@@ -903,9 +924,11 @@ type MergedComponentOptionsOverride = {
   beforeUpdate?: MergedHook;
   updated?: MergedHook;
   activated?: MergedHook;
-  deactivated?: MergedHook; /** @deprecated use `beforeUnmount` instead */
+  deactivated?: MergedHook;
+  /** @deprecated use `beforeUnmount` instead */
   beforeDestroy?: MergedHook;
-  beforeUnmount?: MergedHook; /** @deprecated use `unmounted` instead */
+  beforeUnmount?: MergedHook;
+  /** @deprecated use `unmounted` instead */
   destroyed?: MergedHook;
   unmounted?: MergedHook;
   renderTracked?: MergedHook<DebuggerHook>;
@@ -948,11 +971,11 @@ interface App<HostElement = any> {
   onUnmount(cb: () => void): void;
   provide<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): this;
   /**
-  * Runs a function with the app as active instance. This allows using of `inject()` within the function to get access
-  * to variables provided via `app.provide()`.
-  *
-  * @param fn - function to run with the app as active instance
-  */
+   * Runs a function with the app as active instance. This allows using of `inject()` within the function to get access
+   * to variables provided via `app.provide()`.
+   *
+   * @param fn - function to run with the app as active instance
+   */
   runWithContext<T>(fn: () => T): T;
   _uid: number;
   _component: GenericComponent;
@@ -961,40 +984,40 @@ interface App<HostElement = any> {
   _context: AppContext;
   _instance: GenericComponentInstance | null;
   /**
-  * @internal custom element vnode
-  */
+   * @internal custom element vnode
+   */
   _ceVNode?: VNode;
   /**
-  * @internal vapor custom element instance
-  */
+   * @internal vapor custom element instance
+   */
   _ceComponent?: GenericComponentInstance | null;
   /**
-  * v2 compat only
-  */
+   * v2 compat only
+   */
   filter?(name: string): Function | undefined;
   filter?(name: string, filter: Function): this;
   /**
-  * @internal v3 compat only
-  */
+   * @internal v3 compat only
+   */
   _createRoot?(options: ComponentOptions): ComponentPublicInstance;
 }
 type OptionMergeFunction = (to: unknown, from: unknown) => any;
 /**
-* Shared app config between vdom and vapor
-*/
+ * Shared app config between vdom and vapor
+ */
 interface GenericAppConfig {
   performance?: boolean;
   errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void;
   warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void;
   /**
-  * Whether to throw unhandled errors in production.
-  * Default is `false` to avoid crashing on any error (and only logs it)
-  * But in some cases, e.g. SSR, throwing might be more desirable.
-  */
+   * Whether to throw unhandled errors in production.
+   * Default is `false` to avoid crashing on any error (and only logs it)
+   * But in some cases, e.g. SSR, throwing might be more desirable.
+   */
   throwUnhandledErrorInProduction?: boolean;
   /**
-  * Prefix for all useId() calls within this app
-  */
+   * Prefix for all useId() calls within this app
+   */
   idPrefix?: string;
 }
 interface AppConfig extends GenericAppConfig {
@@ -1002,37 +1025,62 @@ interface AppConfig extends GenericAppConfig {
   optionMergeStrategies: Record<string, OptionMergeFunction>;
   globalProperties: ComponentCustomProperties & Record<string, any>;
   /**
-  * Options to pass to `@vue/compiler-dom`.
-  * Only supported in runtime compiler build.
-  */
+   * Options to pass to `@vue/compiler-dom`.
+   * Only supported in runtime compiler build.
+   */
   compilerOptions: RuntimeCompilerOptions;
   /**
-  * @deprecated use config.compilerOptions.isCustomElement
-  */
+   * @deprecated use config.compilerOptions.isCustomElement
+   */
   isCustomElement?: (tag: string) => boolean;
 }
 /**
-* 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, 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, 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;
+ * The vapor in vdom implementation is in runtime-vapor/src/vdomInterop.ts
+ */
+interface VaporInVdomInterface {
+  mount(vnode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null): GenericComponentInstance;
+  update(n1: VNode, n2: VNode, shouldUpdate: boolean): void;
+  unmount(vnode: VNode, doRemove: boolean | undefined, parentSuspense: SuspenseBoundary | null): void;
+  move(vnode: VNode, container: RendererElement, anchor: RendererNode | null, moveType: MoveType, parentSuspense: SuspenseBoundary | null): void;
+  slot(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null): void;
+  hydrate(vnode: VNode, node: Node, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null): Node | null;
+  hydrateSlot(vnode: VNode, node: Node, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null): Node | null;
+  activate(vnode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance, parentSuspense: SuspenseBoundary | null): void;
+  deactivate(vnode: VNode, container: RendererElement, parentSuspense: SuspenseBoundary | null): void;
   setTransitionHooks(component: ComponentInternalInstance, transition: TransitionHooks): void;
-  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, once?: boolean, slotRoot?: boolean) => any;
-  vdomMountVNode: (vnode: VNode, parentComponent: any) => any;
+  applyCssVars(vnode: VNode, vars: Record<string, string>): void;
+  /**
+   * Hands the fallback of a vdom outlet over to the vapor slot its content
+   * consists of, if it is that one slot.
+   */
+  attachSlotOutlet(content: VNodeArrayChildren, fallback: () => VNodeArrayChildren, owner: ComponentInternalInstance | null): boolean;
+  /**
+   * Hydrates an outlet marked `vo` whose fallback the server rendered in place
+   * of the whole content (`<!--(-->`).
+   */
+  hydrateSlotOutlet(outlet: VNode, open: Comment, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null): Node | null;
 }
 /**
-* Minimal app context shared between vdom and vapor
-*/
+ * Options for rendering a VDOM slot inside vapor. `flags` carries the
+ * outlet's VaporSlotFlags describing its position in the fallback chain;
+ * see renderVDOMSlot.
+ */
+interface VdomSlotOptions {
+  fallback?: (...args: any[]) => any;
+  flags?: number;
+  adoptAnchor?: Node;
+}
+/**
+ * The vdom in vapor implementation is in runtime-vapor/src/vdomInterop.ts
+ */
+interface VdomInVaporInterface {
+  mount: (component: ConcreteComponent, parentComponent: any, props?: any, slots?: any, once?: boolean, inputScope?: EffectScope) => any;
+  slot: (slots: any, name: string | (() => string), props: Record<string, any>, parentComponent: any, options?: VdomSlotOptions) => any;
+  mountVNode: (vnode: VNode, parentComponent: any, isSingleRoot?: boolean, rawProps?: any, once?: boolean) => any;
+}
+/**
+ * Minimal app context shared between vdom and vapor
+ */
 interface GenericAppContext {
   app: App;
   config: GenericAppConfig;
@@ -1040,14 +1088,18 @@ interface GenericAppContext {
   components?: Record<string, Component>;
   directives?: Record<string, Directive>;
   /**
-  * HMR only
-  * @internal
-  */
+   * HMR only
+   * @internal
+   */
   reload?: () => void;
   /**
-  * @internal vapor interop only
-  */
-  vapor?: VaporInteropInterface;
+   * @internal vapor interop only
+   */
+  vapor?: VaporInVdomInterface;
+  /**
+   * @internal vdom interop only
+   */
+  vdom?: VdomInVaporInterface;
 }
 interface AppContext extends GenericAppContext {
   config: AppConfig;
@@ -1055,26 +1107,26 @@ interface AppContext extends GenericAppContext {
   directives: Record<string, Directive>;
   mixins: ComponentOptions[];
   /**
-  * Cache for merged/normalized component options
-  * Each app instance has its own cache because app-level global mixins and
-  * optionMergeStrategies can affect merge behavior.
-  * @internal
-  */
+   * Cache for merged/normalized component options
+   * Each app instance has its own cache because app-level global mixins and
+   * optionMergeStrategies can affect merge behavior.
+   * @internal
+   */
   optionsCache: WeakMap<ComponentOptions, MergedComponentOptions>;
   /**
-  * Cache for normalized props options
-  * @internal
-  */
+   * Cache for normalized props options
+   * @internal
+   */
   propsCache: WeakMap<ConcreteComponent, NormalizedPropsOptions>;
   /**
-  * Cache for normalized emits options
-  * @internal
-  */
+   * Cache for normalized emits options
+   * @internal
+   */
   emitsCache: WeakMap<ConcreteComponent, ObjectEmitsOptions | null>;
   /**
-  * v2 compat only
-  * @internal
-  */
+   * v2 compat only
+   * @internal
+   */
   filters?: Record<string, Function>;
 }
 type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
@@ -1082,7 +1134,7 @@ type ObjectPlugin<Options = any[]> = {
   install: PluginInstallFunction<Options>;
 };
 type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
-type Plugin<Options = any[], P extends unknown[] = (Options extends unknown[] ? Options : [Options])> = FunctionPlugin<P> | ObjectPlugin<P>;
+type Plugin<Options = any[], P extends unknown[] = Options extends unknown[] ? Options : [Options]> = FunctionPlugin<P> | ObjectPlugin<P>;
 //#endregion
 //#region packages/runtime-core/src/components/Teleport.d.ts
 type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
@@ -1095,12 +1147,7 @@ declare const TeleportImpl: {
   name: string;
   __isTeleport: boolean;
   process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
-  remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, {
-    um: unmount,
-    o: {
-      remove: hostRemove
-    }
-  }: RendererInternals, doRemove: boolean): void;
+  remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, { um: unmount, o: { remove: hostRemove } }: RendererInternals, doRemove: boolean): void;
   move: typeof moveTeleport;
   hydrate: typeof hydrateTeleport;
 };
@@ -1109,21 +1156,8 @@ declare enum TeleportMoveTypes {
   TOGGLE = 1,
   REORDER = 2
 }
-declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, {
-  o: {
-    insert
-  },
-  m: move
-}: RendererInternals, parentComponent: ComponentInternalInstance | null, moveType?: TeleportMoveTypes): void;
-declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, {
-  o: {
-    nextSibling,
-    parentNode,
-    querySelector,
-    insert,
-    createText
-  }
-}: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, { o: { insert }, m: move }: RendererInternals, parentComponent: ComponentInternalInstance | null, moveType?: TeleportMoveTypes): void;
+declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, { o: { nextSibling, parentNode, querySelector, insert, createText } }: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
 declare const Teleport: {
   __isTeleport: true;
   new (): {
@@ -1142,27 +1176,27 @@ declare const Fragment: {
   };
 };
 declare const Text: unique symbol;
-declare const Comment: unique symbol;
+declare const Comment$1: unique symbol;
 declare const Static: unique symbol;
 declare const VaporSlot: unique symbol;
-type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl | typeof VaporSlot;
+type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment$1 | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl | typeof VaporSlot;
 type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
 type VNodeNormalizedRefAtom = {
   /**
-  * component instance
-  */
+   * component instance
+   */
   i: ComponentInternalInstance;
   /**
-  * Actual ref
-  */
+   * Actual ref
+   */
   r: VNodeRef;
   /**
-  * setup ref key
-  */
+   * setup ref key
+   */
   k?: string;
   /**
-  * refInFor marker
-  */
+   * refInFor marker
+   */
   f?: boolean;
 };
 type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
@@ -1184,34 +1218,52 @@ type VNodeChildAtom = VNode | string | number | boolean | null | undefined | voi
 type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
 type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
 type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
+/**
+ * A vdom outlet rendering a vapor slot, recorded on the slot's vnode: the
+ * outlet that produced the vnode first, then every enclosing outlet whose
+ * content is only that slot. Interop resolves their fallbacks in turn once
+ * the slot renders empty. Internal to vapor interop.
+ */
+interface VdomSlotOutlet {
+  fallback: () => VNodeArrayChildren;
+  owner: ComponentInternalInstance | null;
+  innerIds?: number;
+}
 interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraProps = {
   [key: string]: any;
 }> {
   /**
-  * @internal
-  */
+   * @internal
+   */
   __v_isVNode: true;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [ReactiveFlags$1.SKIP]: true;
   type: VNodeTypes;
   props: (VNodeProps & ExtraProps) | null;
   key: PropertyKey | null;
   ref: VNodeNormalizedRef | null;
   /**
-  * SFC only. This is assigned on vnode creation using currentScopeId
-  * which is set alongside currentRenderingInstance.
-  */
+   * SFC only. This is assigned on vnode creation using currentScopeId
+   * which is set alongside currentRenderingInstance.
+   */
   scopeId: string | null;
   /**
-  * SFC only. This is assigned to:
-  * - Slot fragment vnodes with :slotted SFC styles.
-  * - Component vnodes (during patch/hydration) so that its root node can
-  *   inherit the component's slotScopeIds
-  * @internal
-  */
+   * SFC only. This is assigned to:
+   * - Slot fragment vnodes with :slotted SFC styles.
+   * - Component vnodes (during patch/hydration) so that its root node can
+   *   inherit the component's slotScopeIds
+   * @internal
+   */
   slotScopeIds: string[] | null;
+  /**
+   * Root-only scope ids published by the vapor interop onto vnodes serving
+   * as a vapor component's effective root; consumed by getInheritedScopeIds
+   * where the effective-root chain tops out (before insertion).
+   * @internal
+   */
+  vaporScopeIds?: string[];
   children: VNodeNormalizedChildren;
   component: ComponentInternalInstance | null;
   dirs: DirectiveBinding[] | null;
@@ -1223,115 +1275,132 @@ interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraPro
   targetStart: HostNode | null;
   targetAnchor: HostNode | null;
   /**
-  * number of elements contained in a static vnode
-  * @internal
-  */
+   * number of elements contained in a static vnode
+   * @internal
+   */
   staticCount: number;
   suspense: SuspenseBoundary | null;
   /**
-  * @internal
-  */
+   * @internal
+   */
   ssContent: VNode | null;
   /**
-  * @internal
-  */
+   * @internal
+   */
   ssFallback: VNode | null;
   shapeFlag: number;
   patchFlag: number;
   /**
-  * @internal
-  */
+   * @internal
+   */
   dynamicProps: string[] | null;
   /**
-  * @internal
-  */
+   * @internal
+   */
   dynamicChildren: (VNode[] & {
     hasOnce?: boolean;
   }) | null;
   appContext: AppContext | null;
   /**
-  * @internal lexical scope owner instance
-  */
+   * @internal lexical scope owner instance
+   */
   ctx: ComponentInternalInstance | null;
   /**
-  * @internal attached by v-memo
-  */
+   * @internal attached by v-memo
+   */
   memo?: any[];
   /**
-  * @internal index for cleaning v-memo cache
-  */
+   * @internal index for cleaning v-memo cache
+   */
   cacheIndex?: number;
   /**
-  * @internal __COMPAT__ only
-  */
+   * @internal __COMPAT__ only
+   */
   isCompatRoot?: true;
   /**
-  * @internal custom element interception hook
-  */
+   * @internal custom element interception hook
+   */
   ce?: (instance: ComponentInternalInstance) => void;
   /**
-  * @internal VDOM in Vapor interop hook
-  */
+   * @internal VDOM in Vapor interop hook
+   */
   vi?: (instance: ComponentInternalInstance) => void;
   /**
-  * @internal Vapor slot in VDOM metadata
-  */
+   * @internal Vapor slot in VDOM metadata
+   */
   vs?: {
     slot: (props: any) => any;
-    fallback: (() => VNodeArrayChildren) | undefined;
-    outletFallback?: (() => VNodeArrayChildren) | undefined;
+    outlets?: readonly VdomSlotOutlet[];
     state?: unknown;
     ref?: ShallowRef<any>;
     scope?: EffectScope;
   };
   /**
-  * @internal Vapor slot Block
-  */
+   * @internal Vapor slot Block
+   */
   vb?: any;
+  /**
+   * @internal vapor interop only — the fragment of a vdom slot outlet whose
+   * fallback a forwarded vapor slot resolves
+   */
+  vo?: boolean;
+  /**
+   * @internal vapor interop only — internal before-update notification, fired
+   * before this vnode is patched (alongside onVnodeBeforeUpdate). Single-owner:
+   * the interop layer assigns (never appends) so re-tracking replaces the
+   * previous callback.
+   */
+  ibu?: () => void;
+  /**
+   * @internal vapor interop only — internal updated notification, fired after
+   * this vnode is patched (alongside onVnodeUpdated) so the interop layer can
+   * refresh its snapshot of the DOM range. Single-owner; see `ibu`.
+   */
+  iu?: () => void;
 }
 //#endregion
 //#region packages/runtime-core/src/component.d.ts
 type Data = Record<string, unknown>;
 /**
-* For extending allowed non-declared attrs on components in TSX
-*/
+ * For extending allowed non-declared attrs on components in TSX
+ */
 interface AllowedAttrs {}
 type Attrs = Data & AllowedAttrs;
 /**
-* For extending allowed non-declared props on components in TSX
-*/
+ * For extending allowed non-declared props on components in TSX
+ */
 interface ComponentCustomProps {}
 /**
-* For globally defined Directives
-* Here is an example of adding a directive `VTooltip` as global directive:
-*
-* @example
-* ```ts
-* import VTooltip from 'v-tooltip'
-*
-* declare module '@vue/runtime-core' {
-*   interface GlobalDirectives {
-*     VTooltip
-*   }
-* }
-* ```
-*/
+ * For globally defined Directives
+ * Here is an example of adding a directive `VTooltip` as global directive:
+ *
+ * @example
+ * ```ts
+ * import VTooltip from 'v-tooltip'
+ *
+ * declare module '@vue/runtime-core' {
+ *   interface GlobalDirectives {
+ *     VTooltip
+ *   }
+ * }
+ * ```
+ */
 interface GlobalDirectives {}
 /**
-* For globally defined Components
-* Here is an example of adding a component `RouterView` as global component:
-*
-* @example
-* ```ts
-* import { RouterView } from 'vue-router'
-*
-* declare module '@vue/runtime-core' {
-*   interface GlobalComponents {
-*     RouterView
-*   }
-* }
-* ```
-*/
+ * For globally defined Components
+ * Here is an example of adding a component `RouterView` as global component:
+ *
+ * @example
+ * ```ts
+ * import { RouterView } from 'vue-router'
+ *
+ * declare module '@vue/runtime-core' {
+ *   interface GlobalComponents {
+ *     RouterView
+ *   }
+ * }
+ * ```
+ */
 interface GlobalComponents {
   Teleport: DefineComponent<TeleportProps>;
   Suspense: DefineComponent<SuspenseProps>;
@@ -1339,65 +1408,65 @@ interface GlobalComponents {
   BaseTransition: DefineComponent<BaseTransitionProps>;
 }
 /**
-* Default allowed non-declared props on component in TSX
-*/
+ * Default allowed non-declared props on component in TSX
+ */
 interface AllowedComponentProps {
   class?: unknown;
   style?: unknown;
 }
 interface ComponentInternalOptions {
   /**
-  * indicates vapor component
-  */
+   * indicates vapor component
+   */
   __vapor?: boolean;
   /**
-  * whether this vapor component has multiple root nodes
-  */
+   * whether this vapor component has multiple root nodes
+   */
   __multiRoot?: boolean;
   /**
-  * indicates keep-alive component
-  */
+   * indicates keep-alive component
+   */
   __isKeepAlive?: boolean;
   /**
-  * @internal
-  */
+   * @internal
+   */
   __scopeId?: string;
   /**
-  * @internal
-  */
+   * @internal
+   */
   __cssModules?: Data;
   /**
-  * @internal
-  */
+   * @internal
+   */
   __hmrId?: string;
   /**
-  * Compat build only, for bailing out of certain compatibility behavior
-  */
+   * Compat build only, for bailing out of certain compatibility behavior
+   */
   __isBuiltIn?: boolean;
   /**
-  * This one should be exposed so that devtools can make use of it
-  */
+   * This one should be exposed so that devtools can make use of it
+   */
   __file?: string;
   /**
-  * name inferred from filename
-  */
+   * name inferred from filename
+   */
   __name?: string;
 }
 interface AsyncComponentInternalOptions<R = ConcreteComponent, I = ComponentInternalInstance> {
   /**
-  * marker for AsyncComponentWrapper
-  * @internal
-  */
+   * marker for AsyncComponentWrapper
+   * @internal
+   */
   __asyncLoader?: () => Promise<R>;
   /**
-  * the inner component resolved by the AsyncComponentWrapper
-  * @internal
-  */
+   * the inner component resolved by the AsyncComponentWrapper
+   * @internal
+   */
   __asyncResolved?: R;
   /**
-  * Exposed for lazy hydration
-  * @internal
-  */
+   * Exposed for lazy hydration
+   * @internal
+   */
   __asyncHydrate?: (el: Element, instance: I, hydrate: () => void) => void;
 }
 interface FunctionalComponent<P = {}, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any, EE extends EmitsOptions = ShortEmitsToObject<E>> extends ComponentInternalOptions {
@@ -1410,24 +1479,24 @@ interface FunctionalComponent<P = {}, E extends EmitsOptions | Record<string, an
   compatConfig?: CompatConfig;
 }
 /**
-* Type used where a function accepts both vdom and vapor components.
-*/
+ * Type used where a function accepts both vdom and vapor components.
+ */
 type GenericComponent = ({
   name?: string;
 } | ((() => any) & {
   displayName?: string;
 })) & ComponentInternalOptions;
 /**
-* Concrete component type matches its actual value: it's either an options
-* object, or a function. Use this where the code expects to work with actual
-* values, e.g. checking if its a function or not. This is mostly for internal
-* implementation code.
-*/
+ * Concrete component type matches its actual value: it's either an options
+ * object, or a function. Use this where the code expects to work with actual
+ * values, e.g. checking if its a function or not. This is mostly for internal
+ * implementation code.
+ */
 type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, E, S>;
 /**
-* A type used in public APIs where a component type is expected.
-* The constructor type is an artificial type returned by defineComponent().
-*/
+ * A type used in public APIs where a component type is expected.
+ * The constructor type is an artificial type returned by defineComponent().
+ */
 type Component<PropsOrInstance = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<PropsOrInstance, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<PropsOrInstance>;
 type LifecycleHook<TFn = Function> = (TFn & SchedulerJob)[] | null;
 type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
@@ -1437,8 +1506,8 @@ type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ?
   expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
 } : never;
 /**
-* @internal
-*/
+ * @internal
+ */
 type InternalRenderFunction = {
   (ctx: ComponentPublicInstance, cache: ComponentInternalInstance["renderCache"], $props: ComponentInternalInstance["props"], $setup: ComponentInternalInstance["setupState"], $data: ComponentInternalInstance["data"], $options: ComponentInternalInstance["ctx"]): VNodeChild;
   _rc?: boolean;
@@ -1446,10 +1515,10 @@ type InternalRenderFunction = {
   _compatWrapped?: boolean;
 };
 /**
-* Base component instance interface that is shared between vdom mode and vapor
-* mode, so that we can have a mixed instance tree and reuse core logic that
-* operate on both.
-*/
+ * Base component instance interface that is shared between vdom mode and vapor
+ * mode, so that we can have a mixed instance tree and reuse core logic that
+ * operate on both.
+ */
 interface GenericComponentInstance {
   vapor?: boolean;
   uid: number;
@@ -1458,202 +1527,197 @@ interface GenericComponentInstance {
   parent: GenericComponentInstance | null;
   appContext: GenericAppContext;
   /**
-  * Object containing values this component provides for its descendants
-  * @internal
-  */
+   * Object containing values this component provides for its descendants
+   * @internal
+   */
   provides: Data;
   /**
-  * Tracking reactive effects (e.g. watchers) associated with this component
-  * so that they can be automatically stopped on component unmount
-  * @internal
-  */
+   * Tracking reactive effects (e.g. watchers) associated with this component
+   * so that they can be automatically stopped on component unmount
+   * @internal
+   */
   scope: EffectScope;
   /**
-  * render function will have different types between vdom and vapor
-  */
+   * render function will have different types between vdom and vapor
+   */
   render?: Function | null;
   /**
-  * SSR render function
-  * (they are the same between vdom and vapor components.)
-  * @internal
-  */
+   * SSR render function
+   * (they are the same between vdom and vapor components.)
+   * @internal
+   */
   ssrRender?: Function | null;
   props: Data;
   attrs: Data;
   refs: Data;
   emit: EmitFn;
   /**
-  * used for keeping track of .once event handlers on components
-  * @internal
-  */
+   * used for keeping track of .once event handlers on components
+   * @internal
+   */
   emitted: Record<string, boolean> | null;
   /**
-  * used for caching the value returned from props default factory functions to
-  * avoid unnecessary watcher trigger
-  * @internal
-  */
+   * used for caching the value returned from props default factory functions to
+   * avoid unnecessary watcher trigger
+   * @internal
+   */
   propsDefaults: Data | null;
   /**
-  * used for getting the keys of a component's raw props, vapor only
-  * @internal
-  */
+   * used for getting the keys of a component's raw props, vapor only
+   * @internal
+   */
   rawKeys?: () => string[];
   exposed: Record<string, any> | null;
   exposeProxy: Record<string, any> | null;
   /**
-  * setup related
-  * @internal
-  */
+   * setup related
+   * @internal
+   */
   setupState?: Data;
   /**
-  * devtools access to additional info
-  * @internal
-  */
+   * devtools access to additional info
+   * @internal
+   */
   devtoolsRawSetupState?: any;
   isMounted: boolean;
   isUnmounted: boolean;
   isDeactivated: boolean;
   /**
-  * for tracking useId()
-  * first element is the current boundary prefix
-  * second number is the index of the useId call within that boundary
-  * @internal
-  */
+   * for tracking useId()
+   * first element is the current boundary prefix
+   * second number is the index of the useId call within that boundary
+   * @internal
+   */
   ids: [string, number, number];
   /**
-  * resolved props options
-  * @internal
-  */
+   * resolved props options
+   * @internal
+   */
   propsOptions?: NormalizedPropsOptions;
   /**
-  * resolved emits options
-  * @internal
-  */
+   * resolved emits options
+   * @internal
+   */
   emitsOptions?: ObjectEmitsOptions | null;
   /**
-  * Public instance proxy, vdom only
-  */
+   * Public instance proxy, vdom only
+   */
   proxy?: any;
   /**
-  * suspense related
-  * @internal
-  */
+   * suspense related
+   * @internal
+   */
   suspense: SuspenseBoundary | null;
   /**
-  * suspense pending batch id
-  * @internal
-  */
+   * suspense pending batch id
+   * @internal
+   */
   suspenseId: number;
   /**
-  * @internal
-  */
+   * @internal
+   */
   asyncDep: Promise<any> | null;
   /**
-  * @internal
-  */
+   * @internal
+   */
   asyncResolved: boolean;
   /**
-  * restore renderer-specific async context after `withAsyncContext()`
-  * @internal
-  */
-  restoreAsyncContext?: () => void | (() => void);
-  /**
-  * `updateTeleportCssVars`
-  * For updating css vars on contained teleports
-  * @internal
-  */
+   * `updateTeleportCssVars`
+   * For updating css vars on contained teleports
+   * @internal
+   */
   ut?: (vars?: Record<string, string>) => void;
   /**
-  * dev only. For style v-bind hydration mismatch checks
-  * @internal
-  */
+   * dev only. For style v-bind hydration mismatch checks
+   * @internal
+   */
   getCssVars?: () => Record<string, string>;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.BEFORE_CREATE]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.CREATED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.BEFORE_MOUNT]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.MOUNTED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.BEFORE_UPDATE]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.UPDATED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.BEFORE_UNMOUNT]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.UNMOUNTED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.RENDER_TRACKED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.RENDER_TRIGGERED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.ACTIVATED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.DEACTIVATED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.ERROR_CAPTURED]?: LifecycleHook;
   /**
-  * @internal
-  */
+   * @internal
+   */
   [LifecycleHooks.SERVER_PREFETCH]?: LifecycleHook<() => Promise<unknown>>;
   /**
-  * @internal vapor only
-  */
+   * @internal vapor only
+   */
   hmrRerender?: () => void;
   /**
-  * @internal vapor only
-  */
+   * @internal vapor only
+   */
   hmrReload?: (newComp: any) => void;
   vnode?: VNode;
   subTree?: VNode;
   /**
-  * Custom Element instance (if component is created by defineCustomElement)
-  * @internal
-  */
+   * Custom Element instance (if component is created by defineCustomElement)
+   * @internal
+   */
   ce?: ComponentCustomElementInterface;
   /**
-  * is custom element? (kept only for compatibility)
-  * @internal
-  */
+   * is custom element? (kept only for compatibility)
+   * @internal
+   */
   isCE?: boolean;
   /**
-  * custom element specific HMR method
-  * @internal
-  */
+   * custom element specific HMR method
+   * @internal
+   */
   ceReload?: (newStyles?: string[]) => void;
 }
 /**
-* We expose a subset of properties on the internal instance as they are
-* useful for advanced external libraries and tools.
-*/
+ * We expose a subset of properties on the internal instance as they are
+ * useful for advanced external libraries and tools.
+ */
 interface ComponentInternalInstance extends GenericComponentInstance {
   vapor?: never;
   uid: number;
@@ -1662,84 +1726,84 @@ interface ComponentInternalInstance extends GenericComponentInstance {
   root: GenericComponentInstance;
   appContext: AppContext;
   /**
-  * Vnode representing this component in its parent's vdom tree
-  */
+   * Vnode representing this component in its parent's vdom tree
+   */
   vnode: VNode;
   /**
-  * The pending new vnode from parent updates
-  * @internal
-  */
+   * The pending new vnode from parent updates
+   * @internal
+   */
   next: VNode | null;
   /**
-  * Root vnode of this component's own vdom tree
-  */
+   * Root vnode of this component's own vdom tree
+   */
   subTree: VNode;
   /**
-  * Render effect instance
-  */
+   * Render effect instance
+   */
   effect: ReactiveEffect;
   /**
-  * Force update render effect
-  */
+   * Force update render effect
+   */
   update: () => void;
   /**
-  * Render effect job to be passed to scheduler (checks if dirty)
-  */
+   * Render effect job to be passed to scheduler (checks if dirty)
+   */
   job: SchedulerJob;
   /**
-  * The render function that returns vdom tree.
-  * @internal
-  */
+   * The render function that returns vdom tree.
+   * @internal
+   */
   render: InternalRenderFunction | null;
   /**
-  * cache for proxy access type to avoid hasOwnProperty calls
-  * @internal
-  */
+   * cache for proxy access type to avoid hasOwnProperty calls
+   * @internal
+   */
   accessCache: Data | null;
   /**
-  * cache for render function values that rely on _ctx but won't need updates
-  * after initialized (e.g. inline handlers)
-  * @internal
-  */
+   * cache for render function values that rely on _ctx but won't need updates
+   * after initialized (e.g. inline handlers)
+   * @internal
+   */
   renderCache: (Function | VNode | undefined)[];
   /**
-  * Resolved component registry, only for components with mixins or extends
-  * @internal
-  */
+   * Resolved component registry, only for components with mixins or extends
+   * @internal
+   */
   components: Record<string, ConcreteComponent> | null;
   /**
-  * Resolved directive registry, only for components with mixins or extends
-  * @internal
-  */
+   * Resolved directive registry, only for components with mixins or extends
+   * @internal
+   */
   directives: Record<string, Directive> | null;
   /**
-  * Resolved filters registry, v2 compat only
-  * @internal
-  */
+   * Resolved filters registry, v2 compat only
+   * @internal
+   */
   filters?: Record<string, Function>;
   /**
-  * resolved props options
-  * @internal
-  */
+   * resolved props options
+   * @internal
+   */
   propsOptions: NormalizedPropsOptions;
   /**
-  * resolved emits options
-  * @internal
-  */
+   * resolved emits options
+   * @internal
+   */
   emitsOptions: ObjectEmitsOptions | null;
   /**
-  * resolved inheritAttrs options
-  * @internal
-  */
+   * resolved inheritAttrs options
+   * @internal
+   */
   inheritAttrs?: boolean;
   /**
-  * setup related
-  * @internal
-  */
+   * setup related
+   * @internal
+   */
   setupState: Data;
   /**
-  * @internal
-  */
+   * @internal
+   */
   setupContext?: SetupContext | null;
   proxy: ComponentPublicInstance | null;
   data: Data;
@@ -1747,79 +1811,79 @@ interface ComponentInternalInstance extends GenericComponentInstance {
   slots: InternalSlots;
   exposeProxy: Record<string, any> | null;
   /**
-  * alternative proxy used only for runtime-compiled render functions using
-  * `with` block
-  * @internal
-  */
+   * alternative proxy used only for runtime-compiled render functions using
+   * `with` block
+   * @internal
+   */
   withProxy: ComponentPublicInstance | null;
   /**
-  * This is the target for the public instance proxy. It also holds properties
-  * injected by user options (computed, methods etc.) and user-attached
-  * custom properties (via `this.x = ...`)
-  * @internal
-  */
+   * This is the target for the public instance proxy. It also holds properties
+   * injected by user options (computed, methods etc.) and user-attached
+   * custom properties (via `this.x = ...`)
+   * @internal
+   */
   ctx: Data;
   /**
-  * suspense pending batch id
-  * @internal
-  */
+   * suspense pending batch id
+   * @internal
+   */
   suspenseId: number;
   /**
-  * @internal
-  */
+   * @internal
+   */
   asyncDep: Promise<any> | null;
   /**
-  * @internal
-  */
+   * @internal
+   */
   asyncResolved: boolean;
   /**
-  * For caching bound $forceUpdate on public proxy access
-  * @internal
-  */
+   * For caching bound $forceUpdate on public proxy access
+   * @internal
+   */
   f?: () => void;
   /**
-  * For caching bound $nextTick on public proxy access
-  * @internal
-  */
+   * For caching bound $nextTick on public proxy access
+   * @internal
+   */
   n?: () => Promise<void>;
   /**
-  * v2 compat only, for caching mutated $options
-  * @internal
-  */
+   * v2 compat only, for caching mutated $options
+   * @internal
+   */
   resolvedOptions?: MergedComponentOptions;
 }
 interface ComponentCustomElementInterface {
   /**
-  * @internal
-  */
+   * @internal
+   */
   _isVueCE: boolean;
   /**
-  * @internal
-  */
+   * @internal
+   */
   _injectChildStyle(type: ConcreteComponent, parent?: ConcreteComponent): void;
   /**
-  * @internal
-  */
+   * @internal
+   */
   _removeChildStyle(type: ConcreteComponent): void;
   /**
-  * @internal
-  */
+   * @internal
+   */
   _setProp(key: string, val: any, shouldReflect?: boolean, shouldUpdate?: boolean): void;
   /**
-  * @internal
-  */
+   * @internal
+   */
   _beginPatch(): void;
   /**
-  * @internal
-  */
+   * @internal
+   */
   _endPatch(): void;
   /**
-  * @internal attached by the nested Teleport when shadowRoot is false.
-  */
+   * @internal attached by the nested Teleport when shadowRoot is false.
+   */
   _teleportTargets?: Set<RendererElement>;
   /**
-  * @internal check if shadow root is enabled
-  */
+   * @internal check if shadow root is enabled
+   */
   _hasShadowRoot(): boolean;
 }
 //#endregion
@@ -1836,28 +1900,28 @@ interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
 //#region packages/runtime-core/src/compat/globalConfig.d.ts
 type LegacyConfig = {
   /**
-  * @deprecated `config.silent` option has been removed
-  */
+   * @deprecated `config.silent` option has been removed
+   */
   silent?: boolean;
   /**
-  * @deprecated use __VUE_PROD_DEVTOOLS__ compile-time feature flag instead
-  * https://github.com/vuejs/core/tree/main/packages/vue#bundler-build-feature-flags
-  */
+   * @deprecated use __VUE_PROD_DEVTOOLS__ compile-time feature flag instead
+   * https://github.com/vuejs/core/tree/main/packages/vue#bundler-build-feature-flags
+   */
   devtools?: boolean;
   /**
-  * @deprecated use `config.isCustomElement` instead
-  * https://v3-migration.vuejs.org/breaking-changes/global-api.html#config-ignoredelements-is-now-config-iscustomelement
-  */
+   * @deprecated use `config.isCustomElement` instead
+   * https://v3-migration.vuejs.org/breaking-changes/global-api.html#config-ignoredelements-is-now-config-iscustomelement
+   */
   ignoredElements?: (string | RegExp)[];
   /**
-  * @deprecated
-  * https://v3-migration.vuejs.org/breaking-changes/keycode-modifiers.html
-  */
+   * @deprecated
+   * https://v3-migration.vuejs.org/breaking-changes/keycode-modifiers.html
+   */
   keyCodes?: Record<string, number | number[]>;
   /**
-  * @deprecated
-  * https://v3-migration.vuejs.org/breaking-changes/global-api.html#config-productiontip-removed
-  */
+   * @deprecated
+   * https://v3-migration.vuejs.org/breaking-changes/global-api.html#config-productiontip-removed
+   */
   productionTip?: boolean;
 };
 //#endregion
@@ -1878,10 +1942,10 @@ interface LegacyPublicProperties {
 //#endregion
 //#region packages/runtime-core/src/compat/global.d.ts
 /**
-* @deprecated the default `Vue` export has been removed in Vue 3. The type for
-* the default export is provided only for migration purposes. Please use
-* named imports instead - e.g. `import { createApp } from 'vue'`.
-*/
+ * @deprecated the default `Vue` export has been removed in Vue 3. The type for
+ * the default export is provided only for migration purposes. Please use
+ * named imports instead - e.g. `import { createApp } from 'vue'`.
+ */
 type CompatVue = Pick<App, "version" | "component" | "directive"> & {
   configureCompat: typeof configureCompat;
   new (options?: ComponentOptions): LegacyPublicInstance;
@@ -1897,40 +1961,40 @@ type CompatVue = Pick<App, "version" | "component" | "directive"> & {
   directive<T = any, V = any>(name: string, directive: Directive<T, V>): CompatVue;
   compile(template: string): RenderFunction;
   /**
-  * @deprecated Vue 3 no longer supports extending constructors.
-  */
+   * @deprecated Vue 3 no longer supports extending constructors.
+   */
   extend: (options?: ComponentOptions) => CompatVue;
   /**
-  * @deprecated Vue 3 no longer needs set() for adding new properties.
-  */
+   * @deprecated Vue 3 no longer needs set() for adding new properties.
+   */
   set(target: any, key: PropertyKey, value: any): void;
   /**
-  * @deprecated Vue 3 no longer needs delete() for property deletions.
-  */
+   * @deprecated Vue 3 no longer needs delete() for property deletions.
+   */
   delete(target: any, key: PropertyKey): void;
   /**
-  * @deprecated use `reactive` instead.
-  */
+   * @deprecated use `reactive` instead.
+   */
   observable: typeof reactive;
   /**
-  * @deprecated filters have been removed from Vue 3.
-  */
+   * @deprecated filters have been removed from Vue 3.
+   */
   filter(name: string, arg?: any): null;
   /**
-  * @internal
-  */
+   * @internal
+   */
   cid: number;
   /**
-  * @internal
-  */
+   * @internal
+   */
   options: ComponentOptions;
   /**
-  * @internal
-  */
+   * @internal
+   */
   util: any;
   /**
-  * @internal
-  */
+   * @internal
+   */
   super: CompatVue;
 };
 //#endregion
@@ -1989,21 +2053,17 @@ type SystemModifiers = (typeof systemModifiers)[number];
 type CompatModifiers = keyof typeof keyNames;
 type VOnModifiers = SystemModifiers | ModifierGuards | CompatModifiers;
 type ModifierGuards = "shift" | "ctrl" | "alt" | "meta" | "left" | "right" | "stop" | "prevent" | "self" | "middle" | "exact";
-/**
-* @private
-*/
 declare const keyNames: Record<"esc" | "space" | "up" | "left" | "right" | "down" | "delete", string>;
-/**
-* @private
-*/
 type VOnDirective = Directive<any, any, VOnModifiers>;
 //#endregion
 //#region packages/runtime-dom/src/directives/vModel.d.ts
 type AssignerFn = (value: any) => void;
 declare const assignKey: unique symbol;
+declare const initialValueKey: unique symbol;
 type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<T & {
   [assignKey]: AssignerFn;
-  _assigning?: boolean;
+  [initialValueKey]?: string;
+  _pendingValue?: [multiple: boolean, value: any];
 }, any, Modifiers>;
 declare const vModelText: ModelDirective<HTMLInputElement | HTMLTextAreaElement, "trim" | "number" | "lazy">;
 declare const vModelCheckbox: ModelDirective<HTMLInputElement>;
@@ -22186,13 +22246,13 @@ declare namespace DataType {
 //#region packages/runtime-dom/src/jsx.d.ts
 interface CSSProperties extends Properties<string | number>, PropertiesHyphen<string | number> {
   /**
-  * The index signature was removed to enable closed typing for style
-  * using CSSType. You're able to use type assertion or module augmentation
-  * to add properties or an index signature of your own.
-  *
-  * For examples and more information, visit:
-  * https://github.com/frenic/csstype#what-should-i-do-when-i-get-type-errors
-  */
+   * The index signature was removed to enable closed typing for style
+   * using CSSType. You're able to use type assertion or module augmentation
+   * to add properties or an index signature of your own.
+   *
+   * For examples and more information, visit:
+   * https://github.com/frenic/csstype#what-should-i-do-when-i-get-type-errors
+   */
   [v: `--${string}`]: string | number | undefined;
 }
 type StyleValue = false | null | undefined | string | CSSProperties | Array<StyleValue>;
@@ -22200,10 +22260,10 @@ type ClassValue = false | null | undefined | string | Record<string, any> | Arra
 //#endregion
 //#region packages/runtime-dom/src/index.d.ts
 /**
-* This is a stub implementation to prevent the need to use dom types.
-*
-* To enable proper types, add `"dom"` to `"lib"` in your `tsconfig.json`.
-*/
+ * This is a stub implementation to prevent the need to use dom types.
+ *
+ * To enable proper types, add `"dom"` to `"lib"` in your `tsconfig.json`.
+ */
 type DomType<T> = typeof globalThis extends {
   window: unknown;
 } ? T : never;