@qwik.dev/core 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/core-internal.d.ts

@@ -1,11 +1,10 @@
-import { ComputedSignal as ComputedSignal_2 } from '..';
-import * as CSS_2 from 'csstype';
+import type { AsyncLocalStorage } from 'node:async_hooks';
+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 type { StreamWriter as StreamWriter_2 } from '.';
-import { ValueOrPromise as ValueOrPromise_2 } from '..';
+import { ResolvedManifest } from './optimizer';
+import type { ServerQwikManifest } from './optimizer';
 
 /**
  * Qwik Optimizer marker function.
@@ -83,23 +82,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 | ComputedSignalFlags;
+declare type AllSignalFlags = ComputedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
 
 /**
  * TS defines these with the React syntax which is not compatible with Qwik. E.g. `ariaAtomic`
@@ -357,53 +366,77 @@ 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 = {
-    track: Tracker;
-    cleanup: (callback: () => void) => void;
-};
+/**
+ * Note, we don't pass the generic type to ComputeCtx 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.
+ *
+ * @deprecated Use `useComputed$` with an async function instead.
+ * @public
+ */
+export declare type AsyncFn<T> = (ctx: ComputeCtx) => ValueOrPromise<T>;
 
-/** @public */
-export declare type AsyncComputedFn<T> = (ctx: AsyncComputedCtx) => Promise<T>;
+/** @deprecated Use `ComputeQRL` instead. */
+declare type AsyncQRL<T> = _QRLInternal<AsyncFn<T>>;
 
-/** @public */
-export declare interface AsyncComputedReadonlySignal<T = unknown> extends ComputedSignal<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.
+ *
+ * @deprecated Use `ComputedSignal` instead, it has async support now.
+ * @public
+ */
+export declare type AsyncSignal<T = unknown> = ComputedSignal<T>;
+
+declare const enum AsyncSignalFlags {
+    EAGER_CLEANUP = 32,
+    CLIENT_ONLY = 64,
+    /** The compute fn is async: the async engine (jobs, loading, error) is active */
+    ASYNC_MODE = 512,
+    /** Invoke the compute fn AsyncSignal-style: pass the ComputeCtx argument, no auto-tracking */
+    CTX_ARG = 1024
 }
 
-/** @public */
-export declare type AsyncComputedReturnType<T> = T extends Promise<infer T> ? AsyncComputedReadonlySignal<T> : AsyncComputedReadonlySignal<T>;
-
 /**
  * # ================================
  *
- * AsyncComputedSignalImpl
+ * AsyncSignalImpl
  *
  * # ================================
+ *
+ * The async engine (jobs, loading, error) lives in ComputedSignalImpl; this subclass configures it
+ * from options and switches the compute invocation to CTX_ARG mode: the compute fn receives the
+ * ComputeCtx argument and tracks only via its explicit `track()` (no auto-tracking).
+ *
+ * @internal
  */
-declare class AsyncComputedSignalImpl<T> extends ComputedSignalImpl<T, AsyncComputeQRL<T>> implements BackRef {
-    $untrackedLoading$: boolean;
-    $untrackedError$: Error | null;
-    $loadingEffects$: null | Set<EffectSubscription>;
-    $errorEffects$: null | Set<EffectSubscription>;
-    $destroy$: NoSerialize<() => void> | null;
-    private $promiseValue$;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
-    constructor(container: Container | null, fn: AsyncComputeQRL<T>, flags?: SignalFlags | ComputedSignalFlags);
-    /**
-     * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
-     * has resolved or rejected.
-     */
-    get loading(): boolean;
-    set untrackedLoading(value: boolean);
-    get untrackedLoading(): boolean;
-    /** The error that occurred when the signal was resolved. */
-    get error(): Error | null;
-    set untrackedError(value: Error | null);
-    get untrackedError(): Error | null;
-    invalidate(): void;
-    $computeIfNeeded$(): boolean;
+export declare class _AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements AsyncSignal<T> {
+    constructor(container: _Container | null, fn: AsyncQRL<T>, flags?: number, options?: AsyncSignalOptions<T>);
 }
 
-declare type AsyncComputeQRL<T> = QRLInternal<AsyncComputedFn<T>>;
+/**
+ * @deprecated Use `ComputedOptions` instead.
+ * @public
+ */
+export declare type AsyncSignalOptions<T> = ComputedOptions<T>;
 
 /**
  * Replace given element's props with custom types and return all props specific to the element. Use
@@ -415,7 +448,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> = {
@@ -431,21 +464,39 @@ 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
+declare type Capture = {
+    [K in keyof HTMLElementEventMap as `capture:${K}`]?: boolean;
+};
+
+/**
+ * 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 | Promise<void>;
+
+declare const enum ChoreBits {
+    NONE = 0,
+    TASKS = 1,
+    NODE_DIFF = 2,
+    COMPONENT = 4,
+    INLINE_COMPONENT = 8,
+    NODE_PROPS = 16,
+    COMPUTE = 32,
+    CHILDREN = 64,
+    CLEANUP = 128,
+    RECONCILE = 256,
+    ERROR_WRAP = 512,
+    DIRTY_MASK = 1023
 }
 
 /**
@@ -461,18 +512,17 @@ 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;
+    $forwardRefs$: Array<number | string> | null;
+    vNodeLocate(id: string | Element): _VNode;
     parseQRL<T = unknown>(qrl: string): QRL<T>;
+    $getForwardRef$(id: number): number | string | undefined;
     $setRawState$(id: number, vParent: _ElementVNode | _VirtualVNode): void;
 }
 
@@ -499,11 +549,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>
  *   );
  * });
@@ -558,26 +608,84 @@ 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>;
 
-/** @public */
-export declare type ComputedFn<T> = () => T;
+declare type ComputeCtx<T = unknown> = {
+    /**
+     * Track reactive reads so the computation re-runs when they change. Computed functions track
+     * synchronous reads automatically, but after the first `await` the tracking context is lost, so
+     * later reads must go through `track()`.
+     */
+    readonly track: Tracker;
+    /**
+     * 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;
+};
+
+/**
+ * The compute function. The context provides `track()`, `previous` (the last computed value),
+ * `info` (the argument of the `invalidate(info)` call that triggered this computation), `cleanup()`
+ * and `abortSignal`. Synchronous reactive state reads are tracked automatically, use `untrack()` to
+ * read signals without tracking. Return a `Promise` (or use an `async` function) for async values.
+ * After the first `await`, reads are no longer tracked automatically and must use `track()`.
+ *
+ * @public
+ */
+export declare type ComputedFn<T> = (ctx: ComputeCtx) => ValueOrPromise<T>;
 
 /** @public */
-export declare interface ComputedOptions {
+export declare interface ComputedOptions<T = unknown> {
     serializationStrategy?: SerializationStrategy;
-    container?: Container;
+    container?: _Container;
+    /** Like useSignal's `initial`; prevents the throw on first read when uninitialized */
+    initial?: Awaited<T> | (() => Awaited<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;
+    /**
+     * 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;
 }
 
 /** @public */
-export declare type ComputedReturnType<T> = T extends Promise<any> ? never : ComputedSignal<T>;
+export declare type ComputedReturnType<T> = ComputedSignal<Awaited<T>>;
 
 /**
  * A computed signal is a signal which is calculated from other signals. When the signals change,
@@ -586,54 +694,182 @@ export declare type ComputedReturnType<T> = T extends Promise<any> ? never : Com
  *
  * @public
  */
-export declare interface ComputedSignal<T> extends ReadonlySignal<T> {
+export declare interface ComputedSignal<T> extends Signal<T> {
+    /** @deprecated Use `trigger()` instead */
+    force(): void;
+    /** Use this to force recalculation. */
+    invalidate(): void;
     /**
-     * Use this to force running subscribers, for example when the calculated value mutates but
-     * remains the same object.
+     * Clear the value and recompute. Unlike `invalidate()`, readers see the loading state (reads
+     * throw the computation promise) instead of the stale value while the new value computes.
      */
-    force(): void;
+    clear(): void;
     /**
-     * Use this to force recalculation and running subscribers, for example when the calculated value
-     * mutates but remains the same object.
+     * Whether the signal is currently loading. This will trigger lazy computation of the signal, so
+     * you can use it like this:
+     *
+     * ```tsx
+     * signal.pending ? <Loading /> : signal.error ? <Error /> : <Component
+     * value={signal.value} />
+     * ```
      */
-    invalidate(): void;
+    pending: boolean;
+    /**
+     * Lets you read the pending state without subscribing to `.pending` updates. It also triggers
+     * lazy computation of the signal.
+     *
+     * Setting it will trigger listeners for `.pending`.
+     */
+    untrackedPending: boolean;
+    /** @deprecated Use `pending` instead */
+    loading: boolean;
+    /** @deprecated Use `untrackedPending` instead */
+    untrackedLoading: boolean;
+    /**
+     * The error that occurred while computing the signal, if any, including synchronous throws. This
+     * will be cleared when the signal is successfully computed. It also triggers lazy computation of
+     * the signal. While the error is set, reading `.value` throws it.
+     */
+    error: Error | undefined;
+    /**
+     * Lets you read the error state without subscribing to `.error` updates. It also triggers lazy
+     * computation of the signal.
+     *
+     * Setting it will trigger listeners for `.error`.
+     */
+    untrackedError: Error | undefined;
+    /** 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;
 }
 
 declare const enum ComputedSignalFlags {
-    SERIALIZATION_STRATEGY_NEVER = 8,
-    SERIALIZATION_STRATEGY_ALWAYS = 16
+    INVALID = 1,
+    RUN_EFFECTS = 2,
+    PRESERVE_ON_SEQ_CLEANUP = 4
 }
 
 /**
  * A signal which is computed from other signals.
  *
- * The value is available synchronously, but the computation is done lazily.
+ * Sync compute functions resolve synchronously and every read they perform is auto-tracked. When
+ * the compute function turns out to be async (it returned a promise), the signal lazily switches on
+ * the async engine — jobs, `loading`, `error` — giving it the same API as an AsyncSignal.
+ * Auto-tracking only covers reads before the first await point (the invoke context is lost after
+ * it); later reads must use the ComputeCtx `track()`.
  */
-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.
      *
-     * The computed functions must be executed synchronously (because of this we need to eagerly
-     * resolve the QRL during the mark dirty phase so that any call to it will be synchronous). )
+     * Sync computed functions must be executed synchronously (because of this we need to eagerly
+     * resolve the QRL during the mark dirty phase so that any call to it will be synchronous).
      */
     $computeQrl$: S;
-    $flags$: SignalFlags | ComputedSignalFlags;
-    $forceRunEffects$: boolean;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
-    constructor(container: Container | null, fn: S, flags?: SignalFlags | ComputedSignalFlags);
-    invalidate(): void;
+    $flags$: number;
+    [_EFFECT_BACK_REF]: Map<_EffectProperty | string, EffectSubscription> | undefined;
+    $untrackedPending$: boolean | undefined;
+    $untrackedError$: Error | undefined;
+    $current$: Job<T> | null | undefined;
+    $jobs$: Job<T>[] | undefined;
+    $concurrency$: number | undefined;
+    $timeoutMs$: number | undefined;
+    $loadingEffects$: undefined | Set<EffectSubscription>;
+    $errorEffects$: undefined | Set<EffectSubscription>;
+    $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
+    $info$: unknown | undefined;
+    $infoVersion$: number | undefined;
+    constructor(container: _Container | null, fn: S, flags?: number, options?: ComputedOptions<T>);
+    /** Clear the value so readers see the loading state, then recompute. */
+    clear(): void;
+    invalidate(info?: unknown): void;
     /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object
+     * 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.
      */
-    force(): void;
+    get value(): T;
+    set value(value: T);
     get untrackedValue(): T;
-    $computeIfNeeded$(): boolean;
-    set value(_: any);
-    get value(): any;
+    set untrackedValue(value: T);
+    /**
+     * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
+     * has resolved or rejected (or the compute function is synchronous).
+     *
+     * Accessing `.pending` will trigger computation if needed, since it's often used like
+     *
+     * ```ts
+     * signal.pending ? <Loading /> : signal.value
+     * ```
+     */
+    get pending(): boolean;
+    set untrackedPending(value: boolean);
+    get untrackedPending(): boolean;
+    /** @deprecated Use `pending` instead */
+    get loading(): boolean;
+    /** @deprecated Use `untrackedPending` instead */
+    get untrackedLoading(): boolean;
+    set untrackedLoading(value: boolean);
+    /**
+     * The error the compute function threw or rejected with.
+     *
+     * Accessing .error will trigger computation if needed, since it's often used like
+     *
+     * ```ts
+     * signal.error ? <Failed /> : signal.value
+     * ```
+     */
+    get error(): Error | undefined;
+    set untrackedError(value: Error | undefined);
+    get untrackedError(): Error | undefined;
+    $setInvalid$(allowRecalc: boolean): 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;
+    /**
+     * Invoke the compute fn with the ComputeCtx argument. CTX_ARG signals (useAsync$, useResource$)
+     * only track via its explicit track(). Computeds auto-track every synchronous read instead; after
+     * the first await they must use the explicit track() too.
+     */
+    $invokeComputeFn$(fn: Function, job: Job<T>): T | Promise<T>;
+    /** Start an async computation (the async engine; assumes the INVALID flag is set) */
+    $computeAsync$(): void;
+    $runComputation$(running: Job<T>): Promise<void>;
+    /** Await the computation and publish its result, error, and loading transitions. */
+    $settleComputation$(running: Job<T>, compute: () => ValueOrPromise<T>): Promise<void>;
+    /**
+     * Sets the error from the given job. We only accept errors from the current job and we ignore
+     * AbortErrors.
+     */
+    $setError$(job: Job<T>, error: Error): void;
+    /** Called after SSR/unmount */
+    $destroy$(): Promise<void>;
+    private $hasSubscribers$;
+    $requestCleanups$(job: Job<T>, reason?: any): void;
+    /** Run a job's cleanup callbacks, returning a promise when any of them are async. */
+    $runCleanupCallbacks$(job: Job<T>): Promise<void> | undefined;
+    /** Clean up and trigger signal compute once complete */
+    $runCleanups$(job: Job<T>): Promise<void> | undefined;
 }
 
-declare type ComputeQRL<T> = QRLInternal<ComputedFn<T>>;
+declare type ComputeQRL<T> = _QRLInternal<ComputedFn<T>>;
 
 /** @internal */
 export declare const _CONST_PROPS: unique symbol;
@@ -647,24 +883,31 @@ 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;
+    $rootContainer$: _Container | null;
+    $isOutOfOrderSegment$: boolean;
     readonly $locale$: string;
     readonly $getObjectById$: (id: number | string) => any;
     readonly $serverData$: Record<string, any>;
+    readonly $instanceHash$: string | null;
     $currentUniqueId$: number;
     $buildBase$: string | null;
-    handleError(err: any, $host$: HostElement): 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;
-    setHostProp<T>(host: HostElement, name: string, value: T): void;
-    getHostProp<T>(host: HostElement, name: string): T | null;
-    $appendStyle$(content: string, styleId: string, host: HostElement, scoped: boolean): 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;
+    setHostProp<T>(host: _HostElement, name: string, value: T): void;
+    getHostProp<T>(host: _HostElement, name: string): T | null;
+    $appendStyle$(content: string, styleId: string, host: _HostElement, scoped: boolean): void;
     /**
      * When component is about to be executed, it may add/remove children. This can cause problems
      * with the projection because deleting content will prevent the projection references from
@@ -673,7 +916,7 @@ declare interface Container {
      *
      * @param renderHost - Host element to ensure projection is resolved.
      */
-    ensureProjectionResolved(host: HostElement): void;
+    ensureProjectionResolved(host: _HostElement): void;
     serializationCtxFactory(NodeConstructor: {
         new (...rest: any[]): {
             __brand__: 'SsrNode';
@@ -685,6 +928,13 @@ declare interface Container {
     } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter): SerializationContext;
 }
 
+declare const enum ContainerDataProcessState {
+    NotStarted = 0,
+    ProcessingVNode = 1,
+    ProcessingState = 2,
+    ProcessingStateDone = 3
+}
+
 /** @internal */
 export declare interface _ContainerElement extends HTMLElement {
     qContainer?: ClientContainer;
@@ -702,6 +952,9 @@ export declare interface _ContainerElement extends HTMLElement {
     qVNodeRefs?: Map<number, Element | _ElementVNode>;
     /** String from `<script type="qwik/vnode">` tag. */
     qVnodeData?: string;
+    qDestroy?: () => void;
+    /** Segment-local strings from `<script type="qwik/vnode" q:r="...">` tags. */
+    qSegmentVnodeData?: Map<string, string>;
 }
 
 /**
@@ -802,19 +1055,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.
      *
@@ -837,19 +1084,16 @@ export declare interface CorrectedToggleEvent extends Event {
 }
 
 /**
- * Create an async computed signal which is calculated from the given QRL. A computed signal is a
- * signal which is calculated from other signals or async operation. When the signals change, the
- * computed signal is recalculated.
- *
- * The QRL must be a function which returns the value of the signal. The function must not have side
- * effects, and it can be async.
+ * Create a signal holding a `.value` which is calculated from the given async function (QRL). The
+ * standalone version of `useAsync$`.
  *
+ * @deprecated Use `createComputed$` instead, it has async support now.
  * @public
  */
-export declare const createAsyncComputed$: <T>(qrl: () => Promise<T>, options?: ComputedOptions) => AsyncComputedReturnType<T>;
+export declare const createAsync$: <T>(qrl: (arg: ComputeCtx<T>) => Promise<T>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
 
 /** @internal */
-export declare const createAsyncComputedQrl: <T>(qrl: QRL<(ctx: AsyncComputedCtx) => Promise<T>>, options?: ComputedOptions) => AsyncComputedSignalImpl<T>;
+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
@@ -857,16 +1101,17 @@ export declare const createAsyncComputedQrl: <T>(qrl: QRL<(ctx: AsyncComputedCtx
  * recalculated.
  *
  * 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 `useAsyncComputed$` instead.
+ * effects. Every synchronous signal or store read is tracked automatically; reads after the first
+ * `await` must use the `track()` provided on the context argument. When the function is async, the
+ * returned signal exposes the async API (`.pending`, `.error`, `.promise()`), and reading an
+ * unresolved `.value` throws the computation promise.
  *
  * @public
  */
-export declare const createComputed$: <T>(qrl: () => T, options?: ComputedOptions) => ComputedReturnType<T>;
+export declare const createComputed$: <T>(qrl: (ctx: ComputeCtx) => ValueOrPromise<T>, options?: ComputedOptions<T>) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const createComputedQrl: <T>(qrl: QRL<() => T>, options?: ComputedOptions) => ComputedSignalImpl<T>;
+export declare const createComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions<T>) => ComputedSignalImpl<T>;
 
 /**
  * Create a context ID to be used in your application. The name should be written with no spaces.
@@ -920,18 +1165,23 @@ export declare const createComputedQrl: <T>(qrl: QRL<() => T>, options?: Compute
  */
 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>;
-};
+/** @internal */
+export declare function _createDeserializeContainer(stateData: unknown[]): DeserializeContainer;
+
+/**
+ * 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?: QrlCaptures, container?: _Container) => _QRLInternal<TYPE>;
 
 /**
  * Create a signal that holds a custom serializable value. See {@link useSerializer$} for more
@@ -959,6 +1209,9 @@ export declare const createSignal: {
     <T>(value: T): Signal<T>;
 };
 
+/** @internal */
+export declare function _createStore<T extends object>(container: _Container | null | undefined, obj: T, flags: _StoreFlags): T;
+
 /** @public */
 export declare interface CSSProperties extends CSS_2.Properties<string | number>, CSS_2.PropertiesHyphen<string | number> {
     /**
@@ -971,34 +1224,34 @@ 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>;
-    $state$: B | undefined;
-    $destroy$: NoSerialize<() => void> | null;
+/** @internal */
+export declare const _delay: (timeout: number) => Promise<unknown>;
+
+declare class DeleteOperation {
+    target: Element | Text;
+    constructor(target: Element | Text);
 }
 
 /**
- * Deserialize data from string to an array of objects.
+ * Deserialize data from string.
  *
  * @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): Promise<T>;
 
 declare interface DeserializeContainer {
     $getObjectById$: (id: number | string) => unknown;
+    $getForwardRef$: (id: number) => number | string | undefined;
+    $pendingStoreTargets$?: Map<object, {
+        t: number;
+        v: unknown;
+    }>;
     element: HTMLElement | null;
     getSyncFn: (id: number) => (...args: unknown[]) => unknown;
     $state$?: unknown[];
     $storeProxyMap$: ObjToProxyMap;
-    $forwardRefs$: Array<number> | null;
-    $initialQRLsIndexes$: Array<number> | null;
-    readonly $scheduler$: Scheduler | null;
+    $forwardRefs$: Array<number | string> | null;
 }
 
 /** @public */
@@ -1014,7 +1267,7 @@ export declare interface DOMAttributes<EL extends Element> extends DOMAttributes
     class?: ClassList | Signal<ClassList> | undefined;
 }
 
-declare interface DOMAttributesBase<EL extends Element> extends QwikIntrinsicAttributes, PreventDefault, StopPropagation, RefAttr<EL> {
+declare interface DOMAttributesBase<EL extends Element> extends QwikIntrinsicAttributes, PreventDefault, StopPropagation, Capture, Passive, RefAttr<EL> {
     dangerouslySetInnerHTML?: string | undefined;
 }
 
@@ -1025,68 +1278,81 @@ 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;
+    $forwardRefs$: Array<number | string> | null;
     vNodeLocate: (id: string | Element) => _VNode;
+    $containerDataProcessState$: ContainerDataProcessState;
+    $containerStateReadyCallbacks$: Array<() => void> | undefined;
+    $containerStateDataState$: unknown;
+    private $rawStateData$;
     private $stateData$;
+    private $rootForwardRefs$;
     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;
-    setHostProp<T>(host: HostElement, name: string, value: T): void;
-    getHostProp<T>(host: HostElement, name: string): T | null;
-    scheduleRender(): Promise<void>;
-    private processChores;
+    $processContainerData$(): Generator<void, void, void>;
+    /** 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;
     ensureProjectionResolved(vNode: _VirtualVNode): void;
     $getObjectById$: (id: number | string) => unknown;
+    $getForwardRef$(id: number): number | string | undefined;
     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 }
 
 declare type DomRef = {
-    $ssrNode$: SsrNode;
+    $ssrNode$: ISsrNode;
 };
 
 /** @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 const enum EffectProperty {
+declare type EffectBackRef = SignalImpl | StoreTarget | PropsProxy;
+
+/** @internal */
+export declare const enum _EffectProperty {
     COMPONENT = ":",
     VNODE = "."
 }
@@ -1127,42 +1393,29 @@ 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 const _ELEMENT_SEQ = "q:seq";
+
+/** @internal */
+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 {
@@ -1170,15 +1423,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>;
@@ -1197,6 +1449,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];
 };
@@ -1209,6 +1464,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;
@@ -1227,16 +1489,30 @@ export declare type FunctionComponent<P = unknown> = {
 }['renderFn'];
 
 /** @internal */
-export declare const _getContextContainer: () => ClientContainer | undefined;
+export declare const _getAsyncLocalStorage: () => (new <T>() => AsyncLocalStorage<T>) | undefined;
+
+/**
+ * Returns the client build manifest, which includes the mappings from symbols to bundles, the
+ * bundlegraph etc.
+ *
+ * @public
+ */
+export declare const getClientManifest: () => ServerQwikManifest | undefined;
+
+/** 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 }
 
@@ -1265,22 +1541,17 @@ 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';
-}
+/** @internal */
+export declare function _getSubscriber(effect: Consumer, prop: _EffectProperty | string, data?: _SubscriptionData): EffectSubscription;
+
+/** 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
  */
@@ -1288,18 +1559,28 @@ 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 | Promise<void>;
 
-declare type HostElement = _VNode | ISsrNode;
+/** @internal */
+export declare type _HostElement = _VNode | ISsrNode;
 
 /** @public */
 declare type HTMLAttributeAnchorTarget = '_self' | '_blank' | '_parent' | '_top' | (string & {});
@@ -1358,7 +1639,7 @@ declare interface HTMLAttributesBase extends AriaAttributes {
 declare type HTMLCrossOriginAttribute = 'anonymous' | 'use-credentials' | '' | undefined;
 
 /** @public */
-declare interface HTMLElementAttrs extends HTMLAttributesBase, FilterBase<HTMLElement> {
+export declare interface HTMLElementAttrs extends HTMLAttributesBase, FilterBase<HTMLElement> {
 }
 
 /** @public */
@@ -1410,17 +1691,47 @@ 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>;
+/**
+ * Inject a pre-loaded value into a signal while preserving subscriptions. Calls `invalidate({__v})`
+ * so the compute function reads the value from `info`, then triggers an immediate synchronous
+ * compute via the private `$computeIfNeeded$()` method (which is mangled in core builds, so callers
+ * from other packages must go through this helper).
+ *
+ * @internal
+ */
+export declare const _injectAsyncSignalValue: (signal: ComputedSignal<unknown>, value: unknown) => void;
+
+/**
+ * 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>;
+export declare const inlinedQrlDEV: <T = any>(symbol: T, symbolName: string, opts: QRLDev, lexicalScopeCapture?: Readonly<unknown[]>) => QRL<T>;
 
-/** @public */
-declare interface InlineEntryStrategy {
-    type: 'inline';
+declare class InsertOrMoveOperation {
+    target: Element | Text;
+    parent: Element;
+    beforeTarget: Element | Text | null;
+    constructor(target: Element | Text, parent: Element, beforeTarget: Element | Text | null);
 }
 
+/** @internal */
+declare type InternalServerComponent<PROPS = unknown> = FunctionComponent<PROPS> & {
+    [InternalServerComponentSymbol]: InternalServerComponentHandler;
+};
+
+/** @internal */
+declare type InternalServerComponentHandler = (ssr: SSRContainer, jsx: JSXNodeInternal, options: SSRRenderJSXOptions, enqueue: (value: StackValue) => void) => ValueOrPromise<void>;
+
+declare const InternalServerComponentSymbol: unique symbol;
+
 /**
  * These are the HTML tags with handlers allowing plain callbacks, to be used for the JSX interface
  *
@@ -1444,26 +1755,24 @@ declare type IntrinsicSVGElements = {
     [K in keyof Omit<SVGElementTagNameMap, keyof HTMLElementTagNameMap>]: LenientSVGProps<SVGElementTagNameMap[K]>;
 };
 
+/**
+ * Call a function with the given InvokeContext and given arguments.
+ *
+ * @internal
+ */
+export declare function _invoke<FN extends (...args: any[]) => any>(this: unknown, context: InvokeContext | undefined, fn: FN, ...args: Parameters<FN>): ReturnType<FN>;
+
 /** 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;
+    $hostElement$: _HostElement | 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;
@@ -1489,11 +1798,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;
@@ -1501,27 +1810,76 @@ export declare interface ISsrComponentFrame {
 
 declare interface ISsrNode {
     id: string;
-    parentSsrNode: ISsrNode | null;
-    vnodeData?: VNodeData;
+    flags: SsrNodeFlags;
+    dirty: ChoreBits;
+    parentComponent: ISsrNode | null;
+    children: ISsrNode[] | null;
+    vnodeData: VNodeData;
+    currentFile: string | null;
+    readonly [_EFFECT_BACK_REF]: Map<_EffectProperty | string, EffectSubscription> | 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(): ValueOrPromise<void>;
+    waitForPendingFlush(): ValueOrPromise<void>;
+    streamBlockStart(): void;
+    streamBlockEnd(): ValueOrPromise<void>;
+}
+
+/** Retains job metadata and also serves as the argument for CTX_ARG compute functions */
+declare class Job<T> implements ComputeCtx<T> {
+    readonly $signal$: ComputedSignalImpl<T, any>;
+    /** First holds the compute promise and then the cleanup promise */
+    $promise$: Promise<void> | null | void;
+    $cleanupRequested$: boolean;
+    $canWrite$: boolean;
+    $track$: Tracker | undefined;
+    $cleanups$: Parameters<ComputeCtx<T>['cleanup']>[0][] | undefined;
+    $abortController$: AbortController | undefined;
+    info: unknown;
+    $infoVersion$: number | undefined;
+    constructor($signal$: ComputedSignalImpl<T, any>, info: unknown, $infoVersion$: number | undefined);
+    get track(): Tracker;
+    get abortSignal(): AbortSignal;
+    /** Backward compatible cache method for resource */
+    cache(): void;
+    get previous(): T | undefined;
+    cleanup(callback: () => void): 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 */
@@ -1530,8 +1888,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;
@@ -1539,6 +1901,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.
  *
@@ -1552,15 +1922,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;
+    };
 }
 
 /**
@@ -1576,6 +1999,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
@@ -1586,7 +2016,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.
@@ -1596,13 +2026,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
@@ -1610,11 +2040,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$`)
@@ -1623,6 +2057,27 @@ 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;
+    $hasMovedCaptures$?: boolean;
+    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 = {
@@ -1666,6 +2121,28 @@ 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;
+
+/**
+ * Mark this signal as owned outside of the component that read it.
+ *
+ * Externally owned signals are preserved when found in a component's sequential scope during
+ * component cleanup.
+ *
+ * @internal
+ */
+export declare const _markSignalAsExternallyOwned: (signal: ComputedSignal<unknown>) => void;
+
+declare class MaybeAsyncSignal {
+}
+
 declare type MediaSpecialAttrs = {
     crossOrigin?: HTMLCrossOriginAttribute;
 };
@@ -1706,16 +2183,19 @@ export declare type NativeUIEvent = UIEvent;
 /** @public @deprecated Use `WheelEvent` and use the second argument to the handler function for the current event target */
 export declare type NativeWheelEvent = WheelEvent;
 
+/** @internal */
+export declare function _newInvokeContext(locale?: string, hostElement?: _HostElement, event?: Exclude<PossibleEvents, typeof RenderEvent>): InvokeContext;
+
 declare interface NodePropData {
     $scopedStyleIdPrefix$: string | null;
     $isConst$: boolean;
 }
 
 /** @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.
@@ -1782,6 +2262,31 @@ export declare interface OnVisibleTaskOptions {
     strategy?: VisibleTaskStrategy;
 }
 
+/** @internal */
+declare type OutOfOrderRevealBoundary = {
+    attrs: string;
+    showFallback: boolean;
+    resolve: () => void;
+};
+
+/** @internal */
+declare class OutOfOrderRevealCoordinator<ITEM extends RevealItemLike = RevealItemLike> {
+    private id;
+    private collapsed;
+    private count;
+    private pendingItems;
+    private orderCode;
+    constructor(id: number, order: RevealOrder, collapsed: boolean);
+    register(registration: RevealRegistrationLike<ITEM>): OutOfOrderRevealBoundary;
+    canReveal(registration: RevealRegistrationLike<ITEM>): boolean;
+    script(): string;
+}
+
+/** @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
@@ -1789,19 +2294,15 @@ 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';
+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';
 
-/**
- * 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 Passive = {
+    [K in keyof HTMLElementEventMap as `passive:${K}`]?: boolean;
 };
 
 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
@@ -1877,7 +2378,7 @@ export declare const PrefetchServiceWorker: (opts: {
  * @returns The preprocessed state data
  * @internal
  */
-export declare function _preprocessState(data: unknown[], container: DeserializeContainer): void;
+export declare function _preprocessState(data: unknown[], container: DeserializeContainer, segmentId?: string, startIndex?: number): void;
 
 declare type Prettify<T> = {} & {
     [K in keyof T]: T[K];
@@ -1899,6 +2400,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.
  *
@@ -1921,7 +2425,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
@@ -1934,6 +2455,20 @@ export declare type PublicProps<PROPS> = (PROPS extends Record<any, any> ? Omit<
 /** @internal */
 export declare interface _QDocument extends Document {
     qVNodeData: WeakMap<Element, string>;
+    /** True once root document VNode data has been scheduled at least once. */
+    qVNodeDataStarted?: boolean;
+    /** True when root, segment, and patch VNode data work is fully drained. */
+    qVNodeDataReady?: boolean;
+    /** Internal yielding state for queued VNode data jobs. */
+    qVNodeDataState?: unknown;
+    /** Callbacks waiting for root, segment, and patch VNode data work to drain. */
+    qVNodeDataCallbacks?: Array<() => void>;
+    /** True once the root document VNode data has been fully processed. */
+    qVNodeDataProcessed?: boolean;
+    /** Processes one vnode patch script. */
+    qProcessVNodeDataPatch?: (script: Element | null) => void;
+    /** Processes an out-of-order Suspense segment after its resolved HTML is swapped in. */
+    qProcessOOOS?: (boundaryId: number, content: Element | null) => void;
 }
 
 /**
@@ -2037,7 +2572,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>
  * ```
  *
@@ -2060,7 +2595,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. */
@@ -2068,7 +2603,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>>;
 
 /**
@@ -2083,10 +2618,12 @@ 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[];
 
+declare type QrlCaptures = Readonly<unknown[]> | string | null;
+
 /** @public */
 declare interface QRLDev {
     file: string;
@@ -2095,31 +2632,56 @@ 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;
+    /** Captures are stored lazily after deserialization. */
+    readonly $captures$?: QrlCaptures;
+    readonly $hasMovedCaptures$?: boolean;
+    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: QrlCaptures): _QRLInternal<TYPE>;
+    /** Mark that the handler receives captures moved to its element. */
+    m(): _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;
@@ -2136,50 +2698,26 @@ 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];
+
+/** @internal */
+export declare const _qrlWithChunk: <T = any>(chunk: string, importer: () => Promise<any>, symbol: string, lexicalScopeCapture?: Readonly<unknown[]>) => QRL<T>;
+
+/** @internal */
+export declare const _qrlWithChunkDEV: <T = any>(chunk: string, importer: () => Promise<any>, symbol: string, opts: QRLDev, lexicalScopeCapture?: Readonly<unknown[]>) => QRL<T>;
+
 /** @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;
 
@@ -2189,13 +2727,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> {
 }
@@ -2204,11 +2748,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
  *
@@ -2279,78 +2825,31 @@ declare namespace QwikJSX {
 export { QwikJSX as JSX }
 export { QwikJSX }
 
+declare type QwikJSXEvents = JSXElementEvents & JSXDocumentEvents & JSXWindowEvents;
+
 /** @public @deprecated Use `KeyboardEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikKeyboardEvent<T = Element> = NativeKeyboardEvent;
 
 declare type QwikKnownEvents<EL> = {
-    [K in keyof AllPascalEventMaps as `${'document:' | 'window:' | ''}on${K}$`]?: QRLEventHandlerMulti<AllPascalEventMaps[K], EL>;
+    [K in keyof QwikJSXEvents]?: QRLEventHandlerMulti<QwikJSXEvents[K], EL>;
 };
 
 declare type QwikKnownEventsPlain<EL> = {
-    [K in keyof AllPascalEventMaps as `${'document:' | 'window:' | ''}on${K}$`]?: QRLEventHandlerMulti<AllPascalEventMaps[K], EL> | EventHandler<AllPascalEventMaps[K], EL>;
+    [K in keyof QwikJSXEvents]?: QRLEventHandlerMulti<QwikJSXEvents[K], EL> | EventHandler<QwikJSXEvents[K], EL>;
 };
 
-/**
- * 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;
-    };
-}
-
 /** @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;
 
 /** @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;
 
@@ -2363,32 +2862,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;
 }>;
 
@@ -2402,19 +2881,33 @@ 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;
+
+/**
+ * @deprecated Use `Readonly<Signal<T>>` instead.
+ * @public
+ */
 export declare interface ReadonlySignal<T = unknown> {
     readonly value: T;
 }
 
+/** @internal */
+export declare const _reC: (props: RevealProps) => JSXNodeInternal<InternalServerComponent<SSRRevealSlotProps>> | JSXNodeInternal<FunctionComponent<    {
+name?: string;
+children?: JSXChildren;
+}>>;
+
 /**
  * A ref can be either a signal or a function. Note that the type of Signal is Element so that it
  * can accept more specialized elements too
@@ -2431,9 +2924,26 @@ 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;
 
+declare class RemoveAllChildrenOperation {
+    target: Element;
+    constructor(target: Element);
+}
+
+/**
+ * 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.
  *
@@ -2451,19 +2961,14 @@ export declare const render: (parent: Element | Document, jsxNode: JSXOutput | F
 
 declare const RenderEvent = "qRender";
 
-declare interface RenderInvokeContext extends InvokeContext {
-    $hostElement$: HostElement;
-    $event$: PossibleEvents;
-    $waitOn$: Promise<unknown>[];
-    $container$: Container;
-}
-
 /** @public */
 export declare const RenderOnce: FunctionComponent<{
     children?: unknown;
     key?: string | number | null | undefined;
 }>;
 
+/** @internal */
+/** @internal */
 /** @public */
 export declare interface RenderOptions {
     serverData?: Record<string, any>;
@@ -2484,82 +2989,64 @@ export declare interface RenderSSROptions {
     manifestHash: string;
 }
 
-/** @public */
-declare interface ResolvedManifest {
-    mapper: SymbolMapper;
-    manifest: ServerQwikManifest;
-    injections?: GlobalInjections[];
-    bundleGraph?: QwikBundleGraph;
-}
+/** @internal */
+export declare const _reR: () => boolean;
 
 /**
- * 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 | Promise<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 ComputeCtx<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$()`
@@ -2576,71 +3063,108 @@ 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;
+
+/** @internal */
+export declare const _reT: ({ cleanup }: TaskCtx) => void;
 
 /**
- * This is called by qwik-loader to schedule a QRL. It has to be synchronous.
+ * Retries a function that throws a promise. If you pass `onError`, you're responsible for handling
+ * errors.
  *
  * @internal
  */
-export declare const _run: (...args: unknown[]) => ValueOrPromise_2<void>;
+export declare function _retryOnPromise<T>(fn: () => ValueOrPromise<T>, onError?: (e: any) => ValueOrPromise<T>): ValueOrPromise<T>;
+
+/** @public @experimental */
+export declare const Reveal: typeof _reC;
+
+declare interface RevealItemLike {
+    boundary: {
+        untrackedValue: number;
+    };
+}
+
+/** @public @experimental */
+export declare type RevealOrder = 'parallel' | 'sequential' | 'reverse' | 'together';
+
+/** @public @experimental */
+export declare type RevealProps = {
+    order?: RevealOrder;
+    collapsed?: boolean;
+};
 
-declare type Scheduler = ReturnType<typeof createScheduler>;
+declare interface RevealRegistrationLike<ITEM extends RevealItemLike = RevealItemLike> {
+    reveal: {
+        order: RevealOrder;
+        items: ITEM[];
+    };
+    item: ITEM;
+}
 
+/**
+ * The resource function wrapper
+ *
+ * @internal
+ */
+export declare const _rsc: <T>(arg: ResourceCtx<T>) => Promise<{
+    r: T;
+}>;
+
+/**
+ * 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 SegmentRenderContext {
+    container: SSRSegmentContainer;
+    writer: SSRInternalStreamWriter;
+    htmlChunks: SSRSegmentWriteChunk[];
 }
 
 declare interface SerializationContext {
-    $serialize$: () => void;
+    $serialize$: () => ValueOrPromise<void>;
+    $serializePatch$: (rootStart: number, rootIds: number[], extraRootId?: number | string | number[], streamedRootLimit?: number) => ValueOrPromise<void>;
     $symbolToChunkResolver$: SymbolToChunkResolver;
     /**
      * Map from object to parent and index reference.
@@ -2652,60 +3176,76 @@ 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.
+     * Roots are entry points into the object graph. Typically the roots are held by the listeners.
      *
-     * 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;
+    $addDuplicateRoot$: (obj: unknown) => SeenRef;
+    $commitRoot$: (root: unknown, obj: unknown) => number;
+    /** Mark an object as seen during serialization. This is used to handle backreferences and cycles */
+    $markSeen$: (obj: unknown, parent: SeenRef | undefined, index: number) => SeenRef;
     $roots$: unknown[];
-    $objectPathStringCache$: Map<unknown, string | number>;
+    $rootObjs$: unknown[];
+    $onAddRoot$?: (id: number, root: unknown, obj: unknown) => void;
+    $forwardRefOffset$: number;
+    $serializedRootCount$: number;
+    $serializedForwardRefCount$: number;
+    $rootStateRootCount$: number;
+    $hasRootStateForwardRefs$: boolean;
+    $promoteToRoot$: (ref: SeenRef, obj: unknown, index?: number) => void;
     $addSyncFn$($funcStr$: string | null, argsCount: number, fn: Function): number;
-    $isSsrNode$: (obj: unknown) => obj is SsrNode;
+    $setSyncFnOffset$(offset: number, existingFns?: string[]): void;
+    $isSsrNode$: (obj: unknown) => obj is ISsrNode;
     $isDomRef$: (obj: unknown) => obj is DomRef;
-    $writer$: StreamWriter_2;
+    $markSsrNodeForSerialization$: (node: ISsrNode, flags: number) => void;
+    $writer$: SSRInternalStreamWriter;
+    $setWriter$(writer: SSRInternalStreamWriter): void;
     $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;
 }
 
-/** @public */
-export declare type SerializationStrategy = 'never' | 'always';
-
-declare class SerializationWeakRef {
-    $obj$: unknown;
-    constructor($obj$: unknown);
+declare const enum SerializationSignalFlags {
+    SERIALIZATION_STRATEGY_NEVER = 8,
+    SERIALIZATION_STRATEGY_ALWAYS = 16,
+    SERIALIZATION_ALL_STRATEGIES = 24
 }
 
-/** @internal */
-export declare const _serializationWeakRef: (obj: unknown) => SerializationWeakRef;
+/**
+ * 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.
@@ -2768,9 +3308,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;
 }
 
 /**
@@ -2791,12 +3331,17 @@ 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'>;
+declare class SetAttributeOperation {
+    target: Element;
+    attrName: string;
+    attrValue: any;
+    scopedStyleIdPrefix: string | null;
+    isSvg: boolean;
+    constructor(target: Element, attrName: string, attrValue: any, scopedStyleIdPrefix: string | null, isSvg: boolean);
+}
+
+/** @internal */
+export declare function _setEvent(serializationCtx: SerializationContext, key: string, rawValue: unknown, hasMovedCaptures: boolean): string | SSRWriteChunk[] | null;
 
 /**
  * Sets the `CorePlatform`.
@@ -2810,19 +3355,39 @@ 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;
+
+declare class SetTextOperation {
+    target: Text;
+    text: string;
+    constructor(target: Text, text: string);
+}
+
 /** @internal */
-export declare abstract class _SharedContainer implements Container {
+export declare abstract class _SharedContainer implements _Container {
     readonly $version$: string;
-    readonly $scheduler$: Scheduler;
     readonly $storeProxyMap$: ObjToProxyMap;
+    $rootContainer$: _Container | null;
+    $isOutOfOrderSegment$: boolean;
     readonly $locale$: string;
     readonly $getObjectById$: (id: number | string) => any;
     $serverData$: Record<string, any>;
     $currentUniqueId$: number;
     $instanceHash$: string | null;
     $buildBase$: string | null;
-    constructor(scheduleDrain: () => void, journalFlush: () => void, serverData: Record<string, any>, locale: string);
-    trackSignalValue<T>(signal: Signal, subscriber: HostElement, property: string, data: _SubscriptionData): T;
+    $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[]): {
             __brand__: 'SsrNode';
@@ -2832,16 +3397,36 @@ export declare abstract class _SharedContainer implements Container {
             __brand__: 'DomRef';
         };
     } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter): SerializationContext;
-    abstract ensureProjectionResolved(host: HostElement): void;
-    abstract handleError(err: any, $host$: HostElement): 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;
-    abstract setHostProp<T>(host: HostElement, name: string, value: T): void;
-    abstract getHostProp<T>(host: HostElement, name: string): T | null;
-    abstract $appendStyle$(content: string, styleId: string, host: HostElement, scoped: boolean): void;
+    $checkPendingCount$(): void;
+    abstract ensureProjectionResolved(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;
+    abstract setHostProp<T>(host: _HostElement, name: string, value: T): void;
+    abstract getHostProp<T>(host: _HostElement, name: string): T | null;
+    abstract $appendStyle$(content: string, styleId: string, host: _HostElement, scoped: boolean): void;
+}
+
+/** @internal */
+export declare const _shC: (props: ShowProps<any>) => JSXNode<unknown>;
+
+/** @public @experimental */
+export declare const Show: ShowComponent;
+
+/** @public @experimental */
+export declare type ShowComponent = <WHEN = unknown, THEN extends JSXOutput = JSXOutput, ELSE extends JSXOutput = JSXOutput>(props: PublicProps<ShowProps<WHEN, THEN, ELSE>>, key: string | null, flags: number, dev?: DevJSX) => JSXOutput;
+
+/** @public @experimental */
+export declare interface ShowProps<WHEN = unknown, THEN extends JSXOutput = JSXOutput, ELSE extends JSXOutput = JSXOutput> {
+    when$: QRL<() => WHEN>;
+    then$: QRL<(when: WHEN) => THEN>;
+    else$?: QRL<(when: WHEN) => ELSE>;
 }
 
+/** @internal */
+export declare const _shT: ({ track }: TaskCtx) => ValueOrPromise<void | undefined>;
+
 /**
  * A signal is a reactive value which can be read and written. When the signal is written, all tasks
  * which are tracking the signal will be re-run and all components that read the signal will be
@@ -2854,20 +3439,32 @@ 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;
-}
-
-declare const enum SignalFlags {
-    INVALID = 1
+    /** 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 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;
@@ -2885,12 +3482,6 @@ declare interface SimplifiedServerRequestEvent<T = unknown> {
     request: Request;
 }
 
-/** @public */
-declare interface SingleEntryStrategy {
-    type: 'single';
-    manual?: Record<string, string>;
-}
-
 /** @public */
 declare type Size = number | string;
 
@@ -2908,12 +3499,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;
@@ -3154,49 +3739,65 @@ 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 writer: StreamWriter;
+    readonly size: number;
+    readonly writer: SSRInternalStreamWriter;
+    readonly streamHandler: IStreamHandler;
     readonly serializationCtx: SerializationContext;
     readonly symbolToChunkResolver: SymbolToChunkResolver;
     readonly resolvedManifest: ResolvedManifest;
+    readonly outOfOrderStreaming: boolean;
     additionalHeadNodes: Array<JSXNodeInternal>;
     additionalBodyNodes: Array<JSXNodeInternal>;
-    unclaimedProjectionComponentFrameQueue: ISsrComponentFrame[];
+    $noScriptHere$: number;
+    /**
+     * Lets the container place a root-level `useOn` placeholder `<script>` itself when injecting it
+     * inline would put it at an illegal position. Returns `true` if the container took the node, in
+     * which case the caller must not inject it into the component's JSX.
+     */
+    $deferRootPlaceholder$(scriptNode: JSXNodeInternal<string>): boolean;
+    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;
-    addRoot(obj: any): number | undefined;
+    addRoot(obj: any): number | string | undefined;
     getOrCreateLastNode(): ISsrNode;
     addUnclaimedProjection(frame: ISsrComponentFrame, name: string, children: JSXChildren): void;
     isStatic(): boolean;
     render(jsx: JSXOutput): Promise<void>;
+    renderJSX(jsx: JSXOutput, options: SSRRenderJSXOptions): Promise<void>;
+    $runQueuedRender$<T>(render: () => ValueOrPromise<T>): ValueOrPromise<T>;
+    nextOutOfOrderId(): number;
+    emitOutOfOrderSegmentScripts(scripts: string): void;
+    segment(segmentId: string, jsx: JSXOutput, options: SSRRenderJSXOptions): Promise<SSROutOfOrderSegment>;
+    queueOutOfOrderSegment(segment: Promise<void>): void;
+    emitOutOfOrderExecutorIfNeeded(): void;
+    emitInlineScript(script: string): void;
+    writeScript(attrs: Props, body?: string): void;
     emitPreloaderPre(): void;
     emitQwikLoaderAtTopIfNeeded(): void;
+    emitPatchDataIfNeeded(): void;
+    emitBackpatchDataAndExecutorIfNeeded(): void;
+    addBackpatchEntry(ssrNodeId: string, attrName: string, serializedValue: string | boolean | null): void;
 }
 
 /** @public */
@@ -3204,19 +3805,68 @@ export declare type SSRHintProps = {
     dynamic?: boolean;
 };
 
-/** A selection of attributes of the real thing */
-declare type SsrNode = {
-    id: string;
-    children: ISsrNode[] | null;
-    vnodeData: VNodeData;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
-};
+/** @internal */
+declare interface SSRInternalStreamWriter extends StreamWriter {
+    writeRootRef(id: number): ValueOrPromise<void>;
+    writeRootRefPath(path: number[]): ValueOrPromise<void>;
+    writeRootRefDelta(id: number, base: number): ValueOrPromise<void>;
+    toString(remap?: number[]): string;
+}
+
+declare const enum SsrNodeFlags {
+    Updatable = 1,
+    WarnedStreamedChore = 2
+}
+
+declare type SSROutOfOrderSegment = SegmentRenderContext;
 
 /** @public */
 export declare const SSRRaw: FunctionComponent<{
     data: string;
 }>;
 
+declare interface SSRRenderJSXOptions {
+    currentStyleScoped: string | null;
+    parentComponentFrame: ISsrComponentFrame | null;
+}
+
+declare type SSRRevealSlotProps = {
+    coordinator: OutOfOrderRevealCoordinator;
+};
+
+/** @internal */
+declare interface SSRRootRefDeltaChunk {
+    readonly id: number;
+    readonly base: number;
+}
+
+/** @internal */
+declare interface SSRRootRefPathChunk {
+    readonly path: number[];
+}
+
+declare interface SSRSegmentContainer extends SSRContainer {
+    $rootContainer$: SSRContainer;
+    $recordExternalRootEffect$(producer: unknown, effect: EffectSubscription, prop: string | symbol | null, sourceEffects?: Map<string | symbol, Set<EffectSubscription>>): void;
+    $finalizeOutOfOrderSegment$(segmentId: string, segment: SSROutOfOrderSegment): Promise<{
+        html: string;
+        scripts: string;
+    }>;
+}
+
+/** @internal */
+declare type SSRSegmentWriteChunk = string | {
+    readonly type: 'root-ref';
+    readonly localId: number;
+} | {
+    readonly type: 'root-ref-path';
+    readonly localPath: number[];
+} | {
+    readonly type: 'root-ref-delta';
+    readonly localId: number;
+    readonly localBaseId: number;
+};
+
 /** @public */
 export declare const SSRStream: FunctionComponent<SSRStreamProps>;
 
@@ -3226,43 +3876,42 @@ 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;
+}
+
+/** @internal */
+declare type SSRWriteChunk = string | number | SSRRootRefPathChunk | SSRRootRefDeltaChunk;
+
+declare type StackFn = () => ValueOrPromise<void>;
+
+declare type StackValue = ValueOrPromise<JSXOutput | StackFn | Promise<JSXOutput> | typeof Promise | AsyncGenerator | typeof MaybeAsyncSignal>;
+
 declare type StopPropagation = {
     [K in keyof HTMLElementEventMap as `stoppropagation:${K}`]?: boolean;
 };
 
-declare const enum StoreFlags {
+/** @internal */
+export 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 */
 export declare interface StreamWriter {
-    write(chunk: string): void;
+    write(chunk: string): ValueOrPromise<void>;
+    waitForDrain?(): ValueOrPromise<void>;
 }
 
 /** @file Shared types */
@@ -3275,6 +3924,28 @@ export declare class _SubscriptionData {
     constructor(data: NodePropData);
 }
 
+/** @internal */
+export declare class _SubscriptionPatch {
+    rootId: number;
+    subscriptions: Set<EffectSubscription> | Map<string | symbol, Set<EffectSubscription>>;
+    constructor(rootId?: number, subscriptions?: Set<EffectSubscription> | Map<string | symbol, Set<EffectSubscription>>);
+}
+
+/** @internal */
+export declare const _suC: (props: SuspenseProps) => JSXNodeInternal<string>[];
+
+/** @public @experimental */
+export declare const Suspense: typeof _suC;
+
+/** @public @experimental */
+export declare type SuspenseProps = {
+    fallback?: JSXOutput;
+    delay?: number;
+};
+
+/** @internal */
+export declare const _suT: ({ track, cleanup }: TaskCtx) => void;
+
 /**
  * The TS types don't include the SVG attributes so we have to define them ourselves
  *
@@ -3544,12 +4215,9 @@ export declare interface SVGAttributes<T extends Element = Element> extends Aria
 }
 
 /** @public */
-declare interface SVGProps<T extends Element> extends SVGAttributes, QwikAttributes<T> {
+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;
 
 /**
@@ -3563,18 +4231,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 = {
@@ -3584,49 +4253,59 @@ 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>> {
-    $flags$: number;
+/** @internal */
+export declare class _Task<T = unknown, B = T> extends BackRef {
+    $flags$: TaskFlags;
     $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);
+    $el$: _HostElement;
+    $qrl$: _QRLInternal<T>;
+    $destroy$: (() => void) | null;
+    $destroyPromise$: Promise<void> | undefined;
+    $taskPromise$: Promise<void> | null;
+    constructor($flags$: TaskFlags, $index$: number, $el$: _HostElement, $qrl$: _QRLInternal<T>, $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 | Promise<void>;
 
 /** @public */
 export declare interface TaskCtx {
     track: Tracker;
-    cleanup: (callback: () => void) => void;
+    cleanup: (callback: () => ValueOrPromise<void>) => void;
 }
 
 declare const TaskEvent = "qTask";
 
+/** @internal */
+declare const enum TaskFlags {
+    VISIBLE_TASK = 1,
+    TASK = 2,
+    DIRTY = 4,
+    RENDER_BLOCKING = 8,
+    NEEDS_CLEANUP = 16,
+    EVENTS_REGISTERED = 32
+}
+
+/** @public */
+export declare type TaskFn = (ctx: TaskCtx) => ValueOrPromise<void | (() => ValueOrPromise<void>)>;
+
 /** @public */
-export declare type TaskFn = (ctx: TaskCtx) => ValueOrPromise<void | (() => void)>;
+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.
@@ -3647,6 +4326,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;
@@ -3717,11 +4398,18 @@ export declare interface Tracker {
 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';
 
@@ -3734,19 +4422,42 @@ 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.
+ *
+ * @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.
  *
- * The function must be synchronous and must not have any side effects.
+ * 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.
+ *
+ * @deprecated Use `useComputed$` instead, it has async support now. It auto-tracks synchronous
+ *   reads; after the first `await`, use the provided `track()` like before.
  * @public
  */
-export declare const useAsyncComputed$: <T>(qrl: AsyncComputedFn<T>, options?: ComputedOptions | undefined) => 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>>, options?: ComputedOptions) => AsyncComputedReturnType<T>;
+/**
+ * @deprecated Use `useComputed$` instead, it has async support now.
+ * @internal
+ */
+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
@@ -3754,24 +4465,42 @@ export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>, opti
  * 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.
  *
- * The function must be synchronous and must not have any side effects.
+ * Every synchronous signal or store read is tracked automatically. Reads after an `await` are not:
+ * the tracking context is lost, so track them explicitly with the `track()` provided on the context
+ * argument. When the function is async, the returned signal exposes the async API: reading an
+ * unresolved `.value` throws the computation promise, and `.pending` and `.error` expose the
+ * computation state.
+ *
+ * The function must not have any side effects.
  *
  * @public
  */
-export declare const useComputed$: <T>(qrl: ComputedFn<T>, options?: ComputedOptions | undefined) => ComputedReturnType<T>;
+export declare const useComputed$: <T>(qrl: ComputedFn<T>, options?: ComputedOptions<T> | undefined) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions) => ComputedReturnType<T>;
+export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions<T>) => 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;
@@ -3883,12 +4612,17 @@ 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;
 
-/** @internal */
-export declare const _useInvokeContext: () => RenderInvokeContext;
-
 /**
  * Used by the Qwik Optimizer to restore the lexically scoped variables.
  *
@@ -3897,6 +4631,7 @@ export declare const _useInvokeContext: () => RenderInvokeContext;
  * 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;
@@ -3907,10 +4642,12 @@ 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`.
  */
-export declare const useOn: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>) => void;
+export declare const useOn: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>, options?: UseOnOptions) => void;
 
 /**
  * Register a listener on `document`.
@@ -3918,6 +4655,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`.
  *
@@ -3937,7 +4676,21 @@ export declare const useOn: <T extends KnownEventNames>(event: T | T[], eventQrl
  * });
  * ```
  */
-export declare const useOnDocument: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>) => void;
+export declare const useOnDocument: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>, options?: UseOnOptions) => void;
+
+/** @public */
+export declare type UseOnOptions = UseOnOptionsBase & ({
+    passive?: boolean;
+    preventdefault?: never;
+} | {
+    passive?: never;
+    preventdefault?: boolean;
+});
+
+declare interface UseOnOptionsBase {
+    capture?: boolean;
+    stoppropagation?: boolean;
+}
 
 /**
  * Register a listener on `window`.
@@ -3945,6 +4698,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`.
  *
@@ -3965,7 +4720,7 @@ export declare const useOnDocument: <T extends KnownEventNames>(event: T | T[],
  * });
  * ```
  */
-export declare const useOnWindow: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>) => void;
+export declare const useOnWindow: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>, options?: UseOnOptions) => void;
 
 /**
  * This method works like an async memoized function that runs whenever some tracked value changes
@@ -3983,45 +4738,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 `useComputed$` instead, which is more powerful and flexible. `useResource$` is
+ *   still available for backward compatibility but it is recommended to migrate to `useComputed$`
+ *   for new code and when updating existing code.
  * @public
+ * @see useComputed$
  * @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>;
@@ -4090,7 +4815,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>>) => ComputedSignal_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;
@@ -4104,14 +4829,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.
  *
- * 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.
+ * `Store`s are deep by default, meaning that any objects assigned to properties will also become
+ * `Store`s. This includes arrays.
+ *
+ * Prefer `useSignal` over `useStore` when possible, as it is more efficient.
  *
  * ### Example
  *
@@ -4291,10 +5063,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
@@ -4324,6 +5096,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 | Promise<void>;
+
 /**
  * Type representing a value which is either resolve or a promise.
  *
@@ -4338,38 +5117,83 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.4-dev+9849dcf
+ * 2.0.0-beta.40-dev+a459d55
  *
  * @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_getElementName: (vnode: _ElementVNode) => string;
+
+/** @internal */
+export declare const _vnode_getFirstChild: (vnode: _VNode) => _VNode | null;
+
+/** @internal */
+export declare const _vnode_getProp: <T = unknown>(vNode: _VNode, key: string, getObject: ((id: string) => unknown) | null) => T | null;
+
+/** @internal */
+export declare const _vnode_getVNodeForChildNode: (vNode: _ElementVNode, childElement: Element) => _ElementVNode;
+
+/** @internal */
+export declare const _vnode_insertBefore: (journal: _VNodeJournal, parent: _ElementVNode | _VirtualVNode, newChild: _VNode, insertBefore: _VNode | null) => void;
+
+/** @internal */
+export declare const _vnode_isElementVNode: (vNode: _VNode) => vNode is _ElementVNode;
+
+/** @internal */
+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 const _vnode_newVirtual: () => _VirtualVNode;
+
+/** @internal */
+export declare const _vnode_remove: (journal: _VNodeJournal, vParent: _ElementVNode | _VirtualVNode, vToRemove: _VNode, removeDOM: boolean) => void;
+
+/** @internal */
+export declare const _vnode_setProp: (vNode: _VNode, key: string, value: unknown) => void;
 
 /** @internal */
-export declare function _vnode_toString(this: _VNode | null, depth?: number, offset?: string, materialize?: boolean, siblings?: boolean, colorize?: boolean): string;
+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.
@@ -4398,7 +5222,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)
@@ -4437,46 +5261,34 @@ 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
+    NS_svg = 512,// http://www.w3.org/2000/svg
+    NS_math = 1024,// http://www.w3.org/1998/Math/MathML
+    HasTargetElement = 2048
 }
 
-declare type VNodeJournal = Array<VNodeJournalOpCode | Document | Element | Text | string | boolean | null>;
+/** @internal */
+export declare type _VNodeJournal = Array<VNodeOperation>;
 
-/**
- * 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
-}
+declare type VNodeOperation = DeleteOperation | RemoveAllChildrenOperation | SetTextOperation | InsertOrMoveOperation | SetAttributeOperation;
 
 /** @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: {
-    currentStyleScoped: string | null;
-    parentComponentFrame: ISsrComponentFrame | null;
-}): Promise<void>;
+export declare function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: SSRRenderJSXOptions): Promise<void>;
 
 /**
  * Override the `getLocale` with `lang` within the `fn` execution.
@@ -4485,27 +5297,20 @@ export declare function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: {
  */
 export declare function withLocale<T>(locale: string, fn: () => T): T;
 
-declare const enum WrappedSignalFlags {
-    UNWRAP = 2
-}
+declare type WrappedProp<T extends object, P extends keyof T> = T extends Signal ? WrappedSignalImpl<PropType<T, P>> : PropType<T, P>;
 
-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);
+    $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?: AllSignalFlags);
     invalidate(): void;
-    /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object.
-     */
-    force(): void;
     get untrackedValue(): T;
-    $computeIfNeeded$(): boolean;
+    $computeIfNeeded$(): void;
+    $unwrapIfSignal$(): SignalImpl<T> | WrappedSignalImpl<T>;
     set value(_: any);
     get value(): any;
 }
@@ -4521,9 +5326,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;
+export declare const _wrapSignal: <T extends object, P extends keyof T>(obj: T, prop: P) => T[P] | WrappedProp<T, P>;
 
 export { }