@qwik.dev/core 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/core-internal.d.ts

@@ -1,11 +1,8 @@
-import * as CSS_2 from 'csstype';
+import type * as CSS_2 from 'csstype';
 import { isBrowser } from './build';
 import { isDev } from './build';
 import { isServer } from './build';
-import { QRL as QRL_2 } from './qrl.public';
-import { ReadonlySignal as ReadonlySignal_2 } from '..';
-import type { StreamWriter as StreamWriter_2 } from '.';
-import { ValueOrPromise as ValueOrPromise_2 } from '..';
+import { ResolvedManifest } from './optimizer';
 
 /**
  * Qwik Optimizer marker function.
@@ -83,23 +80,33 @@ import { ValueOrPromise as ValueOrPromise_2 } from '..';
  */
 export declare const $: <T>(expression: T) => QRL<T>;
 
+/**
+ * Register an external projection on a parent component VNode.
+ *
+ * Creates a new VirtualVNode that will render the given component QRL with the given props. The
+ * VNode is stored as a projection on the parent, and a low-priority cursor is added so the cursor
+ * walker will process it.
+ *
+ * Use `_setProjectionTarget` to set the DOM target element before the cursor fires.
+ *
+ * @internal
+ */
+export declare function _addProjection(container: _Container, parentVNode: _VirtualVNode, componentQRL: QRL<any>, props: Record<string, unknown>, slotName: string): _VirtualVNode;
+
+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;
+declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
 
 /**
  * TS defines these with the React syntax which is not compatible with Qwik. E.g. `ariaAtomic`
@@ -357,22 +364,248 @@ declare interface AriaAttributes {
 /** @public */
 declare type AriaRole = 'alert' | 'alertdialog' | 'application' | 'article' | 'banner' | 'button' | 'cell' | 'checkbox' | 'columnheader' | 'combobox' | 'complementary' | 'contentinfo' | 'definition' | 'dialog' | 'directory' | 'document' | 'feed' | 'figure' | 'form' | 'grid' | 'gridcell' | 'group' | 'heading' | 'img' | 'link' | 'list' | 'listbox' | 'listitem' | 'log' | 'main' | 'marquee' | 'math' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'navigation' | 'none' | 'note' | 'option' | 'presentation' | 'progressbar' | 'radio' | 'radiogroup' | 'region' | 'row' | 'rowgroup' | 'rowheader' | 'scrollbar' | 'search' | 'searchbox' | 'separator' | 'slider' | 'spinbutton' | 'status' | 'switch' | 'tab' | 'table' | 'tablist' | 'tabpanel' | 'term' | 'textbox' | 'timer' | 'toolbar' | 'tooltip' | 'tree' | 'treegrid' | 'treeitem' | (string & {});
 
-declare type AsyncComputedCtx = {
+declare type AsyncCtx<T = unknown> = {
     track: Tracker;
-    cleanup: (callback: () => void) => void;
+    /**
+     * Register a cleanup callback to be called when the async computation is aborted or completed.
+     * The next invocation will await the previous cleanup. If you do not want this, do not return a
+     * Promise.
+     */
+    cleanup: (callback: () => void | Promise<void>) => void;
+    /**
+     * A lazily created AbortSignal, for interrupting the async computation when needed, e.g. when the
+     * component is unmounted or the computation is invalidated. Pass it to `fetch` or other APIs that
+     * support it to ensure that unnecessary work is not performed.
+     */
+    readonly abortSignal: AbortSignal;
+    /** The result of the previous computation, if any */
+    readonly previous: T | undefined;
+    /** Extra info passed to `invalidate(info)` for this computation, if any. */
+    readonly info: unknown;
 };
 
-/** @public */
-export declare type AsyncComputedFn<T> = (ctx: AsyncComputedCtx) => Promise<T>;
+/**
+ * Note, we don't pass the generic type to AsyncCtx because it causes TypeScript to not infer the
+ * type of the resource correctly. The type is only used for the `previous` property, which is not
+ * commonly used, and can be easily cast if needed.
+ *
+ * @public
+ */
+export declare type AsyncFn<T> = (ctx: AsyncCtx) => ValueOrPromise<T>;
+
+/** Retains job metadata and also serves as the argument for the compute function */
+declare class AsyncJob<T> implements AsyncCtx<T> {
+    readonly $signal$: AsyncSignalImpl<T>;
+    readonly info: unknown;
+    readonly $infoVersion$: number;
+    /** First holds the compute promise and then the cleanup promise */
+    $promise$: Promise<void> | null;
+    $cleanupRequested$: boolean;
+    $canWrite$: boolean;
+    $track$: AsyncCtx<T>['track'] | undefined;
+    $cleanups$: Parameters<AsyncCtx<T>['cleanup']>[0][] | undefined;
+    $abortController$: AbortController | undefined;
+    constructor($signal$: AsyncSignalImpl<T>, info: unknown, $infoVersion$: number);
+    get track(): AsyncCtx<T>['track'];
+    get abortSignal(): AbortSignal;
+    /** Backward compatible cache method for resource */
+    cache(): void;
+    get previous(): T | undefined;
+    cleanup(callback: () => void): void;
+}
 
-/** @public */
-export declare interface AsyncComputedReadonlySignal<T = unknown> extends ReadonlySignal<T> {
+declare type AsyncQRL<T> = _QRLInternal<AsyncFn<T>>;
+
+/**
+ * An AsyncSignal holds the result of the given async function. If the function uses `track()` to
+ * track reactive state, and that state changes, the AsyncSignal is recalculated, and if the result
+ * changed, all tasks which are tracking the AsyncSignal will be re-run and all subscribers
+ * (components, tasks etc) that read the AsyncSignal will be updated.
+ *
+ * If the async function throws an error, the AsyncSignal will capture the error and set the `error`
+ * property. The error can be cleared by re-running the async function successfully.
+ *
+ * While the async function is running, the `.loading` property will be set to `true`. Once the
+ * function completes, `loading` will be set to `false`.
+ *
+ * If the value has not yet been resolved, reading the AsyncSignal will throw a Promise, which will
+ * retry the component or task once the value resolves.
+ *
+ * If the value has been resolved, but the async function is re-running, reading the AsyncSignal
+ * will subscribe to it and return the last resolved value until the new value is ready. As soon as
+ * the new value is ready, the subscribers will be updated.
+ *
+ * If the async function threw an error, reading the `.value` will throw that same error. Read from
+ * `.error` to check if there was an error.
+ *
+ * @public
+ */
+export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
+    /**
+     * Whether the signal is currently loading. This will trigger lazy loading of the signal, so you
+     * can use it like this:
+     *
+     * ```tsx
+     * signal.loading ? <Loading /> : signal.error ? <Error /> : <Component
+     * value={signal.value} />
+     * ```
+     */
+    loading: boolean;
+    /**
+     * The error that occurred while computing the signal, if any. This will be cleared when the
+     * signal is successfully computed.
+     */
+    error: Error | undefined;
+    /**
+     * Staleness/poll interval in ms. Writable and immediately effective.
+     *
+     * - **Positive**: Poll — re-compute after this many ms when subscribers exist.
+     * - **Negative**: Stale-only — mark stale after `|interval|` ms, no auto-recompute.
+     * - **`0`**: No staleness tracking or polling.
+     */
+    interval: number;
+    /** A promise that resolves when the value is computed or rejected. */
+    promise(): Promise<void>;
+    /** Abort the current computation and run cleanups if needed. */
+    abort(reason?: any): void;
+    /**
+     * Use this to force recalculation. If you pass `info`, it will be provided to the calculation
+     * function.
+     */
+    invalidate(info?: unknown): void;
 }
 
-/** @public */
-export declare type AsyncComputedReturnType<T> = T extends Promise<infer T> ? AsyncComputedReadonlySignal<T> : AsyncComputedReadonlySignal<T>;
+declare const enum AsyncSignalFlags {
+    EAGER_CLEANUP = 32,
+    CLIENT_ONLY = 64
+}
 
-declare type AsyncComputeQRL<T> = QRLInternal<AsyncComputedFn<T>>;
+/**
+ * # ================================
+ *
+ * AsyncSignalImpl
+ *
+ * # ================================
+ */
+declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements BackRef, AsyncSignal<T> {
+    $untrackedLoading$: boolean;
+    $untrackedError$: Error | undefined;
+    $loadingEffects$: undefined | Set<EffectSubscription>;
+    $errorEffects$: undefined | Set<EffectSubscription>;
+    $current$: AsyncJob<T> | null;
+    $jobs$: AsyncJob<T>[];
+    $concurrency$: number;
+    $interval$: number;
+    $timeoutMs$: number | undefined;
+    $info$: unknown;
+    $infoVersion$: number;
+    $pollTimeoutId$: ReturnType<typeof setTimeout> | undefined;
+    $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
+    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
+    constructor(container: _Container | null, fn: AsyncQRL<T>, flags?: SignalFlags | SerializationSignalFlags, options?: AsyncSignalOptions<T>);
+    get untrackedValue(): T;
+    set untrackedValue(value: T);
+    /**
+     * Read the value, subscribing if in a tracking context. Triggers computation if needed.
+     *
+     * Setting the value will mark the signal as not loading and clear any error, and prevent any
+     * pending computations from writing their results.
+     *
+     * If you want to set the value without affecting loading or error state, set `untrackedValue`
+     * instead and make sure to trigger effects manually if needed.
+     *
+     * If you want to abort pending computations when setting, you have to call `abort()` manually.
+     */
+    get value(): T;
+    set value(value: T);
+    /**
+     * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
+     * has resolved or rejected.
+     *
+     * Accessing .loading will trigger computation if needed, since it's often used like
+     * `signal.loading ? <Loading /> : signal.value`.
+     */
+    get loading(): boolean;
+    set untrackedLoading(value: boolean);
+    get untrackedLoading(): boolean;
+    /** The error that occurred when the signal was resolved. */
+    get error(): Error | undefined;
+    set untrackedError(value: Error | undefined);
+    get untrackedError(): Error | undefined;
+    get interval(): number;
+    set interval(value: number);
+    /** Invalidates the signal, causing it to re-compute its value. */
+    invalidate(info?: unknown): Promise<void>;
+    /** Abort the current computation and run cleanups if needed. */
+    abort(reason?: any): void;
+    /** Schedule eager cleanup on next macro task if no subscribers remain. */
+    $scheduleEagerCleanup$(): void;
+    /** Returns a promise resolves when the signal finished computing. */
+    promise(): Promise<void>;
+    /** Run the computation if needed */
+    $computeIfNeeded$(): void;
+    $runComputation$(running: AsyncJob<T>): Promise<void>;
+    /** Called after SSR/unmount */
+    $destroy$(): Promise<void>;
+    private $clearNextPoll$;
+    private $scheduleNextPoll$;
+    private $hasSubscribers$;
+    $requestCleanups$(job: AsyncJob<T>, reason?: any): Promise<void | null>;
+    /** Clean up and trigger signal compute once complete */
+    $runCleanups$(job: AsyncJob<T>): Promise<void>;
+}
+
+/** @public */
+export declare interface AsyncSignalOptions<T> extends ComputedOptions {
+    /** Like useSignal's `initial`; prevents the throw on first read when uninitialized */
+    initial?: T | (() => T);
+    /**
+     * Maximum number of concurrent computations. Use `0` for unlimited.
+     *
+     * Defaults to `1`.
+     */
+    concurrency?: number;
+    /**
+     * When subscribers drop to 0, run cleanup in the next tick, instead of waiting for the function
+     * inputs to change.
+     *
+     * Defaults to `false`, meaning cleanup happens only when inputs change.
+     */
+    eagerCleanup?: boolean;
+    /**
+     * Wait for previous invocation to complete before running again.
+     *
+     * Defaults to `true`.
+     *
+     * @deprecated Not implemented yet
+     */
+    awaitPrevious?: boolean;
+    /**
+     * Controls staleness and polling behavior.
+     *
+     * - **Positive**: Re-run the function after `interval` ms if subscribers exist (polling).
+     * - **Negative**: Mark the value as stale after `|interval|` ms, but do NOT auto-recompute.
+     *   Consumers can check staleness and manually trigger recomputation.
+     * - **`0`** (default): No staleness tracking or polling.
+     */
+    interval?: number;
+    /**
+     * When true, the async computation is postponed to the browser. On SSR, the signal remains
+     * INVALID and does not execute the function. On the client, it will compute on first read.
+     *
+     * Defaults to `false`.
+     */
+    clientOnly?: boolean;
+    /**
+     * Maximum time in milliseconds to wait for the async computation to complete. If exceeded, the
+     * computation is aborted and an error is thrown.
+     *
+     * If `0`, no timeout is applied.
+     *
+     * Defaults to `0`.
+     */
+    timeout?: number;
+}
 
 /**
  * Replace given element's props with custom types and return all props specific to the element. Use
@@ -384,7 +617,7 @@ declare type Augmented<E, A = {}> = Prettify<Filtered<E, A> & A>;
 
 /** Class for back reference to the EffectSubscription */
 declare abstract class BackRef {
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
+    [_EFFECT_BACK_REF]: Map<any, any> | undefined;
 }
 
 declare type BivariantQrlFn<ARGS extends any[], RETURN> = {
@@ -400,21 +633,34 @@ declare type BivariantQrlFn<ARGS extends any[], RETURN> = {
 /** @public */
 declare type Booleanish = boolean | `${boolean}`;
 
-declare const enum ChoreType {
-    MACRO = 240,
-    MICRO = 15,
-    /** Ensure that the QRL promise is resolved before processing next chores in the queue */
-    QRL_RESOLVE = 1,
-    RUN_QRL = 2,
-    TASK = 3,
-    NODE_DIFF = 4,
-    NODE_PROP = 5,
-    COMPONENT = 6,
-    RECOMPUTE_AND_SCHEDULE_EFFECTS = 7,
-    JOURNAL_FLUSH = 16,
-    VISIBLE = 32,
-    CLEANUP_VISIBLE = 48,
-    WAIT_FOR_ALL = 255
+/**
+ * The current captured scope during QRL invocation. This is used to provide the lexical scope for
+ * QRL functions. It is used one time per invocation, synchronously, so it is safe to store it in
+ * module scope.
+ *
+ * @internal
+ */
+export declare let _captures: Readonly<unknown[]> | null;
+
+/**
+ * Handles events for bind:checked
+ *
+ * @internal
+ */
+export declare function _chk(this: string | undefined, _: any, element: HTMLInputElement): void;
+
+declare const enum ChoreBits {
+    NONE = 0,
+    TASKS = 1,
+    NODE_DIFF = 2,
+    COMPONENT = 4,
+    NODE_PROPS = 8,
+    COMPUTE = 16,
+    CHILDREN = 32,
+    CLEANUP = 64,
+    RECONCILE = 128,
+    ERROR_WRAP = 256,
+    DIRTY_MASK = 511
 }
 
 /**
@@ -430,17 +676,14 @@ declare const enum ChoreType {
 export declare type ClassList = string | undefined | null | false | Record<string, boolean | string | number | null | undefined> | ClassList[];
 
 /** @internal */
-export declare interface ClientContainer extends Container {
+export declare interface ClientContainer extends _Container {
     document: _QDocument;
     element: _ContainerElement;
     qContainer: string;
     $locale$: string;
     qManifestHash: string;
     rootVNode: _ElementVNode;
-    $journal$: VNodeJournal;
-    renderDone: Promise<void> | null;
     $forwardRefs$: Array<number> | null;
-    $initialQRLsIndexes$: Array<number> | null;
     parseQRL<T = unknown>(qrl: string): QRL<T>;
     $setRawState$(id: number, vParent: _ElementVNode | _VirtualVNode): void;
 }
@@ -468,11 +711,11 @@ export declare interface ClientContainer extends Container {
  *   step?: number;
  * }
  * export const Counter = component$((props: CounterProps) => {
- *   const state = useStore({ count: props.initialValue || 0 });
+ *   const state = useSignal(props.initialValue || 0);
  *   return (
  *     <div>
- *       <span>{state.count}</span>
- *       <button onClick$={() => (state.count += props.step || 1)}>+</button>
+ *       <span>{state.value}</span>
+ *       <button onClick$={() => (state.value += props.step || 1)}>+</button>
  *     </div>
  *   );
  * });
@@ -527,12 +770,6 @@ declare type ComponentChildren<PROPS> = PROPS extends {
     children?: JSXChildren;
 };
 
-/** @public */
-declare interface ComponentEntryStrategy {
-    type: 'component';
-    manual?: Record<string, string>;
-}
-
 /** @internal */
 export declare const componentQrl: <PROPS extends Record<any, any>>(componentQrl: QRL<OnRenderFn<PROPS>>) => Component<PROPS>;
 
@@ -540,7 +777,13 @@ export declare const componentQrl: <PROPS extends Record<any, any>>(componentQrl
 export declare type ComputedFn<T> = () => T;
 
 /** @public */
-export declare type ComputedReturnType<T> = T extends Promise<any> ? never : ReadonlySignal<T>;
+export declare interface ComputedOptions {
+    serializationStrategy?: SerializationStrategy;
+    container?: _Container;
+}
+
+/** @public */
+export declare type ComputedReturnType<T> = T extends Promise<any> ? never : ComputedSignal<T>;
 
 /**
  * A computed signal is a signal which is calculated from other signals. When the signals change,
@@ -549,12 +792,11 @@ export declare type ComputedReturnType<T> = T extends Promise<any> ? never : Rea
  *
  * @public
  */
-export declare interface ComputedSignal<T> extends ReadonlySignal<T> {
-    /**
-     * Use this to force recalculation and running subscribers, for example when the calculated value
-     * mutates but remains the same object. Useful for third-party libraries.
-     */
+export declare interface ComputedSignal<T> extends Signal<T> {
+    /** @deprecated Use `trigger()` instead */
     force(): void;
+    /** Use this to force recalculation. */
+    invalidate(): void;
 }
 
 /**
@@ -562,7 +804,7 @@ export declare interface ComputedSignal<T> extends ReadonlySignal<T> {
  *
  * The value is available synchronously, but the computation is done lazily.
  */
-declare class ComputedSignalImpl<T, S extends QRLInternal = ComputeQRL<T>> extends SignalImpl<T> implements BackRef {
+declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> extends SignalImpl<T> implements BackRef {
     /**
      * The compute function is stored here.
      *
@@ -570,23 +812,16 @@ declare class ComputedSignalImpl<T, S extends QRLInternal = ComputeQRL<T>> exten
      * resolve the QRL during the mark dirty phase so that any call to it will be synchronous). )
      */
     $computeQrl$: S;
-    $flags$: SignalFlags;
-    $forceRunEffects$: boolean;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
-    constructor(container: Container | null, fn: S, flags?: SignalFlags);
-    $invalidate$(): void;
-    /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object
-     */
-    force(): void;
+    $flags$: SignalFlags | SerializationSignalFlags;
+    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
+    constructor(container: _Container | null, fn: S, flags?: SignalFlags | SerializationSignalFlags);
+    invalidate(): void;
     get untrackedValue(): T;
-    $computeIfNeeded$(): boolean;
-    set value(_: any);
-    get value(): any;
+    set untrackedValue(value: T);
+    $computeIfNeeded$(): void;
 }
 
-declare type ComputeQRL<T> = QRLInternal<ComputedFn<T>>;
+declare type ComputeQRL<T> = _QRLInternal<ComputedFn<T>>;
 
 /** @internal */
 export declare const _CONST_PROPS: unique symbol;
@@ -600,18 +835,22 @@ export declare const _CONST_PROPS: unique symbol;
  * - `VNode` and `ISsrNode`: Either a component or `<Signal>`
  * - `Signal2`: A derived signal which contains a computation function.
  */
-declare type Consumer = Task | _VNode | ISsrNode | SignalImpl;
+declare type Consumer = Task | _VNode | SignalImpl | ISsrNode;
 
-declare interface Container {
+/** @internal */
+export declare interface _Container {
     readonly $version$: string;
-    readonly $scheduler$: Scheduler;
     readonly $storeProxyMap$: ObjToProxyMap;
     readonly $locale$: string;
     readonly $getObjectById$: (id: number | string) => any;
     readonly $serverData$: Record<string, any>;
     $currentUniqueId$: number;
     $buildBase$: string | null;
-    handleError(err: any, $host$: HostElement): void;
+    $renderPromise$: Promise<void> | null;
+    $resolveRenderPromise$: (() => void) | null;
+    $pendingCount$: number;
+    $checkPendingCount$(): void;
+    handleError(err: any, $host$: HostElement | null): void;
     getParentHost(host: HostElement): HostElement | null;
     setContext<T>(host: HostElement, context: ContextId<T>, value: T): void;
     resolveContext<T>(host: HostElement, contextId: ContextId<T>): T | undefined;
@@ -755,19 +994,13 @@ export declare interface CorePlatform {
      * @param symbol - The name of the symbol to import.
      * @returns A promise that resolves to the imported symbol.
      */
-    importSymbol: (containerEl: Element | undefined, url: string | URL | undefined | null, symbol: string) => ValueOrPromise<any>;
+    importSymbol: (containerEl: Element | undefined, url: string | URL | undefined | null, symbol: string) => ValueOrPromise<unknown>;
     /**
      * Perform operation on next request-animation-frame.
      *
      * @param fn - The function to call when the next animation frame is ready.
      */
     raf: (fn: () => any) => Promise<any>;
-    /**
-     * Perform operation on next tick.
-     *
-     * @param fn - The function to call when the tick is ready.
-     */
-    nextTick: (fn: () => any) => Promise<any>;
     /**
      * Retrieve chunk name for the symbol.
      *
@@ -789,6 +1022,17 @@ export declare interface CorrectedToggleEvent extends Event {
     readonly prevState: 'open' | 'closed';
 }
 
+/**
+ * Create a signal holding a `.value` which is calculated from the given async function (QRL). The
+ * standalone version of `useAsync$`.
+ *
+ * @public
+ */
+export declare const createAsync$: <T>(qrl: (arg: AsyncCtx<T>) => Promise<T>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
+
+/** @internal */
+export declare const createAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSignalOptions<T>) => AsyncSignalImpl<T>;
+
 /**
  * Create a computed signal which is calculated from the given QRL. A computed signal is a signal
  * which is calculated from other signals. When the signals change, the computed signal is
@@ -797,14 +1041,14 @@ export declare interface CorrectedToggleEvent extends Event {
  * The QRL must be a function which returns the value of the signal. The function must not have side
  * effects, and it must be synchronous.
  *
- * If you need the function to be async, use `useSignal` and `useTask$` instead.
+ * If you need the function to be async, use `createAsync$` instead (don't forget to use `track()`).
  *
  * @public
  */
-export declare const createComputed$: <T>(qrl: () => T) => T extends Promise<any> ? never : ComputedSignal<T>;
+export declare const createComputed$: <T>(qrl: () => T, options?: ComputedOptions) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const createComputedQrl: <T>(qrl: QRL<() => T>) => ComputedSignalImpl<T>;
+export declare const createComputedQrl: <T>(qrl: QRL<() => T>, options?: ComputedOptions) => ComputedSignalImpl<T>;
 
 /**
  * Create a context ID to be used in your application. The name should be written with no spaces.
@@ -858,18 +1102,20 @@ export declare const createComputedQrl: <T>(qrl: QRL<() => T>) => ComputedSignal
  */
 export declare const createContextId: <STATE = unknown>(name: string) => ContextId<STATE>;
 
-declare const createScheduler: (container: Container, scheduleDrain: () => void, journalFlush: () => void) => {
-    (type: ChoreType.QRL_RESOLVE, ignore: null, target: ComputeQRL<any> | AsyncComputeQRL<any>): ValueOrPromise<void>;
-    (type: ChoreType.JOURNAL_FLUSH): ValueOrPromise<void>;
-    (type: ChoreType.WAIT_FOR_ALL): ValueOrPromise<void>;
-    (type: ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, host: HostElement | null, target: Signal | StoreHandler, effects: Set<EffectSubscription> | null): ValueOrPromise<void>;
-    (type: ChoreType.TASK | ChoreType.VISIBLE, task: Task): ValueOrPromise<void>;
-    (type: ChoreType.RUN_QRL, host: HostElement, target: QRLInternal<(...args: unknown[]) => unknown>, args: unknown[]): ValueOrPromise<void>;
-    (type: ChoreType.COMPONENT, host: HostElement, qrl: QRLInternal<OnRenderFn<unknown>>, props: Props | null): ValueOrPromise<JSXOutput>;
-    (type: ChoreType.NODE_DIFF, host: HostElement, target: HostElement, value: JSXOutput | Signal): ValueOrPromise<void>;
-    (type: ChoreType.NODE_PROP, host: HostElement, prop: string, value: any): ValueOrPromise<void>;
-    (type: ChoreType.CLEANUP_VISIBLE, task: Task): ValueOrPromise<JSXOutput>;
-};
+/**
+ * Creates a QRL instance to represent a lazily loaded value. Normally this is a function, but it
+ * can be any value.
+ *
+ * When the value is a function, calling the returned qrl will load the underlying code when
+ * invoked, and call it with the captured scope. This always returns a promise since the code may
+ * not be loaded yet.
+ *
+ * To get the underlying function without invoking it, await `qrl.resolve()` and then `qrl.resolved`
+ * holds the loaded function, wrapped with the captured scope.
+ *
+ * @internal
+ */
+export declare const _createQRL: <TYPE>(chunk: string | null, symbol: string, symbolRef?: null | ValueOrPromise<TYPE>, symbolFn?: null | (() => Promise<Record<string, TYPE>>), captures?: Readonly<unknown[]> | string | null, container?: _Container) => _QRLInternal<TYPE>;
 
 /**
  * Create a signal that holds a custom serializable value. See {@link useSerializer$} for more
@@ -909,24 +1155,22 @@ 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;
     $el$: HostElement;
-    $qrl$: QRLInternal<T>;
+    $qrl$: _QRLInternal<T>;
     $state$: B | undefined;
-    $destroy$: NoSerialize<() => void> | null;
+    $destroy$: (() => void) | null;
 }
 
 /**
  * Deserialize data from string to an array of objects.
  *
  * @param rawStateData - Data to deserialize
- * @param element - Container element
  * @internal
  */
-export declare function _deserialize(rawStateData: string | null, element?: unknown): unknown[];
+export declare function _deserialize<T>(rawStateData: string): T;
 
 declare interface DeserializeContainer {
     $getObjectById$: (id: number | string) => unknown;
@@ -935,8 +1179,6 @@ declare interface DeserializeContainer {
     $state$?: unknown[];
     $storeProxyMap$: ObjToProxyMap;
     $forwardRefs$: Array<number> | null;
-    $initialQRLsIndexes$: Array<number> | null;
-    readonly $scheduler$: Scheduler | null;
 }
 
 /** @public */
@@ -963,53 +1205,40 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     qManifestHash: string;
     rootVNode: _ElementVNode;
     document: _QDocument;
-    $journal$: VNodeJournal;
-    renderDone: Promise<void> | null;
-    $rawStateData$: unknown[];
     $storeProxyMap$: ObjToProxyMap;
     $qFuncs$: Array<(...args: unknown[]) => unknown>;
     $instanceHash$: string;
     $forwardRefs$: Array<number> | null;
-    $initialQRLsIndexes$: Array<number> | null;
     vNodeLocate: (id: string | Element) => _VNode;
+    private $rawStateData$;
     private $stateData$;
     private $styleIds$;
-    private $renderCount$;
     constructor(element: _ContainerElement);
-    $setRawState$(id: number, vParent: _ElementVNode | _VirtualVNode): void;
-    parseQRL<T = unknown>(qrl: string): QRL<T>;
-    handleError(err: any, host: HostElement): void;
-    setContext<T>(host: HostElement, context: ContextId<T>, value: T): void;
-    resolveContext<T>(host: HostElement, contextId: ContextId<T>): T | undefined;
-    getParentHost(host: HostElement): HostElement | null;
+    /** Tear down this container so stale references fail gracefully. */
+    $destroy$(): void;
+    /**
+     * The first time we render we need to hoist the styles. (Meaning we need to move all styles from
+     * component inline to <head>)
+     *
+     * We bulk move all of the styles, because the expensive part is for the browser to recompute the
+     * styles, (not the actual DOM manipulation.) By moving all of them at once we can minimize the
+     * reflow.
+     */
+    $hoistStyles$(): void;
+    $setRawState$(id: number, vParent: _VNode): void;
+    parseQRL<T = unknown>(qrlStr: string): QRL<T>;
+    handleError(err: any, host: _VNode | null): void;
+    setContext<T>(host: _VNode, context: ContextId<T>, value: T): void;
+    resolveContext<T>(host: _VNode, contextId: ContextId<T>): T | undefined;
+    getParentHost(host: _VNode): _VNode | null;
     setHostProp<T>(host: HostElement, name: string, value: T): void;
     getHostProp<T>(host: HostElement, name: string): T | null;
-    scheduleRender(): Promise<void>;
-    private processChores;
     ensureProjectionResolved(vNode: _VirtualVNode): void;
     $getObjectById$: (id: number | string) => unknown;
     getSyncFn(id: number): (...args: unknown[]) => unknown;
     $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 }
@@ -1021,9 +1250,28 @@ declare type DomRef = {
 /** @internal */
 export declare const _dumpState: (state: unknown[], color?: boolean, prefix?: string, limit?: number | null) => string;
 
+/** @internal */
+export declare const _eaC: (props: EachProps<any>) => JSXNode<unknown>;
+
+/** @public @experimental */
+export declare const Each: EachComponent;
+
+declare type EachComponent = <T, ITEM extends JSXOutput = JSXOutput>(props: PublicProps<EachProps<T, ITEM>>, key: string | null, flags: number, dev?: DevJSX) => JSXOutput;
+
+declare interface EachProps<T, ITEM extends JSXOutput = JSXOutput> {
+    items: readonly T[];
+    item$: QRL<(item: T, index: number) => ITEM>;
+    key$: QRL<(item: T, index: number) => string>;
+}
+
+/** @internal */
+export declare const _eaT: ({ track }: TaskCtx) => Promise<void>;
+
 /** @internal */
 export declare const _EFFECT_BACK_REF: unique symbol;
 
+declare type EffectBackRef = SignalImpl | StoreTarget | PropsProxy;
+
 declare const enum EffectProperty {
     COMPONENT = ":",
     VNODE = "."
@@ -1065,42 +1313,26 @@ declare const enum EffectProperty {
  * - `EffectProperty.COMPONENT` if component
  * - `EffectProperty.VNODE` if VNode
  */
-declare type EffectSubscription = [
-Consumer,
-// EffectSubscriptionProp.CONSUMER
-EffectProperty | string,
-// EffectSubscriptionProp.PROPERTY or string for attributes
-Set<SignalImpl | StoreTarget> | null,
-// EffectSubscriptionProp.BACK_REF
-_SubscriptionData | null
-];
+declare class EffectSubscription {
+    consumer: Consumer;
+    property: EffectProperty | string;
+    backRef: Set<EffectBackRef> | null;
+    data: _SubscriptionData | null;
+    constructor(consumer: Consumer, property: EffectProperty | string, backRef?: Set<EffectBackRef> | null, data?: _SubscriptionData | null);
+}
 
 /** @internal */
-export declare type _ElementVNode = [
-_VNodeFlags.Element,
-////////////// 0 - Flags
-_VNode | null,
-/////////////// 1 - Parent
-_VNode | null,
-/////////////// 2 - Previous sibling
-_VNode | null,
-/////////////// 3 - Next sibling
-_VNode | null | undefined,
-/// 4 - First child - undefined if children need to be materialize
-_VNode | null | undefined,
-Element,
-//////////////////// 6 - Element
-string | undefined,
-(string | null)[]
-] & {
-    __brand__: 'ElementVNode';
-};
+export declare class _ElementVNode extends _VirtualVNode {
+    node: Element;
+    elementName: string | undefined;
+    constructor(key: string | null, flags: _VNodeFlags, parent: _ElementVNode | _VirtualVNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, props: Props | null, firstChild: _VNode | null | undefined, lastChild: _VNode | null | undefined, node: Element, elementName: string | undefined);
+}
 
 /** @internal */
 export declare const _EMPTY_ARRAY: any[];
 
-/** @public */
-declare type EntryStrategy = InlineEntryStrategy | HoistEntryStrategy | SingleEntryStrategy | HookEntryStrategy | SegmentEntryStrategy | ComponentEntryStrategy | SmartEntryStrategy;
+/** @internal */
+export declare const _EMPTY_OBJ: Record<string, any>;
 
 /** @public */
 export declare interface ErrorBoundaryStore {
@@ -1108,15 +1340,14 @@ export declare interface ErrorBoundaryStore {
 }
 
 /** @public */
-export declare const event$: <T>(qrl: T) => QRL_2<T>;
+export declare const event$: <T>(qrl: T) => QRL<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>;
@@ -1135,6 +1366,9 @@ declare type EventQRL<T extends string = AllEventKeys> = QRL<EventHandler<EventF
 /** @internal */
 export declare const eventQrl: <T>(qrl: QRL<T>) => QRL<T>;
 
+/** @internal */
+export declare function _executeSsrChores(container: SSRContainer, ssrNode: ISsrNode): ValueOrPromise<void>;
+
 declare type FilterBase<T> = {
     [K in keyof T as K extends string ? K extends Uppercase<K> ? never : any extends T[K] ? never : false extends IsAcceptableDOMValue<T[K]> ? never : IsReadOnlyKey<T, K> extends true ? never : K extends UnwantedKeys ? never : K : never]?: T[K];
 };
@@ -1147,6 +1381,13 @@ declare type Filtered<T, A = {}> = {
 /** @internal */
 export declare const _fnSignal: <T extends (...args: any) => any>(fn: T, args: Parameters<T>, fnStr?: string) => WrappedSignalImpl<any>;
 
+/**
+ * Force a store to recompute and schedule effects.
+ *
+ * @public
+ */
+export declare const forceStoreEffects: (value: StoreTarget, prop: keyof StoreTarget) => void;
+
 /** @public */
 export declare const Fragment: FunctionComponent<{
     children?: any;
@@ -1164,14 +1405,20 @@ export declare type FunctionComponent<P = unknown> = {
     renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput;
 }['renderFn'];
 
+/** 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 _getContextElement: () => unknown;
+export declare const _getContextContainer: () => _Container | undefined;
 
 /** @internal */
 export declare const _getContextEvent: () => unknown;
 
+/** @internal */
+export declare const _getContextHostElement: () => HostElement | undefined;
+
 /** @public */
-declare function getDomContainer(element: Element | _VNode): ClientContainer;
+declare function getDomContainer(element: Element): ClientContainer;
 export { getDomContainer as _getDomContainer }
 export { getDomContainer }
 
@@ -1200,22 +1447,14 @@ export declare function getLocale(defaultLocale?: string): string;
 export declare const getPlatform: () => CorePlatform;
 
 /** @internal */
-export declare function _getQContainerElement(element: Element | _VNode): Element | null;
+export declare function _getQContainerElement(element: Element): Element | null;
 
-/** @public */
-declare interface GlobalInjections {
-    tag: string;
-    attributes?: {
-        [key: string]: string;
-    };
-    location: 'head' | 'body';
-}
+/** Used by the optimizer for spread props operations @internal */
+export declare const _getVarProps: (props: PropsProxy | Record<string, unknown> | null | undefined) => Props | null;
 
 /**
- * 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
  */
@@ -1223,16 +1462,25 @@ declare function h<TYPE extends string | FunctionComponent<PROPS>, PROPS extends
 export { h as createElement }
 export { h }
 
-/** @public */
-declare interface HoistEntryStrategy {
-    type: 'hoist';
-}
+/**
+ * @returns True if the store has effects for the given prop
+ * @internal
+ */
+export declare const _hasStoreEffects: (value: StoreTarget, prop: keyof StoreTarget) => boolean;
 
-/** @deprecated Use SegmentStrategy instead */
-declare interface HookEntryStrategy {
-    type: 'hook';
-    manual?: Record<string, string>;
-}
+/**
+ * HMR event handler. The host VNode is captured at registration time via QRL captures.
+ *
+ * When called by the qwikloader or the test dispatch, `this` is the serialized captures string
+ * which we deserialize to get the host VNode. When called through `_qDispatch` (client-rendered),
+ * `_captures` is already set by `ensureQrlCaptures` in the QRL call chain.
+ *
+ * @internal
+ */
+export declare const _hmr: (this: string | undefined, event: CustomEvent<{
+    files: string[];
+    t: number;
+}>, element: Element) => void;
 
 declare type HostElement = _VNode | ISsrNode;
 
@@ -1345,16 +1593,19 @@ 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?: Readonly<unknown[]>) => QRL<T>;
 
 /** @internal */
-export declare const inlinedQrlDEV: <T = any>(symbol: T, symbolName: string, opts: QRLDev, lexicalScopeCapture?: any[]) => QRL<T>;
-
-/** @public */
-declare interface InlineEntryStrategy {
-    type: 'inline';
-}
+export declare const inlinedQrlDEV: <T = any>(symbol: T, symbolName: string, opts: QRLDev, lexicalScopeCapture?: Readonly<unknown[]>) => QRL<T>;
 
 /**
  * These are the HTML tags with handlers allowing plain callbacks, to be used for the JSX interface
@@ -1381,24 +1632,15 @@ 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 */
-    $element$: Element | undefined;
     /** The event we're currently handling */
     $event$: PossibleEvents | undefined;
-    /** The QRL function we're currently executing */
-    $qrl$: QRL | undefined;
     $effectSubscriber$: EffectSubscription | undefined;
     $locale$: string | undefined;
-    $container$: Container | undefined;
+    $container$: _Container | undefined;
 }
 
-declare type InvokeTuple = [Element, Event, URL?];
-
 declare type IsAcceptableDOMValue<T> = T extends boolean | number | string | null | undefined ? ((...args: any[]) => any) extends T ? false : true : false;
 
 declare type IsAny<T> = 0 extends T & 1 ? true : false;
@@ -1424,11 +1666,11 @@ export declare const isSignal: (value: any) => value is Signal<unknown>;
 /** @internal */
 export declare interface ISsrComponentFrame {
     componentNode: ISsrNode;
+    slots: (string | JSXChildren)[];
     scopedStyleIds: Set<string>;
     projectionScopedStyle: string | null;
     projectionComponentFrame: ISsrComponentFrame | null;
     projectionDepth: number;
-    releaseUnclaimedProjections(unclaimedProjections: (ISsrComponentFrame | JSXChildren | string)[]): void;
     consumeChildrenForSlot(projectionNode: ISsrNode, slotName: string): JSXChildren | null;
     distributeChildrenIntoSlots(children: JSXChildren, parentScopedStyle: string | null, parentComponentFrame: ISsrComponentFrame | null): void;
     hasSlot(slotName: string): boolean;
@@ -1436,27 +1678,52 @@ export declare interface ISsrComponentFrame {
 
 declare interface ISsrNode {
     id: string;
-    parentSsrNode: ISsrNode | null;
-    vnodeData?: VNodeData;
+    flags: SsrNodeFlags;
+    dirty: ChoreBits;
+    parentComponent: ISsrNode | null;
+    vnodeData: VNodeData;
+    currentFile: string | null;
     setProp(name: string, value: any): void;
     getProp(name: string): any;
     removeProp(name: string): void;
     addChild(child: ISsrNode): void;
+    setTreeNonUpdatable(): void;
 }
 
+/** @internal */
+export declare const _isStore: (value: object) => boolean;
+
 /** @internal */
 export declare function _isStringifiable(value: unknown): value is _Stringifiable;
 
+/** @internal */
+export declare const _isTask: (value: any) => value is Task;
+
+/** @internal */
+declare interface IStreamHandler {
+    flush(): void;
+    streamBlockStart(): void;
+    streamBlockEnd(): void;
+}
+
 /**
+ * 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 */
+/**
+ * @deprecated
+ * @internal
+ * No longer used since v2
+ */
 export declare const _jsxBranch: <T>(input?: T) => T | undefined;
 
 /** @internal @deprecated v1 compat */
@@ -1465,8 +1732,12 @@ export declare const _jsxC: (type: any, mutable: any, _flags: any, key: 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;
@@ -1474,6 +1745,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.
  *
@@ -1487,15 +1766,68 @@ export declare interface JSXNode<T extends string | FunctionComponent | unknown
     dev?: DevJSX;
 }
 
+declare const enum JSXNodeFlags {
+    None = 0,
+    StaticSubtree = 2,
+    HasCapturedProps = 4
+}
+
+declare class JSXNodeImpl<T = unknown> implements JSXNodeInternal<T> {
+    type: T;
+    children: JSXChildren;
+    flags: JSXNodeFlags;
+    toSort: boolean;
+    key: string | null;
+    varProps: Props;
+    constProps: Props | null;
+    dev?: DevJSX & {
+        stack: string | undefined;
+    };
+    _proxy: Props | null;
+    constructor(type: T, varProps: Props | null, constProps: Props | null, children: JSXChildren, flags: JSXNodeFlags, key: string | number | null | undefined, toSort?: boolean, dev?: DevJSX);
+    get props(): T extends FunctionComponent<infer PROPS> ? PROPS : Props;
+}
+
 /**
  * The internal representation of a JSX Node.
  *
  * @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;
+    /** Flags */
+    flags: JSXNodeFlags;
+    /**
+     * 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 `q-x: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 `q-x:event` version
+     */
+    constProps: Props | null;
+    /** The children of the node */
+    children: JSXChildren;
+    /** Filename etc for debugging */
+    dev?: DevJSX & {
+        stack: string | undefined;
+    };
 }
 
 /**
@@ -1511,6 +1843,13 @@ export declare const _jsxQ: (type: any, mutable: any, immutable: any, children:
 /** @internal @deprecated v1 compat */
 export declare const _jsxS: (type: any, mutable: any, immutable: any, _flags: any, key: any) => JSXNode<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
  * separated out. Furthermore, the varProps must be a sorted object, that is, the keys must be
@@ -1521,7 +1860,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.
@@ -1531,13 +1870,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
@@ -1545,11 +1884,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$`)
@@ -1558,6 +1901,26 @@ export declare type JSXTagName = keyof HTMLElementTagNameMap | Omit<string, keyo
  */
 export declare type KnownEventNames = LiteralUnion<AllEventKeys, string>;
 
+/**
+ * Shared lazy-loading reference that holds module loading metadata. Multiple QRLs pointing to the
+ * same chunk+symbol can share a single LazyRef, differing only in their captured scope.
+ */
+declare class LazyRef<TYPE = unknown> {
+    readonly $chunk$: string | null;
+    readonly $symbol$: string;
+    readonly $symbolFn$: undefined | null | (() => Promise<Record<string, TYPE>>);
+    $ref$?: (null | ValueOrPromise<TYPE>) | undefined;
+    $container$: _Container | undefined;
+    dev?: QRLDev | null | undefined;
+    qrls?: Set<any>;
+    constructor($chunk$: string | null, $symbol$: string, $symbolFn$: undefined | null | (() => Promise<Record<string, TYPE>>), $ref$?: (null | ValueOrPromise<TYPE>) | undefined, container?: _Container | null);
+    /** We don't read hash very often so let's not allocate a string for every QRL */
+    get $hash$(): string;
+    $setRef$(ref: ValueOrPromise<TYPE>): void;
+    /** Load the raw module export without capture binding. */
+    $load$(): ValueOrPromise<TYPE>;
+}
+
 declare type LcEvent<T extends string, C extends string = Lowercase<T>> = C extends keyof AllEventsMap ? AllEventsMap[C] : Event;
 
 declare type LcEventNameMap = {
@@ -1601,6 +1964,15 @@ declare interface LenientSVGProps<T extends Element> extends SVGAttributes, DOMA
  */
 declare type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 
+/** @internal */
+export declare const _mapApp_findIndx: <T>(array: (T | null)[], key: string, start: number) => number;
+
+/** @internal */
+export declare const _mapArray_get: <T>(array: (T | null)[], key: string, start: number) => T | null;
+
+/** @internal */
+export declare const _mapArray_set: <T>(array: (T | null)[], key: string, value: T | null, start: number, allowNullValue?: boolean) => void;
+
 declare type MediaSpecialAttrs = {
     crossOrigin?: HTMLCrossOriginAttribute;
 };
@@ -1647,10 +2019,10 @@ declare interface NodePropData {
 }
 
 /** @internal */
-export declare const _noopQrl: <T>(symbolName: string, lexicalScopeCapture?: any[]) => QRL<T>;
+export declare const _noopQrl: <T>(symbolName: string, lexicalScopeCapture?: Readonly<unknown[]>) => QRL<T>;
 
 /** @internal */
-export declare const _noopQrlDEV: <T>(symbolName: string, opts: QRLDev, lexicalScopeCapture?: any[]) => QRL<T>;
+export declare const _noopQrlDEV: <T>(symbolName: string, opts: QRLDev, lexicalScopeCapture?: Readonly<unknown[]>) => QRL<T>;
 
 /**
  * Returned type of the `noSerialize()` function. It will be TYPE or undefined.
@@ -1659,7 +2031,7 @@ export declare const _noopQrlDEV: <T>(symbolName: string, opts: QRLDev, lexicalS
  * @see noSerialize
  */
 export declare type NoSerialize<T> = (T & {
-    __no_serialize__: true;
+    __no_serialize__?: true;
 }) | undefined;
 
 /**
@@ -1717,6 +2089,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
@@ -1724,19 +2101,11 @@ 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';
 
-declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent | typeof ResourceEvent;
+declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent;
 
 /**
  * @deprecated This is no longer needed as the preloading happens automatically in qrl-class. You
@@ -1834,6 +2203,9 @@ export declare type PropFunction<T> = QRL<T>;
 
 declare type Props = Record<string, unknown>;
 
+/** @internal */
+declare const _PROPS_HANDLER: unique symbol;
+
 /**
  * Infers `Props` from the component or tag.
  *
@@ -1856,7 +2228,24 @@ export declare type PropsOf<COMP> = COMP extends string ? COMP extends keyof Qwi
 declare type PropsProxy = {
     [_VAR_PROPS]: Props;
     [_CONST_PROPS]: Props | null;
-};
+    [_OWNER]: JSXNodeInternal;
+    [_PROPS_HANDLER]: PropsProxyHandler;
+} & Record<string | symbol, unknown>;
+
+declare class PropsProxyHandler implements ProxyHandler<any> {
+    owner: JSXNodeImpl;
+    $effects$: undefined | Map<string | symbol, Set<EffectSubscription>>;
+    $container$: _Container | null;
+    constructor(owner: JSXNodeImpl);
+    get(_: any, prop: string | symbol): any;
+    set(_: any, prop: string | symbol, value: any): boolean;
+    deleteProperty(_: any, prop: string | symbol): boolean;
+    has(_: any, prop: string | symbol): boolean;
+    getOwnPropertyDescriptor(_: any, p: string | symbol): PropertyDescriptor | undefined;
+    ownKeys(): string[];
+}
+
+declare type PropType<T extends object, P extends keyof T> = P extends keyof T ? T[P] : 'value' extends keyof T ? T['value'] : never;
 
 /**
  * Extends the defined component PROPS, adding the default ones (children and q:slot) and allowing
@@ -1972,7 +2361,7 @@ export declare interface _QDocument extends Document {
  *
  * ```
  * <div q:base="/build/">
- *   <button on:click="./chunk-abc.js#onClick">...</button>
+ *   <button q-e:click="./chunk-abc.js#onClick">...</button>
  * </div>
  * ```
  *
@@ -1995,7 +2384,7 @@ export declare interface _QDocument extends Document {
  */
 export declare type QRL<TYPE = unknown> = {
     __qwik_serializable__?: any;
-    __brand__QRL__: TYPE;
+    __brand__QRL__?: TYPE;
     /** Resolve the QRL and return the actual value. */
     resolve(): Promise<TYPE>;
     /** The resolved value, once `resolve()` returns. */
@@ -2003,7 +2392,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>>;
 
 /**
@@ -2018,7 +2407,7 @@ export declare type QRL<TYPE = unknown> = {
  * @public
  * @see `QRL`, `$(...)`
  */
-export declare const qrl: <T = any>(chunkOrFn: string | (() => Promise<any>), symbol: string, lexicalScopeCapture?: any[], stackOffset?: number) => QRL<T>;
+export declare const qrl: <T = any>(chunkOrFn: string | (() => Promise<any>), symbol: string, lexicalScopeCapture?: Readonly<unknown[]> | null, stackOffset?: number) => QRL<T>;
 
 declare type QrlArgs<T> = T extends (...args: infer ARGS) => any ? ARGS : unknown[];
 
@@ -2030,31 +2419,53 @@ declare interface QRLDev {
 }
 
 /** @internal */
-export declare const qrlDEV: <T = any>(chunkOrFn: string | (() => Promise<any>), symbol: string, opts: QRLDev, lexicalScopeCapture?: any[]) => QRL<T>;
+export declare const qrlDEV: <T = any>(chunkOrFn: string | (() => Promise<any>), symbol: string, opts: QRLDev, lexicalScopeCapture?: Readonly<unknown[]>) => QRL<T>;
 
 /**
  * An event handler for Qwik events, can be a handler QRL or an array of handler QRLs.
  *
  * @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>;
+/** @internal */
+export declare type _QRLInternal<TYPE = unknown> = QRL<TYPE> & QRLInternalMethods<TYPE>;
 
 declare type QRLInternalMethods<TYPE> = {
     readonly $chunk$: string | null;
     readonly $symbol$: string;
     readonly $hash$: string;
-    $capture$: string[] | null;
-    $captureRef$: unknown[] | null;
-    dev: QRLDev | null;
+    /** If it's a string it's serialized */
+    readonly $captures$?: Readonly<unknown[]> | string | null;
+    dev?: QRLDev | null;
+    resolve(container?: _Container): Promise<TYPE>;
     resolved: undefined | TYPE;
-    resolve(containerEl?: Element): Promise<TYPE>;
     getSymbol(): string;
     getHash(): string;
     getCaptured(): unknown[] | null;
-    getFn(currentCtx?: InvokeContext | InvokeTuple, beforeFn?: () => void): TYPE extends (...args: any) => any ? (...args: Parameters<TYPE>) => ValueOrPromise<ReturnType<TYPE>> : unknown;
-    $setContainer$(containerEl: Element | undefined): Element | undefined;
+    getFn(currentCtx?: InvokeContext, 
+    /** If this returns false, the function execution will be skipped */
+    beforeFn?: () => void | false): TYPE extends (...args: any) => any ? (...args: Parameters<TYPE>) => ValueOrPromise<ReturnType<TYPE> | undefined> : unknown;
+    $callFn$(withThis: unknown, ...args: QrlArgs<TYPE>): ValueOrPromise<QrlReturn<TYPE>>;
+    $setDev$(dev: QRLDev | null): void;
+    /**
+     * "with captures" - Get a new QRL for these captures, reusing the lazy ref. It's an internal
+     * method but we need to have a stable name because it gets called in user code by the optimizer,
+     * after the $name$ props are mangled
+     */
+    w(captures: Readonly<unknown[]> | string | null): _QRLInternal<TYPE>;
+    /**
+     * "set ref" - Set the ref of the QRL. It's an internal method but we need to have a stable name
+     * because it gets called in user code by the optimizer, after the $name$ props are mangled
+     */
+    s(ref: ValueOrPromise<TYPE>): void;
+    /**
+     * Needed for deserialization and importing. We don't always have the container while creating
+     * qrls in async sections of code
+     */
+    readonly $container$?: _Container | null;
+    /** The shared lazy-loading reference */
+    readonly $lazy$: LazyRef<TYPE>;
 };
 
 declare type QrlReturn<T> = T extends (...args: any) => infer R ? Awaited<R> : unknown;
@@ -2071,50 +2482,20 @@ declare type QrlReturn<T> = T extends (...args: any) => infer R ? Awaited<R> : u
  */
 export declare const _qrlSync: <TYPE extends Function>(fn: TYPE, serializedFn?: string) => SyncQRL<TYPE>;
 
+/** @internal */
+export declare function _qrlToString(serializationContext: SerializationContext, qrl: _QRLInternal | SyncQRLInternal): string;
+
+/** @internal */
+export declare function _qrlToString(serializationContext: SerializationContext, qrl: _QRLInternal | SyncQRLInternal, raw: true): [string, string, string | null];
+
 /** @public @deprecated Use `AnimationEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikAnimationEvent<T = Element> = NativeAnimationEvent;
 
-/** @public */
-declare interface QwikAsset {
-    /** Name of the asset */
-    name: string | undefined;
-    /** Size of the asset */
-    size: number;
-}
-
 /** The Qwik DOM attributes without plain handlers, for use as function parameters @public */
 export declare interface QwikAttributes<EL extends Element> extends DOMAttributesBase<EL>, QwikEvents<EL, false> {
     class?: ClassList | undefined;
 }
 
-/** @public */
-declare interface QwikBundle {
-    /** Size of the bundle */
-    size: number;
-    /** Total size of this bundle's static import graph */
-    total: number;
-    /** Interactivity score of the bundle */
-    interactivity?: number;
-    /** Symbols in the bundle */
-    symbols?: string[];
-    /** Direct imports */
-    imports?: string[];
-    /** Dynamic imports */
-    dynamicImports?: string[];
-    /** Source files of the bundle */
-    origins?: string[];
-}
-
-/**
- * Bundle graph.
- *
- * Format: [ 'bundle-a.js', 3, 5 // Depends on 'bundle-b.js' and 'bundle-c.js' 'bundle-b.js', 5, //
- * Depends on 'bundle-c.js' 'bundle-c.js', ]
- *
- * @public
- */
-declare type QwikBundleGraph = Array<string | number>;
-
 /** @public @deprecated Use `Event` and use the second argument to the handler function for the current event target. Also note that in Qwik, onInput$ with the InputEvent is the event that behaves like onChange in React. */
 export declare type QwikChangeEvent<T = Element> = Event;
 
@@ -2124,13 +2505,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> {
 }
@@ -2139,11 +2526,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
  *
@@ -2214,71 +2603,18 @@ 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>;
-};
-
-/**
- * The metadata of the build. One of its uses is storing where QRL symbols are located.
- *
- * @public
- */
-declare interface QwikManifest {
-    /** Content hash of the manifest, if this changes, the code changed */
-    manifestHash: string;
-    /** QRL symbols */
-    symbols: {
-        [symbolName: string]: QwikSymbol;
-    };
-    /** Where QRLs are located. The key is the symbol name, the value is the bundle fileName */
-    mapping: {
-        [symbolName: string]: string;
-    };
-    /**
-     * All code bundles, used to know the import graph. The key is the bundle fileName relative to
-     * "build/"
-     */
-    bundles: {
-        [fileName: string]: QwikBundle;
-    };
-    /** All assets. The key is the fileName relative to the rootDir */
-    assets?: {
-        [fileName: string]: QwikAsset;
-    };
-    /** All bundles in a compact graph format with probabilities */
-    bundleGraph?: QwikBundleGraph;
-    /** The bundle graph fileName */
-    bundleGraphAsset?: string;
-    /** The preloader bundle fileName */
-    preloader?: string;
-    /** The Qwik core bundle fileName */
-    core?: string;
-    /** The Qwik loader bundle fileName */
-    qwikLoader?: string;
-    /** CSS etc to inject in the document head */
-    injections?: GlobalInjections[];
-    /** The version of the manifest */
-    version: string;
-    /** The options used to build the manifest */
-    options?: {
-        target?: string;
-        buildMode?: string;
-        entryStrategy?: {
-            type: EntryStrategy['type'];
-        };
-    };
-    /** The platform used to build the manifest */
-    platform?: {
-        [name: string]: string;
-    };
-}
+    [K in keyof QwikJSXEvents]?: QRLEventHandlerMulti<QwikJSXEvents[K], EL> | EventHandler<QwikJSXEvents[K], EL>;
+};
 
 /** @public @deprecated Use `MouseEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikMouseEvent<T = Element, E = NativeMouseEvent> = E;
@@ -2286,6 +2622,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;
 
@@ -2298,32 +2640,12 @@ export declare type QwikSVGElements = {
     [K in keyof Omit<SVGElementTagNameMap, keyof HTMLElementTagNameMap>]: SVGProps<SVGElementTagNameMap[K]>;
 };
 
-/** @public */
-declare interface QwikSymbol {
-    origin: string;
-    displayName: string;
-    hash: string;
-    canonicalFilename: string;
-    ctxKind: 'function' | 'eventHandler';
-    ctxName: string;
-    /** Whether the symbol captures a variable */
-    captures: boolean;
-    parent: string | null;
-    loc: [number, number];
-    /** The parameter names if it's a function with parameters */
-    paramNames?: string[];
-    /** The transformed names of scoped variables, if any */
-    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;
     reqTime: number;
     qBase?: string;
-    qManifest?: string;
-    qVersion?: string;
     href?: string;
 }>;
 
@@ -2337,15 +2659,20 @@ 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;
 
-/** @public */
+declare type QwikWindowEventMap = Omit<WindowEventHandlersEventMap, keyof QwikDocumentEventMap> & QwikDocumentEventMap;
+
+/** @public @deprecated not used */
 export declare interface ReadonlySignal<T = unknown> {
     readonly value: T;
 }
@@ -2366,9 +2693,21 @@ 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;
 
+/**
+ * Remove an external projection from its parent and clean up.
+ *
+ * @internal
+ */
+export declare function _removeProjection(container: _Container, parentVNode: _VirtualVNode, vnode: _VirtualVNode, slotName: string): void;
+
 /**
  * Render JSX.
  *
@@ -2392,6 +2731,8 @@ export declare const RenderOnce: FunctionComponent<{
     key?: string | number | null | undefined;
 }>;
 
+/** @internal */
+/** @internal */
 /** @public */
 export declare interface RenderOptions {
     serverData?: Record<string, any>;
@@ -2412,82 +2753,61 @@ export declare interface RenderSSROptions {
     manifestHash: string;
 }
 
-/** @public */
-declare interface ResolvedManifest {
-    mapper: SymbolMapper;
-    manifest: ServerQwikManifest;
-    injections?: GlobalInjections[];
-    bundleGraph?: QwikBundleGraph;
-}
-
 /**
- * This method works like an async memoized function that runs whenever some tracked value changes
- * and returns some data.
- *
- * `useResource` however returns immediate a `ResourceReturn` object that contains the data and a
- * state that indicates if the data is available or not.
- *
- * The status can be one of the following:
- *
- * - `pending` - the data is not yet available.
- * - `resolved` - the data is available.
- * - `rejected` - the data is not available due to an error or timeout.
- *
- * Be careful when using a `try/catch` statement in `useResource$`. If you catch the error and don't
- * re-throw it (or a new Error), the resource status will never be `rejected`.
- *
- * ### Example
- *
- * Example showing how `useResource` to perform a fetch to request the weather, whenever the input
- * city name changes.
+ * Resumes selected state (e.g. polling AsyncSignals) by deserializing captures. Used for
+ * document:onQIdle to resume async signals with active polling.
  *
+ * @internal
+ */
+export declare function _res(this: string | undefined, _: any, element: Element): void;
+
+/** @internal */
+export declare const _resolveContextWithoutSequentialScope: <STATE>(context: ContextId<STATE>) => STATE | undefined;
+
+/**
  * ```tsx
  * const Cmp = component$(() => {
- *   const cityS = useSignal('');
+ *   const city = useSignal('');
  *
- *   const weatherResource = useResource$(async ({ track, cleanup }) => {
- *     const cityName = track(cityS);
- *     const abortController = new AbortController();
- *     cleanup(() => abortController.abort('cleanup'));
+ *   const weather = useAsync$(async ({ track, cleanup, abortSignal }) => {
+ *     const cityName = track(city);
  *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
- *       signal: abortController.signal,
+ *       signal: abortSignal,
  *     });
- *     const data = await res.json();
- *     return data as { temp: number };
+ *     const temp = (await res.json()) as { temp: number };
+ *     return temp;
  *   });
  *
  *   return (
  *     <div>
- *       <input name="city" bind:value={cityS} />
- *       <Resource
- *         value={weatherResource}
- *         onResolved={(weather) => {
- *           return <div>Temperature: {weather.temp}</div>;
- *         }}
- *       />
+ *       <input name="city" bind:value={city} />
+ *       <div>
+ *         Temperature:{' '}
+ *         {weather.loading
+ *           ? 'Loading...'
+ *           : weather.error
+ *             ? `Error: ${weather.error.message}`
+ *             : weather.value.temp}
+ *       </div>
  *     </div>
  *   );
  * });
  * ```
  *
+ * @deprecated Use `useAsync$` instead, which is more efficient, and has a more flexible API. Just
+ *   read the `loading` and `error` properties from the returned signal to determine the status.
  * @public
- * @see Resource
- * @see ResourceReturn
  */
-export declare const Resource: <T>(props: ResourceProps<T>) => JSXOutput;
+export declare const Resource: <T>({ value, onResolved, onPending, onRejected, }: ResourceProps<T>) => JSXOutput;
 
 /** @public */
-export declare interface ResourceCtx<T> {
-    readonly track: Tracker;
-    cleanup(callback: () => void): void;
+export declare interface ResourceCtx<T = unknown> extends AsyncCtx<T> {
+    /** @deprecated Does not do anything */
     cache(policyOrMilliseconds: number | 'immutable'): void;
-    readonly previous: T | undefined;
 }
 
-declare const ResourceEvent = "qResource";
-
 /** @public */
-export declare type ResourceFn<T> = (ctx: ResourceCtx<unknown>) => ValueOrPromise<T>;
+export declare type ResourceFn<T> = (ctx: ResourceCtx) => ValueOrPromise<T>;
 
 /**
  * Options to pass to `useResource$()`
@@ -2504,71 +2824,64 @@ export declare interface ResourceOptions {
 }
 
 /** @public */
-export declare interface ResourcePending<T> {
-    readonly value: Promise<T>;
-    readonly loading: boolean;
-}
+export declare type ResourcePending<T> = ResourceReturn<T>;
 
 /** @public */
 export declare interface ResourceProps<T> {
     readonly value: ResourceReturn<T> | Signal<Promise<T> | T> | Promise<T>;
-    onResolved: (value: T) => JSXOutput;
-    onPending?: () => JSXOutput;
-    onRejected?: (reason: Error) => JSXOutput;
+    onResolved: (value: T) => JSXOutput | Promise<JSXOutput>;
+    onPending?: () => JSXOutput | Promise<JSXOutput>;
+    onRejected?: (reason: Error) => JSXOutput | Promise<JSXOutput>;
 }
 
 /** @public */
-export declare interface ResourceRejected<T> {
-    readonly value: Promise<T>;
-    readonly loading: boolean;
-}
+export declare type ResourceRejected<T> = ResourceReturn<T>;
 
 /** @public */
-export declare interface ResourceResolved<T> {
-    readonly value: Promise<T>;
-    readonly loading: boolean;
-}
+export declare type ResourceResolved<T> = ResourceReturn<T>;
 
 /** @public */
-export declare type ResourceReturn<T> = ResourcePending<T> | ResourceResolved<T> | ResourceRejected<T>;
+export declare type ResourceReturn<T> = {
+    readonly value: Promise<T>;
+    readonly loading: boolean;
+};
 
 declare interface ResourceReturnInternal<T> {
     __brand: 'resource';
-    _state: 'pending' | 'resolved' | 'rejected';
-    _resolved: T | undefined;
-    _error: Error | undefined;
-    _cache: number;
-    _timeout: number;
     value: Promise<T>;
     loading: boolean;
+    signal: AsyncSignal<{
+        r: T;
+    }>;
 }
 
 /** @internal */
-export declare const _restProps: (props: PropsProxy, omit: string[], target?: Props) => Props;
+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.
+ * The resource function wrapper
  *
  * @internal
  */
-export declare const _run: (...args: unknown[]) => ValueOrPromise_2<void>;
+export declare const _rsc: <T>(arg: ResourceCtx<T>) => Promise<{
+    r: T;
+}>;
 
-declare type Scheduler = ReturnType<typeof createScheduler>;
+/**
+ * This is called by qwik-loader to run a QRL. It has to be synchronous when possible.
+ *
+ * @internal
+ */
+export declare function _run(this: string, event: Event, element: Element): ValueOrPromise<unknown>;
 
+/** 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 */
-declare interface SegmentEntryStrategy {
-    type: 'segment';
-    manual?: Record<string, string>;
-}
-
 declare interface SerializationContext {
-    $serialize$: () => void;
+    $serialize$: () => ValueOrPromise<void>;
     $symbolToChunkResolver$: SymbolToChunkResolver;
     /**
      * Map from object to parent and index reference.
@@ -2580,49 +2893,64 @@ 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.
-     */
-    $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.
+     * Returns the index of the root object.
      */
-    $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[];
-    $pathMap$: 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;
-    $writer$: StreamWriter_2;
+    $writer$: StreamWriter;
     $syncFns$: string[];
     $eventQrls$: Set<QRL>;
     $eventNames$: Set<string>;
-    $resources$: Set<ResourceReturnInternal<unknown>>;
     $renderSymbols$: Set<string>;
     $storeProxyMap$: ObjToProxyMap;
-    $getProp$: (obj: any, prop: string) => any;
+    $eagerResume$: Set<unknown>;
     $setProp$: (obj: any, prop: string, value: any) => void;
 }
 
+declare const enum SerializationSignalFlags {
+    SERIALIZATION_STRATEGY_NEVER = 8,
+    SERIALIZATION_STRATEGY_ALWAYS = 16,
+    SERIALIZATION_ALL_STRATEGIES = 24
+}
+
+/**
+ * Serialization strategy for computed and async signals. This determines whether to serialize their
+ * value during SSR.
+ *
+ * - `never`: The value is never serialized. When the component is resumed, the value will be
+ *   recalculated when it is first read.
+ * - `always`: The value is always serialized. This is the default.
+ *
+ * **IMPORTANT**: When you use `never`, your serialized HTML is smaller, but the recalculation will
+ * trigger subscriptions, meaning that other signals using this signal will recalculate, even if
+ * this signal didn't change.
+ *
+ * This is normally not a problem, but for async signals it may mean fetching something again.
+ *
+ * @public
+ */
+export declare type SerializationStrategy = 'never' | 'always';
+
 /**
  * Serialize data to string using SerializationContext.
  *
- * @param data - Data to serialize
  * @internal
  */
-export declare function _serialize(data: unknown[]): Promise<string>;
+export declare function _serialize<T>(data: T): Promise<string>;
 
 /**
  * Serialize and deserialize custom objects.
@@ -2685,9 +3013,9 @@ declare interface SerializerSignal<T> extends ComputedSignal<T> {
  * @public
  */
 declare class SerializerSignalImpl<T, S> extends ComputedSignalImpl<T> {
-    constructor(container: Container | null, argQrl: QRLInternal<SerializerArg<T, S>>);
+    constructor(container: _Container | null, argQrl: _QRLInternal<SerializerArg<T, S>>);
     $didInitialize$: boolean;
-    $computeIfNeeded$(): boolean;
+    $computeIfNeeded$(): void;
 }
 
 /**
@@ -2708,12 +3036,8 @@ declare class SerializerSignalImpl<T, S> extends ComputedSignalImpl<T> {
  */
 export declare const SerializerSymbol: unique symbol;
 
-/**
- * The manifest values that are needed for SSR.
- *
- * @public
- */
-declare type ServerQwikManifest = Pick<QwikManifest, 'manifestHash' | 'injections' | 'bundleGraph' | 'bundleGraphAsset' | 'mapping' | 'preloader' | 'core' | 'qwikLoader'>;
+/** @internal */
+export declare function _setEvent(serializationCtx: SerializationContext, key: string, rawValue: unknown, hasMovedCaptures: boolean): string | null;
 
 /**
  * Sets the `CorePlatform`.
@@ -2727,10 +3051,19 @@ declare type ServerQwikManifest = Pick<QwikManifest, 'manifestHash' | 'injection
  */
 export declare const setPlatform: (plt: CorePlatform) => CorePlatform;
 
+/**
+ * Set the DOM target element for an external projection VNode.
+ *
+ * When the cursor walker processes this VNode, DOM operations will target this element instead of
+ * walking the parent chain.
+ *
+ * @internal
+ */
+export declare function _setProjectionTarget(vnode: _VirtualVNode, targetElement: Element): void;
+
 /** @internal */
-export declare abstract class _SharedContainer implements Container {
+export declare abstract class _SharedContainer implements _Container {
     readonly $version$: string;
-    readonly $scheduler$: Scheduler;
     readonly $storeProxyMap$: ObjToProxyMap;
     readonly $locale$: string;
     readonly $getObjectById$: (id: number | string) => any;
@@ -2738,7 +3071,10 @@ export declare abstract class _SharedContainer implements Container {
     $currentUniqueId$: number;
     $instanceHash$: string | null;
     $buildBase$: string | null;
-    constructor(scheduleDrain: () => void, journalFlush: () => void, serverData: Record<string, any>, locale: string);
+    $renderPromise$: Promise<void> | null;
+    $resolveRenderPromise$: (() => void) | null;
+    $pendingCount$: number;
+    constructor(serverData: Record<string, any>, locale: string);
     trackSignalValue<T>(signal: Signal, subscriber: HostElement, property: string, data: _SubscriptionData): T;
     serializationCtxFactory(NodeConstructor: {
         new (...rest: any[]): {
@@ -2749,8 +3085,9 @@ export declare abstract class _SharedContainer implements Container {
             __brand__: 'DomRef';
         };
     } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter): SerializationContext;
+    $checkPendingCount$(): void;
     abstract ensureProjectionResolved(host: HostElement): void;
-    abstract handleError(err: any, $host$: HostElement): void;
+    abstract handleError(err: any, $host$: HostElement | null): void;
     abstract getParentHost(host: HostElement): HostElement | null;
     abstract setContext<T>(host: HostElement, context: ContextId<T>, value: T): void;
     abstract resolveContext<T>(host: HostElement, contextId: ContextId<T>): T | undefined;
@@ -2771,20 +3108,37 @@ export declare abstract class _SharedContainer implements Container {
  *
  * @public
  */
-export declare interface Signal<T = any> extends ReadonlySignal<T> {
+export declare interface Signal<T = any> {
+    /** Reading from this subscribes to updates; writing to this triggers updates. */
     value: T;
+    /** Reading from this does not subscribe to updates; writing to this does not trigger updates. */
+    untrackedValue: T;
+    /**
+     * Use this to trigger running subscribers, for example when the value mutated but remained the
+     * same object.
+     */
+    trigger(): void;
 }
 
 declare const enum SignalFlags {
-    INVALID = 1
+    INVALID = 1,
+    RUN_EFFECTS = 2
 }
 
 declare class SignalImpl<T = any> implements Signal<T> {
     $untrackedValue$: T;
     /** Store a list of effects which are dependent on this signal. */
-    $effects$: null | Set<EffectSubscription>;
-    $container$: Container | null;
-    constructor(container: Container | null, value: T);
+    $effects$: undefined | Set<EffectSubscription>;
+    $container$: _Container | null;
+    $wrappedSignal$: WrappedSignalImpl<T> | null;
+    constructor(container: _Container | null | undefined, value: T);
+    /**
+     * Use this to trigger running subscribers, for example when the calculated value has mutated but
+     * remained the same object
+     */
+    trigger(): void;
+    /** @deprecated Use `trigger()` instead */
+    force(): void;
     get untrackedValue(): T;
     set untrackedValue(value: T);
     get value(): T;
@@ -2802,12 +3156,6 @@ declare interface SimplifiedServerRequestEvent<T = unknown> {
     request: Request;
 }
 
-/** @public */
-declare interface SingleEntryStrategy {
-    type: 'single';
-    manual?: Record<string, string>;
-}
-
 /** @public */
 declare type Size = number | string;
 
@@ -2825,12 +3173,6 @@ export declare const Slot: FunctionComponent<{
     children?: JSXChildren;
 }>;
 
-/** @public */
-declare interface SmartEntryStrategy {
-    type: 'smart';
-    manual?: Record<string, string>;
-}
-
 /** @public */
 export declare interface SnapshotListener {
     key: string;
@@ -3071,39 +3413,36 @@ declare type SpecialAttrs = {
     [key: string]: {};
 };
 
-declare type SsrAttrKey = string;
-
-declare type SsrAttrs = Array<SsrAttrKey | SsrAttrValue>;
-
-declare type SsrAttrValue = string | Signal<any> | boolean | object | null;
-
 /** @public */
 export declare const SSRComment: FunctionComponent<{
     data: string;
 }>;
 
-declare interface SSRContainer extends Container {
+declare interface SSRContainer extends _Container {
     readonly tag: string;
     readonly isHtml: boolean;
+    readonly size: number;
     readonly writer: StreamWriter;
+    readonly streamHandler: IStreamHandler;
     readonly serializationCtx: SerializationContext;
     readonly symbolToChunkResolver: SymbolToChunkResolver;
     readonly resolvedManifest: ResolvedManifest;
     additionalHeadNodes: Array<JSXNodeInternal>;
     additionalBodyNodes: Array<JSXNodeInternal>;
-    unclaimedProjectionComponentFrameQueue: ISsrComponentFrame[];
+    $noScriptHere$: number;
+    write(text: string): void;
     openContainer(): void;
     closeContainer(): ValueOrPromise<void>;
-    openElement(elementName: string, varAttrs: SsrAttrs | null, constAttrs?: SsrAttrs | null, currentFile?: string | null): string | undefined;
+    openElement(elementName: string, key: string | null, varAttrs: Props, constAttrs: Props | null, styleScopedId: string | null, currentFile: string | null, hasMovedCaptures?: boolean): string | undefined;
     closeElement(): ValueOrPromise<void>;
-    openFragment(attrs: SsrAttrs): void;
+    openFragment(attrs: Props): void;
     closeFragment(): void;
-    openProjection(attrs: SsrAttrs): void;
+    openProjection(attrs: Props): void;
     closeProjection(): void;
-    openComponent(attrs: SsrAttrs): void;
+    openComponent(attrs: Props): void;
     getComponentFrame(projectionDepth: number): ISsrComponentFrame | null;
     getParentComponentFrame(): ISsrComponentFrame | null;
-    closeComponent(): void;
+    closeComponent(): Promise<void>;
     textNode(text: string): void;
     htmlNode(rawHtml: string): void;
     commentNode(text: string): void;
@@ -3112,8 +3451,14 @@ declare interface SSRContainer extends Container {
     addUnclaimedProjection(frame: ISsrComponentFrame, name: string, children: JSXChildren): void;
     isStatic(): boolean;
     render(jsx: JSXOutput): Promise<void>;
+    renderJSX(jsx: JSXOutput, options: {
+        currentStyleScoped: string | null;
+        parentComponentFrame: ISsrComponentFrame | null;
+    }): Promise<void>;
     emitPreloaderPre(): void;
     emitQwikLoaderAtTopIfNeeded(): void;
+    emitPatchDataIfNeeded(): void;
+    addBackpatchEntry(ssrNodeId: string, attrName: string, serializedValue: string | boolean | null): void;
 }
 
 /** @public */
@@ -3129,6 +3474,10 @@ declare type SsrNode = {
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
 };
 
+declare const enum SsrNodeFlags {
+    Updatable = 1
+}
+
 /** @public */
 export declare const SSRRaw: FunctionComponent<{
     data: string;
@@ -3143,38 +3492,22 @@ export declare const SSRStreamBlock: FunctionComponent<{
 }>;
 
 /** @public */
-export declare type SSRStreamChildren = AsyncGenerator<JSXChildren, void, any> | ((stream: StreamWriter) => Promise<void>) | (() => AsyncGenerator<JSXChildren, void, any>);
+export declare type SSRStreamChildren = AsyncGenerator<JSXChildren, void, any> | ((stream: SSRStreamWriter) => Promise<void>) | (() => AsyncGenerator<JSXChildren, void, any>);
 
 /** @public */
 export declare type SSRStreamProps = {
     children: SSRStreamChildren;
 };
 
+/** @public */
+export declare interface SSRStreamWriter {
+    write(chunk: JSXOutput): void;
+}
+
 declare type StopPropagation = {
     [K in keyof HTMLElementEventMap as `stoppropagation:${K}`]?: boolean;
 };
 
-declare const enum StoreFlags {
-    NONE = 0,
-    RECURSIVE = 1,
-    IMMUTABLE = 2
-}
-
-declare class StoreHandler implements ProxyHandler<StoreTarget> {
-    $flags$: StoreFlags;
-    $container$: Container | null;
-    $effects$: null | Map<string | symbol, Set<EffectSubscription>>;
-    constructor($flags$: StoreFlags, $container$: Container | null);
-    toString(): string;
-    get(target: StoreTarget, prop: string | symbol): any;
-    /** In the case of oldValue and value are the same, the effects are not triggered. */
-    set(target: StoreTarget, prop: string | symbol, value: any): boolean;
-    deleteProperty(target: StoreTarget, prop: string | symbol): boolean;
-    has(target: StoreTarget, prop: string | symbol): boolean;
-    ownKeys(target: StoreTarget): ArrayLike<string | symbol>;
-    getOwnPropertyDescriptor(target: StoreTarget, prop: string | symbol): PropertyDescriptor | undefined;
-}
-
 declare type StoreTarget = Record<string | symbol, any>;
 
 /** @internal */
@@ -3464,9 +3797,6 @@ export declare interface SVGAttributes<T extends Element = Element> extends Aria
 export declare interface SVGProps<T extends Element> extends SVGAttributes, QwikAttributes<T> {
 }
 
-/** @public */
-declare type SymbolMapper = Record<string, readonly [symbol: string, chunk: string]>;
-
 declare type SymbolToChunkResolver = (symbol: string) => string;
 
 /**
@@ -3480,18 +3810,19 @@ declare type SymbolToChunkResolver = (symbol: string) => string;
  */
 export declare const sync$: <T extends Function>(fn: T) => SyncQRL<T>;
 
+declare const SYNC_QRL = "<sync>";
+
 /** @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 SyncQRLInternal = _QRLInternal & SyncQRLSymbol;
+
+declare interface SyncQRLSymbol {
+    $symbol$: typeof SYNC_QRL;
 }
 
 declare type TableCellSpecialAttrs = {
@@ -3501,49 +3832,49 @@ declare type TableCellSpecialAttrs = {
     valign?: 'top' | 'middle' | 'bottom' | 'baseline' | undefined;
 };
 
-declare class Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B> | ResourceReturnInternal<B>> {
+declare class Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B>> {
     $flags$: number;
     $index$: number;
     $el$: HostElement;
-    $qrl$: QRLInternal<T>;
-    $state$: Signal<B> | ResourceReturnInternal<B> | undefined;
-    $destroy$: NoSerialize<() => void> | null;
-    constructor($flags$: number, $index$: number, $el$: HostElement, $qrl$: QRLInternal<T>, $state$: Signal<B> | ResourceReturnInternal<B> | undefined, $destroy$: NoSerialize<() => void> | null);
+    $qrl$: _QRLInternal<T>;
+    $state$: Signal<B> | undefined;
+    $destroy$: (() => void) | null;
+    $destroyPromise$: Promise<void> | undefined;
+    $taskPromise$: Promise<void> | null;
+    constructor($flags$: number, $index$: number, $el$: HostElement, $qrl$: _QRLInternal<T>, $state$: Signal<B> | undefined, $destroy$: (() => void) | null);
 }
 
 /**
- * Used internally as a qrl event handler to schedule a task.
+ * Used internally as a qwikloader event handler to schedule a task. The `this` context is the
+ * captures part of the QRL, provided by qwikloader.
  *
  * @internal
  */
-export declare const _task: (_event: Event, element: Element) => void;
+export declare function _task(this: string, _event: Event, element: Element): void;
 
 /** @public */
 export declare interface TaskCtx {
     track: Tracker;
-    cleanup: (callback: () => void) => void;
+    cleanup: (callback: () => ValueOrPromise<void>) => void;
 }
 
 declare const TaskEvent = "qTask";
 
 /** @public */
-export declare type TaskFn = (ctx: TaskCtx) => ValueOrPromise<void | (() => void)>;
+export declare type TaskFn = (ctx: TaskCtx) => ValueOrPromise<void | (() => ValueOrPromise<void>)>;
+
+/** @public */
+export declare interface TaskOptions {
+    /** Block the rendering of the component until the task completes. Default is `true` */
+    deferUpdates?: boolean;
+}
 
 /** @internal */
-export declare type _TextVNode = [
-_VNodeFlags.Text | _VNodeFlags.Inflated,
-// 0 - Flags
-_VNode | null,
-///////////////// 1 - Parent
-_VNode | null,
-///////////////// 2 - Previous sibling
-_VNode | null,
-///////////////// 3 - Next sibling
-Text | null | undefined,
-string
-] & {
-    __brand__: 'TextVNode';
-};
+export declare class _TextVNode extends _VNode {
+    node: Text | null;
+    text: string | undefined;
+    constructor(flags: _VNodeFlags, parent: _VNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, props: Props | null, node: Text | null, text: string | undefined);
+}
 
 /**
  * Used to signal to Qwik which state should be watched for changes.
@@ -3564,6 +3895,8 @@ string
  *   useTask$(({ track }) => {
  *     // Any signals or stores accessed inside the task will be tracked
  *     const count = track(() => store.count);
+ *     // For stores you can also pass the store and specify the property
+ *     track(store, 'count');
  *     // You can also pass a signal to track() directly
  *     const signalCount = track(signal);
  *     store.doubleCount = count + signalCount;
@@ -3630,12 +3963,22 @@ export declare interface Tracker {
     <T extends object, P extends keyof T>(obj: T, prop: P): T[P];
 }
 
+/** @internal */
+export declare const _UNINITIALIZED: unique symbol;
+
 /**
- * Don't track listeners for this callback
+ * Get the value of the expression without tracking listeners. A function will be invoked, signals
+ * will return their value, and stores will be unwrapped (they return the backing object).
+ *
+ * When you pass a function, you can also pass additional arguments that the function will receive.
+ *
+ * Note that stores are not unwrapped recursively.
  *
+ * @param expr - The function or object to evaluate without tracking.
+ * @param args - Additional arguments to pass when `expr` is a function.
  * @public
  */
-export declare const untrack: <T>(fn: () => T) => T;
+export declare const untrack: <T, A extends any[]>(expr: ((...args: A) => T) | Signal<T> | T, ...args: A) => T;
 
 declare type UnwantedKeys = keyof HTMLAttributesBase | keyof DOMAttributes<any> | keyof ARIAMixin | keyof GlobalEventHandlers | 'enterKeyHint' | 'innerText' | 'innerHTML' | 'outerHTML' | 'inputMode' | 'outerText' | 'nodeValue' | 'textContent';
 
@@ -3648,19 +3991,37 @@ declare type UnwantedKeys = keyof HTMLAttributesBase | keyof DOMAttributes<any>
 export declare const unwrapStore: <T>(value: T) => T;
 
 /**
- * Creates a computed signal which is calculated from the given function. A computed signal is a
- * signal which is calculated from other signals. When the signals change, the computed signal is
- * recalculated, and if the result changed, all tasks which are tracking the signal will be re-run
- * and all components that read the signal will be re-rendered.
+ * Update the props on an external projection VNode and trigger re-rendering.
  *
- * The function must be synchronous and must not have any side effects.
+ * @internal
+ */
+export declare function _updateProjectionProps(container: _Container, vnode: _VirtualVNode, newProps: Record<string, unknown>): void;
+
+/**
+ * Creates an AsyncSignal which holds the result of the given async function. If the function uses
+ * `track()` to track reactive state, and that state changes, the AsyncSignal is recalculated, and
+ * if the result changed, all tasks which are tracking the AsyncSignal will be re-run and all
+ * subscribers (components, tasks etc) that read the AsyncSignal will be updated.
+ *
+ * If the async function throws an error, the AsyncSignal will capture the error and set the `error`
+ * property. The error can be cleared by re-running the async function successfully.
+ *
+ * While the async function is running, the `loading` property will be set to `true`. Once the
+ * function completes, `loading` will be set to `false`.
+ *
+ * If the value has not yet been resolved, reading the AsyncSignal will throw a Promise, which will
+ * retry the component or task once the value resolves.
+ *
+ * If the value has been resolved, but the async function is re-running, reading the AsyncSignal
+ * will subscribe to it and return the last resolved value until the new value is ready. As soon as
+ * the new value is ready, the subscribers will be updated.
  *
  * @public
  */
-export declare const useAsyncComputed$: <T>(qrl: AsyncComputedFn<T>) => AsyncComputedReturnType<T>;
+export declare const useAsync$: <T>(qrl: AsyncFn<T>, options?: AsyncSignalOptions<T> | undefined) => AsyncSignal<T>;
 
 /** @internal */
-export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>) => AsyncComputedReturnType<T>;
+export declare const useAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
 
 /**
  * Creates a computed signal which is calculated from the given function. A computed signal is a
@@ -3672,20 +4033,32 @@ export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>) => A
  *
  * @public
  */
-export declare const useComputed$: <T>(qrl: ComputedFn<T>) => ComputedReturnType<T>;
+export declare const useComputed$: <T>(qrl: ComputedFn<T>, options?: ComputedOptions | undefined) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>) => ComputedReturnType<T>;
+export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions) => ComputedReturnType<T>;
 
 /**
  * Stores a value which is retained for the lifetime of the component. Subsequent calls to
  * `useConstant` will always return the first value given.
  *
- * If the value is a function, the function is invoked once to calculate the actual value.
+ * If the value is a function, the function is invoked once to calculate the actual value. You can
+ * then also pass arguments to call the function with, so that you don't need to create a new
+ * function on every render.
+ *
+ * @example
+ *
+ * ```tsx
+ * const fixedRandomValue = useConstant(() => Math.random);
+ * const otherFixedRandomValue = useConstant(Math.random);
+ *
+ * const getConfig = (env: string) => { ... }
+ * const config = useConstant(getConfig, environment);
+ * ```
  *
  * @public
  */
-export declare const useConstant: <T>(value: (() => T) | T) => T;
+export declare const useConstant: <T, A extends any[]>(value: ((...args: A) => T) | T, ...args: A) => T;
 
 declare interface UseContext {
     <STATE, T>(context: ContextId<STATE>, transformer: (value: STATE) => T): T;
@@ -3797,6 +4170,14 @@ export declare const useContextProvider: <STATE>(context: ContextId<STATE>, newV
 /** @public */
 export declare const useErrorBoundary: () => ErrorBoundaryStore;
 
+/**
+ * Injected by the optimizer into component$ bodies in HMR mode. Registers a document event listener
+ * that triggers component re-render on HMR updates.
+ *
+ * @internal
+ */
+export declare function _useHmr(devPath: string): void;
+
 /** @public */
 export declare const useId: () => string;
 
@@ -3808,6 +4189,7 @@ export declare const useId: () => string;
  * NOTE: `useLexicalScope` method can only be used in the synchronous portion of the callback
  * (before any `await` statements.)
  *
+ * @deprecated Use `_captures` instead.
  * @internal
  */
 export declare const useLexicalScope: <VARS extends any[]>() => VARS;
@@ -3818,6 +4200,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`.
  */
@@ -3829,6 +4213,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`.
  *
@@ -3856,6 +4242,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`.
  *
@@ -3894,45 +4282,15 @@ export declare const useOnWindow: <T extends KnownEventNames>(event: T | T[], ev
  * Be careful when using a `try/catch` statement in `useResource$`. If you catch the error and don't
  * re-throw it (or a new Error), the resource status will never be `rejected`.
  *
- * ### Example
- *
- * Example showing how `useResource` to perform a fetch to request the weather, whenever the input
- * city name changes.
- *
- * ```tsx
- * const Cmp = component$(() => {
- *   const cityS = useSignal('');
- *
- *   const weatherResource = useResource$(async ({ track, cleanup }) => {
- *     const cityName = track(cityS);
- *     const abortController = new AbortController();
- *     cleanup(() => abortController.abort('cleanup'));
- *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
- *       signal: abortController.signal,
- *     });
- *     const data = await res.json();
- *     return data as { temp: number };
- *   });
- *
- *   return (
- *     <div>
- *       <input name="city" bind:value={cityS} />
- *       <Resource
- *         value={weatherResource}
- *         onResolved={(weather) => {
- *           return <div>Temperature: {weather.temp}</div>;
- *         }}
- *       />
- *     </div>
- *   );
- * });
- * ```
- *
+ * @deprecated Use `useAsync$` instead, which is more powerful and flexible. `useResource$` is still
+ *   available for backward compatibility but it is recommended to migrate to `useAsync$` for new
+ *   code and when updating existing code.
  * @public
+ * @see useAsync$
  * @see Resource
  * @see ResourceReturn
  */
-export declare const useResource$: <T>(generatorFn: ResourceFn<T>, opts?: ResourceOptions) => ResourceReturn<T>;
+export declare const useResource$: <T>(qrl: ResourceFn<T>, opts?: ResourceOptions | undefined) => ResourceReturn<T>;
 
 /** @internal */
 export declare const useResourceQrl: <T>(qrl: QRL<ResourceFn<T>>, opts?: ResourceOptions) => ResourceReturn<T>;
@@ -4001,7 +4359,7 @@ export declare const useResourceQrl: <T>(qrl: QRL<ResourceFn<T>>, opts?: Resourc
 export declare const useSerializer$: typeof createSerializer$;
 
 /** @internal */
-export declare const useSerializerQrl: <T, S>(qrl: QRL<SerializerArg<T, S>>) => ReadonlySignal_2<unknown>;
+export declare const useSerializerQrl: <T, S>(qrl: QRL<SerializerArg<T, S>>) => SerializerSignalImpl<T, S>;
 
 /** @public */
 export declare function useServerData<T>(key: string): T | undefined;
@@ -4015,14 +4373,61 @@ export declare interface UseSignal {
     <T>(value: T | (() => T)): Signal<T>;
 }
 
-/** @public */
+/**
+ * Creates an object with a single reactive `.value` property, that Qwik can track across
+ * serializations.
+ *
+ * Use it to create state for your application. The object has a getter and setter to track reads
+ * and writes of the `.value` property. When the value changes, any functions that read from it will
+ * re-run.
+ *
+ * Prefer `useSignal` over `useStore` when possible, as it is more efficient.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * const Signals = component$(() => {
+ *   const counter = useSignal(1);
+ *   const text = useSignal('changeme');
+ *   const toggle = useSignal(false);
+ *
+ *   // useSignal() can also accept a function to calculate the initial value
+ *   const state = useSignal(() => {
+ *     return expensiveInitialValue();
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick$={() => counter.value++}>Counter: {counter.value}</button>
+ *       {
+ *         // pass signal values as the value, the optimizer will make it pass the signal
+ *       }
+ *       <Child state={state.value} />
+ *       {
+ *         // signals can be bound to inputs. A property named `bind:x` implies that the property
+ * is a signal
+ *       }
+ *       <input type="text" bind:value={text} />
+ *       <input type="checkbox" bind:checked={toggle} />
+ *     </div>
+ *   );
+ * });
+ * ```
+ *
+ * @public
+ */
 export declare const useSignal: UseSignal;
 
 /**
- * Creates an object that Qwik can track across serializations.
+ * Creates a reactive object that Qwik can track across serialization.
+ *
+ * Use it to create state for your application. The returned object is a Proxy that tracks reads and
+ * writes. When any of the properties change, the functions that read those properties will re-run.
+ *
+ * `Store`s are deep by default, meaning that any objects assigned to properties will also become
+ * `Store`s. This includes arrays.
  *
- * Use `useStore` to create a state for your application. The returned object is a proxy that has a
- * unique ID. The ID of the object is used in the `QRL`s to refer to the store.
+ * Prefer `useSignal` over `useStore` when possible, as it is more efficient.
  *
  * ### Example
  *
@@ -4202,10 +4607,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
@@ -4235,6 +4640,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 function _val(this: string | undefined, _: any, element: HTMLInputElement): void;
+
 /**
  * Type representing a value which is either resolve or a promise.
  *
@@ -4249,38 +4661,59 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.3-dev+aa098fc
+ * 2.0.0-beta.31-dev+906321a
  *
  * @public
  */
 export declare const version: string;
 
 /** @internal */
-export declare type _VirtualVNode = [
-_VNodeFlags.Virtual,
-///////////// 0 - Flags
-_VNode | null,
-/////////////// 1 - Parent
-_VNode | null,
-/////////////// 2 - Previous sibling
-_VNode | null,
-/////////////// 3 - Next sibling
-_VNode | null,
-/////////////// 4 - First child
-_VNode | null,
-(string | null | boolean)[]
-] & {
-    __brand__: 'FragmentNode' & 'HostElement';
-};
+export declare class _VirtualVNode extends _VNode {
+    key: string | null;
+    firstChild: _VNode | null | undefined;
+    lastChild: _VNode | null | undefined;
+    constructor(key: string | null, flags: _VNodeFlags, parent: _ElementVNode | _VirtualVNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, props: Props | null, firstChild: _VNode | null | undefined, lastChild: _VNode | null | undefined);
+}
 
 /** @public */
 export declare type VisibleTaskStrategy = 'intersection-observer' | 'document-ready' | 'document-idle';
 
 /** @internal */
-export declare type _VNode = _ElementVNode | _TextVNode | _VirtualVNode;
+export declare abstract class _VNode implements BackRef {
+    flags: _VNodeFlags;
+    parent: _VNode | null;
+    previousSibling: _VNode | null | undefined;
+    nextSibling: _VNode | null | undefined;
+    props: Props | null;
+    [_EFFECT_BACK_REF]: Map<any, any> | undefined;
+    slotParent: _VNode | null;
+    dirty: ChoreBits;
+    dirtyChildren: _VNode[] | null;
+    nextDirtyChildIndex: number;
+    constructor(flags: _VNodeFlags, parent: _VNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, props: Props | null);
+    toString(): string;
+}
+
+/** @internal */
+export declare const _vnode_ensureElementInflated: (container: _Container, vnode: _VNode) => void;
+
+/** @internal */
+export declare const _vnode_getAttrKeys: (container: _Container, vnode: _ElementVNode | _VirtualVNode) => string[];
+
+/** @internal */
+export declare const _vnode_getFirstChild: (vnode: _VNode) => _VNode | null;
 
 /** @internal */
-export declare function _vnode_toString(this: _VNode | null, depth?: number, offset?: string, materialize?: boolean, siblings?: boolean, colorize?: boolean): string;
+export declare const _vnode_isMaterialized: (vNode: _VNode) => boolean;
+
+/** @internal */
+export declare const _vnode_isTextVNode: (vNode: _VNode) => vNode is _TextVNode;
+
+/** @internal */
+export declare const _vnode_isVirtualVNode: (vNode: _VNode) => vNode is _VirtualVNode;
+
+/** @internal */
+export declare function _vnode_toString(this: _VNode | null, depth?: number, offset?: string, materialize?: boolean, siblings?: boolean, colorize?: boolean, container?: _Container | null): string;
 
 /**
  * Array of numbers which describes virtual nodes in the tree.
@@ -4309,7 +4742,7 @@ export declare function _vnode_toString(this: _VNode | null, depth?: number, off
  * this data needs to be serialized into a string and stored in the DOM as a script tag which has
  * deferent serialization format.
  */
-declare type VNodeData = [VNodeDataFlag, ...(SsrAttrs | number)[]];
+declare type VNodeData = [VNodeDataFlag, ...(Props | number)[]];
 
 /**
  * Flags for VNodeData (Flags con be bitwise combined)
@@ -4348,40 +4781,26 @@ export declare const enum _VNodeFlags {
     Element = 1,
     Virtual = 2,
     ELEMENT_OR_VIRTUAL_MASK = 3,
+    Text = 4,
     ELEMENT_OR_TEXT_MASK = 5,
     TYPE_MASK = 7,
     INFLATED_TYPE_MASK = 15,
-    Text = 4,
     Inflated = 8,
     Resolved = 16,
     Deleted = 32,
-    NAMESPACE_MASK = 192,
-    NEGATED_NAMESPACE_MASK = -193,
+    HasIterationItems = 64,
+    InflatedIterationItems = 128,
+    Cursor = 256,
+    NAMESPACE_MASK = 1536,
+    NEGATED_NAMESPACE_MASK = -1537,
     NS_html = 0,// http://www.w3.org/1999/xhtml
-    NS_svg = 64,// http://www.w3.org/2000/svg
-    NS_math = 128
-}
-
-declare type VNodeJournal = Array<VNodeJournalOpCode | Document | Element | Text | string | boolean | null>;
-
-/**
- * Fundamental DOM operations are:
- *
- * - Insert new DOM element/text
- * - Remove DOM element/text
- * - Set DOM element attributes
- * - Set text node value
- */
-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
+    NS_svg = 512,// http://www.w3.org/2000/svg
+    NS_math = 1024,// http://www.w3.org/1998/Math/MathML
+    HasTargetElement = 2048
 }
 
 /** @internal */
-export declare const _waitUntilRendered: (elm: Element) => Promise<void>;
+export declare const _waitUntilRendered: (container: _Container) => Promise<void>;
 
 /** @internal */
 export declare function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: {
@@ -4389,9 +4808,6 @@ export declare function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: {
     parentComponentFrame: ISsrComponentFrame | null;
 }): Promise<void>;
 
-/** @internal */
-export declare const _weakSerialize: <T extends object>(input: T) => Partial<T>;
-
 /**
  * Override the `getLocale` with `lang` within the `fn` execution.
  *
@@ -4399,27 +4815,24 @@ export declare const _weakSerialize: <T extends object>(input: T) => Partial<T>;
  */
 export declare function withLocale<T>(locale: string, fn: () => T): T;
 
+declare type WrappedProp<T extends object, P extends keyof T> = T extends Signal ? WrappedSignalImpl<PropType<T, P>> : PropType<T, P>;
+
 declare const enum WrappedSignalFlags {
-    UNWRAP = 2
+    UNWRAP = 4
 }
 
-declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
+declare class WrappedSignalImpl<T> extends SignalImpl<T> {
     $args$: any[];
     $func$: (...args: any[]) => T;
     $funcStr$: string | null;
     $flags$: AllSignalFlags;
-    $hostElement$: HostElement | null;
-    $forceRunEffects$: boolean;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
-    constructor(container: Container | null, fn: (...args: any[]) => T, args: any[], fnStr: string | null, flags?: SignalFlags);
-    $invalidate$(): void;
-    /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object.
-     */
-    force(): void;
+    $hostElement$: HostElement | undefined;
+    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
+    constructor(container: _Container | null, fn: (...args: any[]) => T, args: any[], fnStr: string | null, flags?: SignalFlags);
+    invalidate(): void;
     get untrackedValue(): T;
-    $computeIfNeeded$(): boolean;
+    $computeIfNeeded$(): void;
+    $unwrapIfSignal$(): SignalImpl<T> | WrappedSignalImpl<T>;
     set value(_: any);
     get value(): any;
 }
@@ -4435,12 +4848,9 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
  *
  * @internal
  */
-export declare const _wrapProp: <T extends Record<any, any>, P extends keyof T>(...args: [T, P?]) => any;
+export declare const _wrapProp: <T extends object, P extends keyof T>(...args: [T, P?]) => WrappedProp<T, P>;
 
 /** @internal @deprecated v1 compat */
-export declare const _wrapSignal: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => any;
-
-/** @internal */
-export declare const _wrapStore: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => Signal<T>;
+export declare const _wrapSignal: <T extends object, P extends keyof T>(obj: T, prop: P) => T[P] | WrappedProp<T, P>;
 
 export { }