@qwik.dev/core 2.0.0-beta.11 → 2.0.0-beta.14

package/dist/core-internal.d.ts

@@ -3,6 +3,7 @@ import * as CSS_2 from 'csstype';
 import { isBrowser } from './build';
 import { isDev } from './build';
 import { isServer } from './build';
+import { JSXNode as JSXNode_2 } from './types/jsx-node';
 import { QRL as QRL_2 } from './qrl.public';
 
 /**
@@ -81,22 +82,19 @@ import { QRL as QRL_2 } from './qrl.public';
  */
 export declare const $: <T>(expression: T) => QRL<T>;
 
+declare interface AddRootFn {
+    (obj: unknown, returnRef?: never): number;
+    (obj: unknown, returnRef: true): SeenRef;
+}
+
 declare type AllEventKeys = keyof AllEventsMap;
 
-declare type AllEventMapRaw = HTMLElementEventMap & DocumentEventMap & WindowEventHandlersEventMap & {
-    qidle: QwikIdleEvent;
-    qinit: QwikInitEvent;
-    qsymbol: QwikSymbolEvent;
-    qvisible: QwikVisibleEvent;
-    qviewtransition: QwikViewTransitionEvent;
-};
+declare type AllEventMapRaw = QwikHTMLElementEventMap & QwikDocumentEventMap & QwikWindowEventMap;
 
 declare type AllEventsMap = Omit<AllEventMapRaw, keyof EventCorrectionMap> & EventCorrectionMap;
 
 declare type _AllowPlainQrl<Q> = QRLEventHandlerMulti<any, any> extends Q ? Q extends QRLEventHandlerMulti<infer EV, infer EL> ? Q | (EL extends Element ? EventHandler<EV, EL> : never) : Q : Q extends QRL<infer U> ? Q | U : NonNullable<Q> extends never ? Q : QRL<Q> | Q;
 
-declare type AllPascalEventMaps = PascalMap<AllEventsMap>;
-
 declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags;
 
 /**
@@ -369,6 +367,8 @@ export declare interface AsyncComputedReadonlySignal<T = unknown> extends Comput
     loading: boolean;
     /** The error that occurred while computing the signal. */
     error: Error | null;
+    /** A promise that resolves when the value is computed. */
+    promise(): Promise<T>;
 }
 
 /** @public */
@@ -381,13 +381,14 @@ export declare type AsyncComputedReturnType<T> = T extends Promise<infer T> ? As
  *
  * # ================================
  */
-declare class AsyncComputedSignalImpl<T> extends ComputedSignalImpl<T, AsyncComputeQRL<T>> implements BackRef {
+declare class AsyncComputedSignalImpl<T> extends ComputedSignalImpl<T | undefined, AsyncComputeQRL<T>> implements BackRef {
     $untrackedLoading$: boolean;
     $untrackedError$: Error | null;
     $loadingEffects$: null | Set<EffectSubscription>;
     $errorEffects$: null | Set<EffectSubscription>;
     $destroy$: NoSerialize<() => void> | null;
-    private $promiseValue$;
+    $promiseValue$: T | typeof NEEDS_COMPUTATION;
+    private $promise$;
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
     constructor(container: Container | null, fn: AsyncComputeQRL<T>, flags?: SignalFlags | SerializationSignalFlags);
     /**
@@ -402,7 +403,10 @@ declare class AsyncComputedSignalImpl<T> extends ComputedSignalImpl<T, AsyncComp
     set untrackedError(value: Error | null);
     get untrackedError(): Error | null;
     invalidate(): void;
-    $computeIfNeeded$(): boolean | undefined;
+    promise(): Promise<T>;
+    $computeIfNeeded$(): Promise<void> | undefined;
+    private $promiseComputation$;
+    private setValue;
 }
 
 declare type AsyncComputeQRL<T> = QRLInternal<AsyncComputedFn<T>>;
@@ -433,6 +437,13 @@ declare type BivariantQrlFn<ARGS extends any[], RETURN> = {
 /** @public */
 declare type Booleanish = boolean | `${boolean}`;
 
+/**
+ * Handles events for bind:checked
+ *
+ * @internal
+ */
+export declare const _chk: (_: any, element: HTMLInputElement) => void;
+
 declare interface Chore<T extends ChoreType = ChoreType> {
     $type$: T;
     $idx$: number | string;
@@ -440,7 +451,7 @@ declare interface Chore<T extends ChoreType = ChoreType> {
     $target$: ChoreTarget | null;
     $payload$: unknown;
     $state$: ChoreState;
-    $blockedChores$: Chore[] | null;
+    $blockedChores$: ChoreArray | null;
     $startTime$: number | undefined;
     $endTime$: number | undefined;
     $resolve$: ((value: any) => void) | undefined;
@@ -989,7 +1000,6 @@ export declare interface CSSProperties extends CSS_2.Properties<string | number>
     [v: `--${string}`]: string | number | undefined;
 }
 
-/** @public */
 declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
     $flags$: number;
     $index$: number;
@@ -1015,7 +1025,6 @@ declare interface DeserializeContainer {
     $state$?: unknown[];
     $storeProxyMap$: ObjToProxyMap;
     $forwardRefs$: Array<number> | null;
-    $initialQRLs$: Array<string> | null;
     readonly $scheduler$: Scheduler | null;
 }
 
@@ -1049,7 +1058,6 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     $qFuncs$: Array<(...args: unknown[]) => unknown>;
     $instanceHash$: string;
     $forwardRefs$: Array<number> | null;
-    $initialQRLs$: Array<string> | null;
     vNodeLocate: (id: string | Element) => _VNode;
     private $stateData$;
     private $styleIds$;
@@ -1068,24 +1076,6 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     $appendStyle$(content: string, styleId: string, host: _VirtualVNode, scoped: boolean): void;
     /** Set the server data for the Qwik Router. */
     private $setServerData$;
-    /**
-     * Schedule the initial QRLs to be resolved.
-     *
-     * Schedules the QRLs that are defined in the state data as `PreloadQRL`.
-     *
-     * This is done because when computed and custom serializer QRLs are called they need QRL to work.
-     * If the QRL is not resolved at this point, it will be resolved by throwing a promise and
-     * rerunning the whole wrapping function again. We want to avoid that, because it means that the
-     * function can execute twice.
-     *
-     * ```ts
-     * useVisibleTask$(() => {
-     *   runHeavyLogic(); // This will be called again if the QRL of `computedOrCustomSerializer` is not resolved.
-     *   console.log(computedOrCustomSerializer.value); // Throw a promise if QRL not resolved and execute visible task again.
-     * });
-     * ```
-     */
-    private $scheduleInitialQRLs$;
 }
 export { DomContainer }
 export { DomContainer as _DomContainer }
@@ -1155,9 +1145,9 @@ _SubscriptionData | null
 export declare class _ElementVNode extends _VNode {
     firstChild: _VNode | null | undefined;
     lastChild: _VNode | null | undefined;
-    element: Element;
+    element: QElement;
     elementName: string | undefined;
-    constructor(flags: _VNodeFlags, parent: _ElementVNode | _VirtualVNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, firstChild: _VNode | null | undefined, lastChild: _VNode | null | undefined, element: Element, elementName: string | undefined);
+    constructor(flags: _VNodeFlags, parent: _ElementVNode | _VirtualVNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, firstChild: _VNode | null | undefined, lastChild: _VNode | null | undefined, element: QElement, elementName: string | undefined);
 }
 
 /** @internal */
@@ -1176,11 +1166,10 @@ export declare const event$: <T>(qrl: T) => QRL_2<T>;
 
 declare type EventCorrectionMap = {
     auxclick: PointerEvent;
-    beforetoggle: CorrectedToggleEvent;
     click: PointerEvent;
     dblclick: PointerEvent;
     input: InputEvent;
-    toggle: CorrectedToggleEvent;
+    qvisible: QwikVisibleEvent;
 };
 
 declare type EventFromName<T extends string> = LcEvent<T>;
@@ -1235,8 +1224,8 @@ export declare type FunctionComponent<P = unknown> = {
     renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput;
 }['renderFn'];
 
-/** @internal */
-export declare const _getConstProps: <T, JSX>(props: PropsProxy | Record<string, unknown> | null | undefined) => Props | null;
+/** Used by the optimizer for spread props operations @internal */
+export declare const _getConstProps: (props: PropsProxy | Record<string, unknown> | null | undefined) => Props | null;
 
 /** @internal */
 export declare const _getContextContainer: () => ClientContainer | undefined;
@@ -1279,8 +1268,8 @@ export declare const getPlatform: () => CorePlatform;
 /** @internal */
 export declare function _getQContainerElement(element: Element | _VNode): Element | null;
 
-/** @internal */
-export declare const _getVarProps: <T, JSX>(props: PropsProxy | Record<string, unknown> | null | undefined) => Props | null;
+/** Used by the optimizer for spread props operations @internal */
+export declare const _getVarProps: (props: PropsProxy | Record<string, unknown> | null | undefined) => Props | null;
 
 /** @public */
 declare interface GlobalInjections {
@@ -1292,10 +1281,8 @@ declare interface GlobalInjections {
 }
 
 /**
- * The legacy transform, used in special cases like `<div {...props} key="key" />`. Note that the
- * children are spread arguments, instead of a prop like in jsx() calls.
- *
- * Also note that this disables optimizations.
+ * The legacy transform, used by some JSX transpilers. The optimizer normally replaces this with
+ * optimized calls, with the same caveat as `jsx()`.
  *
  * @public
  */
@@ -1431,8 +1418,16 @@ export declare const _IMMUTABLE: unique symbol;
  */
 export declare const implicit$FirstArg: <FIRST, REST extends any[], RET>(fn: (qrl: QRL<FIRST>, ...rest: REST) => RET) => ((qrl: FIRST, ...rest: REST) => RET);
 
-/** @internal */
-export declare const inlinedQrl: <T>(symbol: T, symbolName: string, lexicalScopeCapture?: any[]) => QRL<T>;
+/**
+ * Create an inlined QRL. This is mostly useful on the server side for serialization.
+ *
+ * @param symbol - The object/function to register, or `null` to retrieve a previously registered
+ *   one by hash
+ * @param symbolName - The name of the symbol.
+ * @param lexicalScopeCapture - A set of lexically scoped variables to capture.
+ * @public
+ */
+export declare const inlinedQrl: <T>(symbol: T | null, symbolName: string, lexicalScopeCapture?: any[]) => QRL<T>;
 
 /** @internal */
 export declare const inlinedQrlDEV: <T = any>(symbol: T, symbolName: string, opts: QRLDev, lexicalScopeCapture?: any[]) => QRL<T>;
@@ -1468,8 +1463,6 @@ declare type IntrinsicSVGElements = {
 /** The shared state during an invoke() call */
 declare interface InvokeContext {
     $url$: URL | undefined;
-    /** The next available index for the sequentialScope array */
-    $i$: number;
     /** The Virtual parent component for the current component code */
     $hostElement$: HostElement | undefined;
     /** The current DOM element */
@@ -1543,25 +1536,33 @@ export declare function _isStringifiable(value: unknown): value is _Stringifiabl
 export declare const _isTask: (value: any) => value is Task;
 
 /**
+ * Used by the JSX transpilers to create a JSXNode. Note that the optimizer will normally not use
+ * this, instead using _jsxSplit and _jsxSorted directly.
+ *
+ * The optimizer will also replace all `jsx()` calls with the more optimized versions.
+ *
+ * The exception is when the props are not a literal object, which can only happen when the `jsx`
+ * call is written directly.
+ *
  * @public
- * Used by the JSX transpilers to create a JSXNode.
- * Note that the optimizer will not use this, instead using _jsxSplit and _jsxSorted directly.
  */
-declare const jsx: <T extends string | FunctionComponent<any>>(type: T, props: T extends FunctionComponent<infer PROPS> ? PROPS : Props, key?: string | number | null) => JSXNode<T>;
-export { jsx }
-export { jsx as jsxs }
+export declare const jsx: <T extends string | FunctionComponent<any>>(type: T, props: T extends FunctionComponent<infer PROPS> ? PROPS : Props, key?: string | number | null, _isStatic?: boolean, dev?: JsxDevOpts) => JSXNode<T>;
 
 /** @internal */
 export declare const _jsxBranch: <T>(input?: T) => T | undefined;
 
 /** @internal @deprecated v1 compat */
-export declare const _jsxC: (type: any, mutable: any, _flags: any, key: any) => JSXNode<any>;
+export declare const _jsxC: (type: any, mutable: any, _flags: any, key: any) => JSXNode_2<any>;
 
 /** @public */
 export declare type JSXChildren = string | number | boolean | null | undefined | Function | RegExp | JSXChildren[] | Promise<JSXChildren> | Signal<JSXChildren> | JSXNode;
 
-/** @public */
-export declare const jsxDEV: <T extends string | FunctionComponent<Props>>(type: T, props: T extends FunctionComponent<infer PROPS> ? PROPS : Props, key: string | number | null | undefined, _isStatic: boolean, opts: JsxDevOpts, _ctx: unknown) => JSXNode<T>;
+/**
+ * Alias of `jsx` for development purposes.
+ *
+ * @public
+ */
+export declare const jsxDEV: <T extends string | FunctionComponent<any>>(type: T, props: T extends FunctionComponent<infer PROPS> ? PROPS : Props, key?: string | number | null, _isStatic?: boolean, dev?: JsxDevOpts) => JSXNode<T>;
 
 declare interface JsxDevOpts {
     fileName: string;
@@ -1569,6 +1570,14 @@ declare interface JsxDevOpts {
     columnNumber: number;
 }
 
+declare type JSXDocumentEvents = {
+    [K in keyof QwikDocumentEventMap as `document:on${PascalCaseName<K>}$`]: QwikDocumentEventMap[K];
+};
+
+declare type JSXElementEvents = {
+    [K in keyof QwikHTMLElementEventMap as `on${PascalCaseName<K>}$`]: QwikHTMLElementEventMap[K];
+};
+
 /**
  * A JSX Node, an internal structure. You probably want to use `JSXOutput` instead.
  *
@@ -1588,9 +1597,38 @@ export declare interface JSXNode<T extends string | FunctionComponent | unknown
  * @internal
  */
 export declare interface JSXNodeInternal<T extends string | FunctionComponent | unknown = unknown> extends JSXNode<T> {
-    varProps: Record<any, unknown>;
-    constProps: Record<any, unknown> | null;
-    flags: number;
+    /** The type of node */
+    type: T;
+    /** Do the varProps need sorting */
+    toSort: boolean;
+    /** The key property */
+    key: string | null;
+    /**
+     * Props that are not guaranteed shallow equal across runs.
+     *
+     * Any prop that is in `constProps` takes precedence over `varProps`.
+     *
+     * Does not contain `children` or `key`.
+     *
+     * `onEvent$` props are normalized to the html `on:event` version
+     */
+    varProps: Props;
+    /**
+     * Props that will be shallow equal across runs. Does not contain any props that are in varProps.
+     *
+     * Any prop that is in `constProps` takes precedence over `varProps`.
+     *
+     * Does not contain `children` or `key`.
+     *
+     * `onEvent$` props are normalized to the html `on:event` version
+     */
+    constProps: Props | null;
+    /** The children of the node */
+    children: JSXChildren;
+    /** Filename etc for debugging */
+    dev?: DevJSX & {
+        stack: string | undefined;
+    };
 }
 
 /**
@@ -1601,10 +1639,17 @@ export declare interface JSXNodeInternal<T extends string | FunctionComponent |
 export declare type JSXOutput = JSXNode | string | number | boolean | null | undefined | JSXOutput[];
 
 /** @internal @deprecated v1 compat */
-export declare const _jsxQ: (type: any, mutable: any, immutable: any, children: any, _flags: any, key: any) => JSXNode<any>;
+export declare const _jsxQ: (type: any, mutable: any, immutable: any, children: any, _flags: any, key: any) => JSXNode_2<any>;
 
 /** @internal @deprecated v1 compat */
-export declare const _jsxS: (type: any, mutable: any, immutable: any, _flags: any, key: any) => JSXNode<any>;
+export declare const _jsxS: (type: any, mutable: any, immutable: any, _flags: any, key: any) => JSXNode_2<any>;
+
+/**
+ * Alias of `jsx` to support JSX syntax.
+ *
+ * @public
+ */
+export declare const jsxs: <T extends string | FunctionComponent<any>>(type: T, props: T extends FunctionComponent<infer PROPS> ? PROPS : Props, key?: string | number | null, _isStatic?: boolean, dev?: JsxDevOpts) => JSXNode<T>;
 
 /**
  * Create a JSXNode with the properties fully split into variable and constant parts, and children
@@ -1616,7 +1661,7 @@ export declare const _jsxS: (type: any, mutable: any, immutable: any, _flags: an
  * still update the attribute on the vnode.
  *
  * @param type - The JSX type
- * @param varProps - The properties of the tag, sorted, excluding children, excluding any constProps
+ * @param varProps - The properties of the tag, sorted, excluding children, key and any constProps
  * @param constProps - The properties of the tag that are known to be constant references and don't
  *   need checking for changes on re-render
  * @param children - JSX children. Any `children` in the props objects are ignored.
@@ -1626,13 +1671,13 @@ export declare const _jsxSorted: <T>(type: T, varProps: Props | null, constProps
 
 /**
  * Create a JSXNode, with the properties split into variable and constant parts, but the variable
- * parts could include keys from constProps, as well as `key` and `children`.
+ * parts could include keys from `constProps`, as well as `key` and `children`.
  *
- * The constant parts are expected to be the same on every render, and are not checked for changes.
- * This means that they are constant scalars or refs. When the ref is a signal or a store, it can
- * still update the attribute on the vnode.
+ * `constProps` cannot include `key` or `children`. The constant parts are expected to be the same
+ * on every render, and are not checked for changes. This means that they are constant scalars or
+ * refs. When the ref is a signal or a store, it can still update the attribute on the vnode.
  *
- * If `children` is defined, any `children` in the props will be ignored.
+ * If `children` or `key` are defined, any `children`/`key` in the props will be ignored.
  *
  * @param type - The tag type
  * @param varProps - The properties of the tag that could change, including children
@@ -1640,11 +1685,15 @@ export declare const _jsxSorted: <T>(type: T, varProps: Props | null, constProps
  *   for changes on re-render
  * @internal
  */
-export declare const _jsxSplit: <T extends string | FunctionComponent<any>>(type: T, varProps: Props | null, constProps: Props | null, children: JSXChildren | null | undefined, flags: number, key: string | number | null, dev?: DevJSX) => JSXNodeInternal<T>;
+export declare const _jsxSplit: <T extends string | FunctionComponent<any>>(type: T, varProps: Props | null, constProps: Props | null, children: JSXChildren | null | undefined, flags: number, key?: string | number | null, dev?: DevJSX) => JSXNodeInternal<T>;
 
 /** @public */
 export declare type JSXTagName = keyof HTMLElementTagNameMap | Omit<string, keyof HTMLElementTagNameMap>;
 
+declare type JSXWindowEvents = {
+    [K in keyof QwikWindowEventMap as `window:on${PascalCaseName<K>}$`]: QwikWindowEventMap[K];
+};
+
 /**
  * The names of events that Qwik knows about. They are all lowercase, but on the JSX side, they are
  * PascalCase for nicer DX. (`onAuxClick$` vs `onauxclick$`)
@@ -1745,6 +1794,12 @@ export declare type NativeUIEvent = UIEvent;
 /** @public @deprecated Use `WheelEvent` and use the second argument to the handler function for the current event target */
 export declare type NativeWheelEvent = WheelEvent;
 
+/**
+ * Special value used to mark that a given signal needs to be computed. This is essentially a
+ * "marked as dirty" flag.
+ */
+declare const NEEDS_COMPUTATION: any;
+
 declare interface NodePropData {
     $scopedStyleIdPrefix$: string | null;
     $isConst$: boolean;
@@ -1821,6 +1876,11 @@ export declare interface OnVisibleTaskOptions {
     strategy?: VisibleTaskStrategy;
 }
 
+/** @internal */
+declare const _OWNER: unique symbol;
+
+declare type PascalCaseName<T extends string> = T extends keyof LcEventNameMap ? LcEventNameMap[T] : Capitalize<T>;
+
 /**
  * Capitalized multi-word names of some known events so we have nicer qwik attributes. For example,
  * instead of `oncompositionEnd$` we can use `onCompositionEnd$`. Note that any capitalization
@@ -1828,15 +1888,7 @@ export declare interface OnVisibleTaskOptions {
  *
  * Add any multi-word event names to this list. Single word events are automatically converted.
  */
-declare type PascalCaseNames = 'AnimationEnd' | 'AnimationIteration' | 'AnimationStart' | 'AuxClick' | 'BeforeToggle' | 'CanPlay' | 'CanPlayThrough' | 'CompositionEnd' | 'CompositionStart' | 'CompositionUpdate' | 'ContextMenu' | 'DblClick' | 'DragEnd' | 'DragEnter' | 'DragExit' | 'DragLeave' | 'DragOver' | 'DragStart' | 'DurationChange' | 'FocusIn' | 'FocusOut' | 'FullscreenChange' | 'FullscreenError' | 'GotPointerCapture' | 'KeyDown' | 'KeyPress' | 'KeyUp' | 'LoadedData' | 'LoadedMetadata' | 'LoadEnd' | 'LoadStart' | 'LostPointerCapture' | 'MouseDown' | 'MouseEnter' | 'MouseLeave' | 'MouseMove' | 'MouseOut' | 'MouseOver' | 'MouseUp' | 'PointerCancel' | 'PointerDown' | 'PointerEnter' | 'PointerLeave' | 'PointerMove' | 'PointerOut' | 'PointerOver' | 'PointerUp' | 'QIdle' | 'QInit' | 'QSymbol' | 'QVisible' | 'RateChange' | 'RateChange' | 'SecurityPolicyViolation' | 'SelectionChange' | 'SelectStart' | 'TimeUpdate' | 'TouchCancel' | 'TouchEnd' | 'TouchMove' | 'TouchStart' | 'TransitionCancel' | 'TransitionEnd' | 'TransitionRun' | 'TransitionStart' | 'VisibilityChange' | 'VolumeChange';
-
-/**
- * Convert an event map to PascalCase. For example, `HTMLElementEventMap` contains lowercase keys,
- * so this will capitalize them, and use the `LcEventNameMap` for multi-word events names.
- */
-declare type PascalMap<M> = {
-    [K in Extract<keyof M, string> as K extends keyof LcEventNameMap ? LcEventNameMap[K] : Capitalize<K>]: M[K];
-};
+declare type PascalCaseNames = 'AnimationEnd' | 'AnimationIteration' | 'AnimationStart' | 'AuxClick' | 'BeforeToggle' | 'CanPlay' | 'CanPlayThrough' | 'CompositionEnd' | 'CompositionStart' | 'CompositionUpdate' | 'ContextMenu' | 'DblClick' | 'DragEnd' | 'DragEnter' | 'DragExit' | 'DragLeave' | 'DragOver' | 'DragStart' | 'DurationChange' | 'FocusIn' | 'FocusOut' | 'FullscreenChange' | 'FullscreenError' | 'GotPointerCapture' | 'KeyDown' | 'KeyPress' | 'KeyUp' | 'LoadedData' | 'LoadedMetadata' | 'LoadEnd' | 'LoadStart' | 'LostPointerCapture' | 'MouseDown' | 'MouseEnter' | 'MouseLeave' | 'MouseMove' | 'MouseOut' | 'MouseOver' | 'MouseUp' | 'PointerCancel' | 'PointerDown' | 'PointerEnter' | 'PointerLeave' | 'PointerMove' | 'PointerOut' | 'PointerOver' | 'PointerUp' | 'QIdle' | 'QInit' | 'QResume' | 'QSymbol' | 'QVisible' | 'QViewTransition' | 'RateChange' | 'RateChange' | 'SecurityPolicyViolation' | 'SelectionChange' | 'SelectStart' | 'TimeUpdate' | 'TouchCancel' | 'TouchEnd' | 'TouchMove' | 'TouchStart' | 'TransitionCancel' | 'TransitionEnd' | 'TransitionRun' | 'TransitionStart' | 'VisibilityChange' | 'VolumeChange';
 
 declare type PopoverTargetAction = 'hide' | 'show' | 'toggle';
 
@@ -1960,6 +2012,7 @@ export declare type PropsOf<COMP> = COMP extends string ? COMP extends keyof Qwi
 declare type PropsProxy = {
     [_VAR_PROPS]: Props;
     [_CONST_PROPS]: Props | null;
+    [_OWNER]: JSXNodeInternal;
 };
 
 declare type PropType<T extends object, P extends keyof T> = P extends keyof T ? T[P] : 'value' extends keyof T ? T['value'] : never;
@@ -1977,6 +2030,11 @@ export declare interface _QDocument extends Document {
     qVNodeData: WeakMap<Element, string>;
 }
 
+declare interface QElement extends Element {
+    qDispatchEvent?: (event: Event, scope: QwikLoaderEventScope) => ValueOrPromise<unknown>;
+    vNode?: _VNode;
+}
+
 /**
  * The `QRL` type represents a lazy-loadable AND serializable resource.
  *
@@ -2109,7 +2167,7 @@ export declare type QRL<TYPE = unknown> = {
     getCaptured(): unknown[] | null;
     getSymbol(): string;
     getHash(): string;
-    dev: QRLDev | null;
+    dev?: QRLDev | null;
 } & BivariantQrlFn<QrlArgs<TYPE>, QrlReturn<TYPE>>;
 
 /**
@@ -2143,7 +2201,7 @@ export declare const qrlDEV: <T = any>(chunkOrFn: string | (() => Promise<any>),
  *
  * @public
  */
-export declare type QRLEventHandlerMulti<EV extends Event, EL> = QRL<EventHandler<EV, EL>> | undefined | null | QRLEventHandlerMulti<EV, EL>[] | EventHandler<EV, EL>;
+export declare type QRLEventHandlerMulti<EV extends Event, EL> = QRL<EventHandler<EV, EL>> | undefined | null | QRLEventHandlerMulti<EV, EL>[];
 
 declare type QRLInternal<TYPE = unknown> = QRL<TYPE> & QRLInternalMethods<TYPE>;
 
@@ -2230,13 +2288,19 @@ export declare type QwikClipboardEvent<T = Element> = NativeClipboardEvent;
 /** @public @deprecated Use `CompositionEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikCompositionEvent<T = Element> = NativeCompositionEvent;
 
-declare type QwikCustomEvents<EL> = {};
-
 declare type QwikCustomEventsPlain<EL> = {
     /** The handler */
     [key: `${'document:' | 'window:' | ''}on${string}$`]: QRLEventHandlerMulti<Event, EL> | EventHandler<Event, EL>;
 };
 
+declare type QwikDocumentEventMap = Omit<DocumentEventMap, keyof QwikHTMLElementEventMap> & Omit<QwikHTMLElementEventMap, 'qvisible' | 'focus' | 'blur'> & {
+    qidle: QwikIdleEvent;
+    qinit: QwikInitEvent;
+    qsymbol: QwikSymbolEvent;
+    qresume: QwikResumeEvent;
+    qviewtransition: QwikViewTransitionEvent;
+};
+
 /** @public */
 export declare interface QwikDOMAttributes extends DOMAttributes<Element> {
 }
@@ -2245,11 +2309,13 @@ export declare interface QwikDOMAttributes extends DOMAttributes<Element> {
 export declare type QwikDragEvent<T = Element> = NativeDragEvent;
 
 /** @public */
-declare type QwikEvents<EL, Plain extends boolean = true> = Plain extends true ? QwikKnownEventsPlain<EL> & QwikCustomEventsPlain<EL> : QwikKnownEvents<EL> & QwikCustomEvents<EL>;
+declare type QwikEvents<EL, Plain extends boolean = true> = Plain extends true ? QwikKnownEventsPlain<EL> & QwikCustomEventsPlain<EL> : QwikKnownEvents<EL>;
 
 /** @public @deprecated Use `FocusEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikFocusEvent<T = Element> = NativeFocusEvent;
 
+declare type QwikHTMLElementEventMap = Omit<HTMLElementEventMap, keyof EventCorrectionMap> & EventCorrectionMap;
+
 /**
  * The DOM props without plain handlers, for use inside functions
  *
@@ -2320,17 +2386,21 @@ declare namespace QwikJSX {
 export { QwikJSX as JSX }
 export { QwikJSX }
 
+declare type QwikJSXEvents = JSXElementEvents & JSXDocumentEvents & JSXWindowEvents;
+
 /** @public @deprecated Use `KeyboardEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikKeyboardEvent<T = Element> = NativeKeyboardEvent;
 
 declare type QwikKnownEvents<EL> = {
-    [K in keyof AllPascalEventMaps as `${'document:' | 'window:' | ''}on${K}$`]?: QRLEventHandlerMulti<AllPascalEventMaps[K], EL>;
+    [K in keyof QwikJSXEvents]?: QRLEventHandlerMulti<QwikJSXEvents[K], EL>;
 };
 
 declare type QwikKnownEventsPlain<EL> = {
-    [K in keyof AllPascalEventMaps as `${'document:' | 'window:' | ''}on${K}$`]?: QRLEventHandlerMulti<AllPascalEventMaps[K], EL> | EventHandler<AllPascalEventMaps[K], EL>;
+    [K in keyof QwikJSXEvents]?: QRLEventHandlerMulti<QwikJSXEvents[K], EL> | EventHandler<QwikJSXEvents[K], EL>;
 };
 
+declare type QwikLoaderEventScope = '-document' | '-window' | '';
+
 /**
  * The metadata of the build. One of its uses is storing where QRL symbols are located.
  *
@@ -2392,6 +2462,12 @@ export declare type QwikMouseEvent<T = Element, E = NativeMouseEvent> = E;
 /** @public @deprecated Use `PointerEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikPointerEvent<T = Element> = NativePointerEvent;
 
+/**
+ * Emitted by qwik-core on the container element when it resumes from a paused state. You cannot put
+ * a Qwik event handler on the container so you must listen on the document instead. @public
+ */
+export declare type QwikResumeEvent = CustomEvent<{}>;
+
 /** @public @deprecated Use `SubmitEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikSubmitEvent<T = Element> = SubmitEvent;
 
@@ -2422,7 +2498,7 @@ declare interface QwikSymbol {
     captureNames?: string[];
 }
 
-/** Emitted by qwik-loader when a module was lazily loaded @public */
+/** Emitted by qwik-loader on document when a module was lazily loaded @public */
 export declare type QwikSymbolEvent = CustomEvent<{
     symbol: string;
     element: Element;
@@ -2443,14 +2519,19 @@ export declare type QwikTransitionEvent<T = Element> = NativeTransitionEvent;
 export declare type QwikUIEvent<T = Element> = NativeUIEvent;
 
 /** Emitted by qwik-core on document when the a view transition start @public */
-declare type QwikViewTransitionEvent = CustomEvent<ViewTransition>;
+export declare type QwikViewTransitionEvent = CustomEvent<ViewTransition>;
 
-/** Emitted by qwik-loader when an element becomes visible. Used by `useVisibleTask$` @public */
+/**
+ * Handled by qwik-loader when an element becomes visible. Used by `useVisibleTask$`. Does not
+ * bubble. @public
+ */
 export declare type QwikVisibleEvent = CustomEvent<IntersectionObserverEntry>;
 
 /** @public @deprecated Use `WheelEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikWheelEvent<T = Element> = NativeWheelEvent;
 
+declare type QwikWindowEventMap = Omit<WindowEventHandlersEventMap, keyof QwikDocumentEventMap> & QwikDocumentEventMap;
+
 /** @public */
 export declare interface ReadonlySignal<T = unknown> {
     readonly value: T;
@@ -2472,7 +2553,12 @@ declare type RefFnInterface<EL> = {
     (el: EL): void;
 };
 
-/** @internal */
+/**
+ * Register a QRL symbol globally for lookup by its hash. This is used by the optimizer to register
+ * the names passed in `reg_ctx_name`.
+ *
+ * @internal
+ */
 export declare const _regSymbol: (symbol: any, hash: string) => any;
 
 /**
@@ -2658,7 +2744,7 @@ declare interface ResourceReturnInternal<T> {
 export declare const _restProps: (props: PropsProxy, omit?: string[], target?: Props) => Props;
 
 /**
- * This is called by qwik-loader to schedule a QRL. It has to be synchronous.
+ * This is called by qwik-loader to run a QRL. It has to be synchronous.
  *
  * @internal
  */
@@ -2666,10 +2752,10 @@ export declare const _run: (...args: unknown[]) => ValueOrPromise<unknown>;
 
 declare type Scheduler = ReturnType<typeof createScheduler>;
 
+/** Stores the location of an object. If no parent, it's a root. */
 declare type SeenRef = {
-    $parent$: unknown | null;
     $index$: number;
-    $rootIndex$: number;
+    $parent$?: SeenRef | null;
 };
 
 /** @public */
@@ -2691,28 +2777,21 @@ declare interface SerializationContext {
      * - `{ parent, index }` - The parent object and the index within that parent.
      * - `undefined` - Object has not been seen yet.
      */
-    $wasSeen$: (obj: unknown) => SeenRef | undefined;
+    getSeenRef: (obj: unknown) => SeenRef | undefined;
+    /** Returns the root index of the object, if it is a root. Otherwise returns undefined. */
     $hasRootId$: (obj: unknown) => number | undefined;
     /**
      * Root objects which need to be serialized.
      *
      * Roots are entry points into the object graph. Typically the roots are held by the listeners.
      *
-     * Returns a path string representing the path from roots through all parents to the object.
-     * Format: "3 2 0" where each number is the index within its parent, from root to leaf.
+     * Returns the index of the root object.
      */
-    $addRoot$: (obj: unknown, parent?: unknown) => number;
-    /**
-     * Get root path of the object without creating a new root.
-     *
-     * This is used during serialization, as new roots can't be created during serialization.
-     *
-     * The function throws if the root was not found.
-     */
-    $addRootPath$: (obj: any) => string | number;
-    $seen$: (obj: unknown, parent: unknown | null, index: number) => void;
+    $addRoot$: AddRootFn;
+    /** Mark an object as seen during serialization. This is used to handle backreferences and cycles */
+    $markSeen$: (obj: unknown, parent: SeenRef | undefined, index: number) => SeenRef;
     $roots$: unknown[];
-    $objectPathStringCache$: Map<unknown, string | number>;
+    $promoteToRoot$: (ref: SeenRef, index?: number) => void;
     $addSyncFn$($funcStr$: string | null, argsCount: number, fn: Function): number;
     $isSsrNode$: (obj: unknown) => obj is SsrNode;
     $isDomRef$: (obj: unknown) => obj is DomRef;
@@ -2905,6 +2984,7 @@ declare class SignalImpl<T = any> implements Signal<T> {
     /** Store a list of effects which are dependent on this signal. */
     $effects$: null | Set<EffectSubscription>;
     $container$: Container | null;
+    $wrappedSignal$: WrappedSignalImpl<T> | null;
     constructor(container: Container | null, value: T);
     /**
      * Use this to force running subscribers, for example when the calculated value has mutated but
@@ -3201,7 +3281,7 @@ declare type SsrAttrKey = string;
 
 declare type SsrAttrs = Array<SsrAttrKey | SsrAttrValue>;
 
-declare type SsrAttrValue = string | Signal<any> | boolean | object | null;
+declare type SsrAttrValue = string | Signal<any> | Promise<any> | boolean | object | null;
 
 /** @public */
 export declare const SSRComment: FunctionComponent<{
@@ -3211,6 +3291,7 @@ export declare const SSRComment: FunctionComponent<{
 declare interface SSRContainer extends Container {
     readonly tag: string;
     readonly isHtml: boolean;
+    readonly size: number;
     readonly writer: StreamWriter;
     readonly serializationCtx: SerializationContext;
     readonly symbolToChunkResolver: SymbolToChunkResolver;
@@ -3218,6 +3299,7 @@ declare interface SSRContainer extends Container {
     additionalHeadNodes: Array<JSXNodeInternal>;
     additionalBodyNodes: Array<JSXNodeInternal>;
     unclaimedProjectionComponentFrameQueue: ISsrComponentFrame[];
+    write(text: string): void;
     openContainer(): void;
     closeContainer(): ValueOrPromise<void>;
     openElement(elementName: string, varAttrs: SsrAttrs | null, constAttrs?: SsrAttrs | null, currentFile?: string | null): string | undefined;
@@ -3597,18 +3679,11 @@ declare type SymbolToChunkResolver = (symbol: string) => string;
 export declare const sync$: <T extends Function>(fn: T) => SyncQRL<T>;
 
 /** @public */
-export declare interface SyncQRL<TYPE extends Function = any> extends QRL<TYPE> {
+export declare type SyncQRL<TYPE extends Function> = QRL<TYPE> & {
     __brand__SyncQRL__: TYPE;
-    /**
-     * Resolve the QRL of closure and invoke it.
-     *
-     * @param args - Closure arguments.
-     * @returns A return value of the closure.
-     */
-    (...args: TYPE extends (...args: infer ARGS) => any ? ARGS : never): TYPE extends (...args: any[]) => infer RETURN ? RETURN : never;
     resolved: TYPE;
-    dev: QRLDev | null;
-}
+    dev?: QRLDev | null;
+} & BivariantQrlFn<QrlArgs<TYPE>, QrlReturn<TYPE>>;
 
 declare type TableCellSpecialAttrs = {
     align?: 'left' | 'center' | 'right' | 'justify' | 'char' | undefined;
@@ -3645,6 +3720,12 @@ declare const TaskEvent = "qTask";
 /** @public */
 export declare type TaskFn = (ctx: TaskCtx) => ValueOrPromise<void | (() => void)>;
 
+/** @public */
+export declare interface TaskOptions {
+    /** Block the rendering of the component until the task completes. Default is `true` */
+    deferUpdates?: boolean;
+}
+
 /** @internal */
 export declare class _TextVNode extends _VNode {
     textNode: Text | null;
@@ -3928,6 +4009,8 @@ export declare const useLexicalScope: <VARS extends any[]>() => VARS;
  * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
  * have access to the JSX. Otherwise, it's adding a JSX listener in the `<div>` is a better idea.
  *
+ * Events are case sensitive.
+ *
  * @public
  * @see `useOn`, `useOnWindow`, `useOnDocument`.
  */
@@ -3939,6 +4022,8 @@ export declare const useOn: <T extends KnownEventNames>(event: T | T[], eventQrl
  * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
  * have access to the JSX.
  *
+ * Events are case sensitive.
+ *
  * @public
  * @see `useOn`, `useOnWindow`, `useOnDocument`.
  *
@@ -3966,6 +4051,8 @@ export declare const useOnDocument: <T extends KnownEventNames>(event: T | T[],
  * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
  * have access to the JSX.
  *
+ * Events are case sensitive.
+ *
  * @public
  * @see `useOn`, `useOnWindow`, `useOnDocument`.
  *
@@ -4312,10 +4399,10 @@ export declare const useStylesScopedQrl: (styles: QRL<string>) => UseStylesScope
  * @public
  * @see `Tracker`
  */
-export declare const useTask$: (fn: TaskFn) => void;
+export declare const useTask$: (fn: TaskFn, opts?: TaskOptions) => void;
 
 /** @internal */
-export declare const useTaskQrl: (qrl: QRL<TaskFn>) => void;
+export declare const useTaskQrl: (qrl: QRL<TaskFn>, opts?: TaskOptions) => void;
 
 /**
  * ```tsx
@@ -4345,6 +4432,13 @@ export declare const useVisibleTask$: (fn: TaskFn, opts?: OnVisibleTaskOptions)
 /** @internal */
 export declare const useVisibleTaskQrl: (qrl: QRL<TaskFn>, opts?: OnVisibleTaskOptions) => void;
 
+/**
+ * Handles events for bind:value
+ *
+ * @internal
+ */
+export declare const _val: (_: any, element: HTMLInputElement) => void;
+
 /**
  * Type representing a value which is either resolve or a promise.
  *
@@ -4359,7 +4453,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.11-dev+d7daca3
+ * 2.0.0-beta.14-dev+1e7496d
  *
  * @public
  */
@@ -4511,8 +4605,9 @@ declare const enum VNodeJournalOpCode {
     SetText = 1,// ------ [SetAttribute, target, text]
     SetAttribute = 2,// - [SetAttribute, target, ...(key, values)]]
     HoistStyles = 3,// -- [HoistStyles, document]
-    Remove = 4,// ------- [Insert, target(parent), ...nodes]
-    Insert = 5
+    Remove = 4,// ------- [Remove, target(parent), ...nodes]
+    RemoveAll = 5,// ------- [RemoveAll, target(parent)]
+    Insert = 6
 }
 
 /** @internal */
@@ -4553,6 +4648,7 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
     force(): void;
     get untrackedValue(): T;
     $computeIfNeeded$(): void;
+    $unwrapIfSignal$(): SignalImpl<T> | WrappedSignalImpl<T>;
     set value(_: any);
     get value(): any;
 }