@qwik.dev/core 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/core-internal.d.ts

@@ -1,11 +1,10 @@
+import { ComputedSignal as ComputedSignal_2 } from '..';
 import * as CSS_2 from 'csstype';
 import { isBrowser } from './build';
 import { isDev } from './build';
 import { isServer } from './build';
 import { QRL as QRL_2 } from './qrl.public';
-import { ReadonlySignal as ReadonlySignal_2 } from '..';
 import type { StreamWriter as StreamWriter_2 } from '.';
-import { ValueOrPromise as ValueOrPromise_2 } from '..';
 
 /**
  * Qwik Optimizer marker function.
@@ -99,7 +98,7 @@ declare type _AllowPlainQrl<Q> = QRLEventHandlerMulti<any, any> extends Q ? Q ex
 
 declare type AllPascalEventMaps = PascalMap<AllEventsMap>;
 
-declare type AllSignalFlags = SignalFlags | WrappedSignalFlags;
+declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags;
 
 /**
  * TS defines these with the React syntax which is not compatible with Qwik. E.g. `ariaAtomic`
@@ -366,12 +365,47 @@ declare type AsyncComputedCtx = {
 export declare type AsyncComputedFn<T> = (ctx: AsyncComputedCtx) => Promise<T>;
 
 /** @public */
-export declare interface AsyncComputedReadonlySignal<T = unknown> extends ReadonlySignal<T> {
+export declare interface AsyncComputedReadonlySignal<T = unknown> extends ComputedSignal<T> {
+    /** Whether the signal is currently loading. */
+    loading: boolean;
+    /** The error that occurred while computing the signal. */
+    error: Error | null;
 }
 
 /** @public */
 export declare type AsyncComputedReturnType<T> = T extends Promise<infer T> ? AsyncComputedReadonlySignal<T> : AsyncComputedReadonlySignal<T>;
 
+/**
+ * # ================================
+ *
+ * AsyncComputedSignalImpl
+ *
+ * # ================================
+ */
+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 | SerializationSignalFlags);
+    /**
+     * 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 | undefined;
+}
+
 declare type AsyncComputeQRL<T> = QRLInternal<AsyncComputedFn<T>>;
 
 /**
@@ -400,6 +434,32 @@ declare type BivariantQrlFn<ARGS extends any[], RETURN> = {
 /** @public */
 declare type Booleanish = boolean | `${boolean}`;
 
+declare interface Chore<T extends ChoreType = ChoreType> {
+    $type$: T;
+    $idx$: number | string;
+    $host$: HostElement;
+    $target$: ChoreTarget | null;
+    $payload$: unknown;
+    $state$: ChoreState;
+    $blockedChores$: Chore[] | null;
+    $startTime$: number | undefined;
+    $endTime$: number | undefined;
+    $resolve$: ((value: any) => void) | undefined;
+    $reject$: ((reason?: any) => void) | undefined;
+    $returnValue$: ValueOrPromise<ChoreReturnValue<T>>;
+}
+
+declare type ChoreReturnValue<T extends ChoreType = ChoreType> = T extends ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS | ChoreType.WAIT_FOR_QUEUE | ChoreType.NODE_PROP ? void : T extends ChoreType.NODE_DIFF | ChoreType.COMPONENT ? JSXOutput : unknown;
+
+declare enum ChoreState {
+    NONE = 0,
+    RUNNING = 1,
+    FAILED = 2,
+    DONE = 3
+}
+
+declare type ChoreTarget = HostElement | QRLInternal<(...args: unknown[]) => unknown> | Signal | StoreTarget;
+
 declare const enum ChoreType {
     MACRO = 240,
     MICRO = 15,
@@ -411,10 +471,9 @@ declare const enum ChoreType {
     NODE_PROP = 5,
     COMPONENT = 6,
     RECOMPUTE_AND_SCHEDULE_EFFECTS = 7,
-    JOURNAL_FLUSH = 16,
-    VISIBLE = 32,
-    CLEANUP_VISIBLE = 48,
-    WAIT_FOR_ALL = 255
+    VISIBLE = 16,
+    CLEANUP_VISIBLE = 32,
+    WAIT_FOR_QUEUE = 255
 }
 
 /**
@@ -438,9 +497,8 @@ export declare interface ClientContainer extends Container {
     qManifestHash: string;
     rootVNode: _ElementVNode;
     $journal$: VNodeJournal;
-    renderDone: Promise<void> | null;
     $forwardRefs$: Array<number> | null;
-    $initialQRLsIndexes$: Array<number> | null;
+    $flushEpoch$: number;
     parseQRL<T = unknown>(qrl: string): QRL<T>;
     $setRawState$(id: number, vParent: _ElementVNode | _VirtualVNode): void;
 }
@@ -540,7 +598,13 @@ export declare const componentQrl: <PROPS extends Record<any, any>>(componentQrl
 export declare type ComputedFn<T> = () => T;
 
 /** @public */
-export declare type ComputedReturnType<T> = T extends Promise<any> ? never : ReadonlySignal<T>;
+export declare interface ComputedOptions {
+    serializationStrategy?: SerializationStrategy;
+    container?: Container;
+}
+
+/** @public */
+export declare type ComputedReturnType<T> = T extends Promise<any> ? never : ComputedSignal<T>;
 
 /**
  * A computed signal is a signal which is calculated from other signals. When the signals change,
@@ -551,10 +615,15 @@ export declare type ComputedReturnType<T> = T extends Promise<any> ? never : Rea
  */
 export declare interface ComputedSignal<T> extends ReadonlySignal<T> {
     /**
-     * Use this to force recalculation and running subscribers, for example when the calculated value
-     * mutates but remains the same object. Useful for third-party libraries.
+     * Use this to force running subscribers, for example when the calculated value mutates but
+     * remains the same object.
      */
     force(): void;
+    /**
+     * Use this to force recalculation and running subscribers, for example when the calculated value
+     * mutates but remains the same object.
+     */
+    invalidate(): void;
 }
 
 /**
@@ -570,18 +639,17 @@ declare class ComputedSignalImpl<T, S extends QRLInternal = ComputeQRL<T>> exten
      * resolve the QRL during the mark dirty phase so that any call to it will be synchronous). )
      */
     $computeQrl$: S;
-    $flags$: SignalFlags;
-    $forceRunEffects$: boolean;
+    $flags$: SignalFlags | SerializationSignalFlags;
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
-    constructor(container: Container | null, fn: S, flags?: SignalFlags);
-    $invalidate$(): void;
+    constructor(container: Container | null, fn: S, flags?: SignalFlags | SerializationSignalFlags);
+    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;
     set value(_: any);
     get value(): any;
 }
@@ -611,7 +679,7 @@ declare interface Container {
     readonly $serverData$: Record<string, any>;
     $currentUniqueId$: number;
     $buildBase$: string | null;
-    handleError(err: any, $host$: HostElement): 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;
@@ -762,12 +830,6 @@ export declare interface CorePlatform {
      * @param fn - The function to call when the next animation frame is ready.
      */
     raf: (fn: () => any) => Promise<any>;
-    /**
-     * Perform operation on next tick.
-     *
-     * @param fn - The function to call when the tick is ready.
-     */
-    nextTick: (fn: () => any) => Promise<any>;
     /**
      * Retrieve chunk name for the symbol.
      *
@@ -789,6 +851,21 @@ export declare interface CorrectedToggleEvent extends Event {
     readonly prevState: 'open' | 'closed';
 }
 
+/**
+ * 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.
+ *
+ * @public
+ */
+export declare const createAsyncComputed$: <T>(qrl: () => Promise<T>, options?: ComputedOptions) => AsyncComputedReturnType<T>;
+
+/** @internal */
+export declare const createAsyncComputedQrl: <T>(qrl: QRL<(ctx: AsyncComputedCtx) => Promise<T>>, options?: ComputedOptions) => AsyncComputedSignalImpl<T>;
+
 /**
  * Create a computed signal which is calculated from the given QRL. A computed signal is a signal
  * which is calculated from other signals. When the signals change, the computed signal is
@@ -797,14 +874,14 @@ export declare interface CorrectedToggleEvent extends Event {
  * The QRL must be a function which returns the value of the signal. The function must not have side
  * effects, and it must be synchronous.
  *
- * If you need the function to be async, use `useSignal` and `useTask$` instead.
+ * If you need the function to be async, use `useAsyncComputed$` instead.
  *
  * @public
  */
-export declare const createComputed$: <T>(qrl: () => T) => T extends Promise<any> ? never : ComputedSignal<T>;
+export declare const createComputed$: <T>(qrl: () => T, options?: ComputedOptions) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const createComputedQrl: <T>(qrl: QRL<() => T>) => ComputedSignalImpl<T>;
+export declare const createComputedQrl: <T>(qrl: QRL<() => T>, options?: ComputedOptions) => ComputedSignalImpl<T>;
 
 /**
  * Create a context ID to be used in your application. The name should be written with no spaces.
@@ -858,17 +935,16 @@ export declare const createComputedQrl: <T>(qrl: QRL<() => T>) => ComputedSignal
  */
 export declare const createContextId: <STATE = unknown>(name: string) => ContextId<STATE>;
 
-declare const createScheduler: (container: Container, scheduleDrain: () => void, journalFlush: () => void) => {
-    (type: ChoreType.QRL_RESOLVE, ignore: null, target: ComputeQRL<any> | AsyncComputeQRL<any>): ValueOrPromise<void>;
-    (type: ChoreType.JOURNAL_FLUSH): ValueOrPromise<void>;
-    (type: ChoreType.WAIT_FOR_ALL): ValueOrPromise<void>;
-    (type: ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, host: HostElement | null, target: Signal | StoreHandler, effects: Set<EffectSubscription> | null): ValueOrPromise<void>;
-    (type: ChoreType.TASK | ChoreType.VISIBLE, task: Task): ValueOrPromise<void>;
-    (type: ChoreType.RUN_QRL, host: HostElement, target: QRLInternal<(...args: unknown[]) => unknown>, args: unknown[]): ValueOrPromise<void>;
-    (type: ChoreType.COMPONENT, host: HostElement, qrl: QRLInternal<OnRenderFn<unknown>>, props: Props | null): ValueOrPromise<JSXOutput>;
-    (type: ChoreType.NODE_DIFF, host: HostElement, target: HostElement, value: JSXOutput | Signal): ValueOrPromise<void>;
-    (type: ChoreType.NODE_PROP, host: HostElement, prop: string, value: any): ValueOrPromise<void>;
-    (type: ChoreType.CLEANUP_VISIBLE, task: Task): ValueOrPromise<JSXOutput>;
+declare const createScheduler: (container: Container, journalFlush: () => void, choreQueue?: Chore[], blockedChores?: Set<Chore>, runningChores?: Set<Chore>) => {
+    (type: ChoreType.QRL_RESOLVE, ignore: null, target: ComputeQRL<any> | AsyncComputeQRL<any>): Chore<ChoreType.QRL_RESOLVE>;
+    (type: ChoreType.WAIT_FOR_QUEUE): Chore<ChoreType.WAIT_FOR_QUEUE>;
+    (type: ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, host: HostElement | null, target: Signal | StoreHandler, effects: Set<EffectSubscription> | null): Chore<ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS>;
+    (type: ChoreType.TASK | ChoreType.VISIBLE, task: Task): Chore<ChoreType.TASK | ChoreType.VISIBLE>;
+    (type: ChoreType.RUN_QRL, host: HostElement, target: QRLInternal<(...args: unknown[]) => unknown>, args: unknown[]): Chore<ChoreType.RUN_QRL>;
+    (type: ChoreType.COMPONENT, host: HostElement, qrl: QRLInternal<OnRenderFn<unknown>>, props: Props | null): Chore<ChoreType.COMPONENT>;
+    (type: ChoreType.NODE_DIFF, host: HostElement, target: HostElement, value: JSXOutput | Signal): Chore<ChoreType.NODE_DIFF>;
+    (type: ChoreType.NODE_PROP, host: HostElement, prop: string, value: any): Chore<ChoreType.NODE_PROP>;
+    (type: ChoreType.CLEANUP_VISIBLE, task: Task): Chore<ChoreType.CLEANUP_VISIBLE>;
 };
 
 /**
@@ -935,7 +1011,7 @@ declare interface DeserializeContainer {
     $state$?: unknown[];
     $storeProxyMap$: ObjToProxyMap;
     $forwardRefs$: Array<number> | null;
-    $initialQRLsIndexes$: Array<number> | null;
+    $initialQRLs$: Array<string> | null;
     readonly $scheduler$: Scheduler | null;
 }
 
@@ -964,28 +1040,24 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     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;
+    $initialQRLs$: Array<string> | null;
     vNodeLocate: (id: string | Element) => _VNode;
     private $stateData$;
     private $styleIds$;
-    private $renderCount$;
     constructor(element: _ContainerElement);
     $setRawState$(id: number, vParent: _ElementVNode | _VirtualVNode): void;
     parseQRL<T = unknown>(qrl: string): QRL<T>;
-    handleError(err: any, host: HostElement): void;
+    handleError(err: any, host: HostElement | null): 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;
     ensureProjectionResolved(vNode: _VirtualVNode): void;
     $getObjectById$: (id: number | string) => unknown;
     getSyncFn(id: number): (...args: unknown[]) => unknown;
@@ -1147,6 +1219,13 @@ declare type Filtered<T, A = {}> = {
 /** @internal */
 export declare const _fnSignal: <T extends (...args: any) => any>(fn: T, args: Parameters<T>, fnStr?: string) => WrappedSignalImpl<any>;
 
+/**
+ * Force a store to recompute and schedule effects.
+ *
+ * @public
+ */
+export declare const forceStoreEffects: (value: StoreTarget, prop: keyof StoreTarget) => void;
+
 /** @public */
 export declare const Fragment: FunctionComponent<{
     children?: any;
@@ -1164,6 +1243,12 @@ export declare type FunctionComponent<P = unknown> = {
     renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput;
 }['renderFn'];
 
+/** @internal */
+export declare const _getConstProps: <T, JSX>(props: PropsProxy | Record<string, unknown> | null | undefined) => Props | null;
+
+/** @internal */
+export declare const _getContextContainer: () => ClientContainer | undefined;
+
 /** @internal */
 export declare const _getContextElement: () => unknown;
 
@@ -1202,6 +1287,9 @@ export declare const getPlatform: () => CorePlatform;
 /** @internal */
 export declare function _getQContainerElement(element: Element | _VNode): Element | null;
 
+/** @internal */
+export declare const _getVarProps: <T, JSX>(props: PropsProxy | Record<string, unknown> | null | undefined) => Props | null;
+
 /** @public */
 declare interface GlobalInjections {
     tag: string;
@@ -1223,6 +1311,12 @@ declare function h<TYPE extends string | FunctionComponent<PROPS>, PROPS extends
 export { h as createElement }
 export { h }
 
+/**
+ * @returns True if the store has effects for the given prop
+ * @internal
+ */
+export declare const _hasStoreEffects: (value: StoreTarget, prop: keyof StoreTarget) => boolean;
+
 /** @public */
 declare interface HoistEntryStrategy {
     type: 'hoist';
@@ -1436,17 +1530,26 @@ export declare interface ISsrComponentFrame {
 
 declare interface ISsrNode {
     id: string;
-    parentSsrNode: ISsrNode | null;
-    vnodeData?: VNodeData;
+    flags: SsrNodeFlags;
+    parentComponent: ISsrNode | null;
+    vnodeData: VNodeData;
+    currentFile: string | null;
     setProp(name: string, value: any): void;
     getProp(name: string): any;
     removeProp(name: string): void;
     addChild(child: ISsrNode): void;
+    setTreeNonUpdatable(): void;
 }
 
+/** @internal */
+export declare const _isStore: (value: StoreTarget) => boolean;
+
 /** @internal */
 export declare function _isStringifiable(value: unknown): value is _Stringifiable;
 
+/** @internal */
+export declare const _isTask: (value: any) => value is Task;
+
 /**
  * @public
  * Used by the JSX transpilers to create a JSXNode.
@@ -1601,6 +1704,15 @@ declare interface LenientSVGProps<T extends Element> extends SVGAttributes, DOMA
  */
 declare type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 
+/** @internal */
+export declare const _mapApp_findIndx: <T>(array: (T | null)[], key: string, start: number) => number;
+
+/** @internal */
+export declare const _mapArray_get: <T>(array: (T | null)[], key: string, start: number) => T | null;
+
+/** @internal */
+export declare const _mapArray_set: <T>(array: (T | null)[], key: string, value: T | null, start: number, allowNullValue?: boolean) => void;
+
 declare type MediaSpecialAttrs = {
     crossOrigin?: HTMLCrossOriginAttribute;
 };
@@ -2049,13 +2161,12 @@ declare type QRLInternalMethods<TYPE> = {
     $captureRef$: unknown[] | null;
     dev: QRLDev | null;
     resolved: undefined | TYPE;
-    resolve(): Promise<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;
-    $resolveLazy$(containerEl?: Element): ValueOrPromise<TYPE>;
 };
 
 declare type QrlReturn<T> = T extends (...args: any) => infer R ? Awaited<R> : unknown;
@@ -2413,6 +2524,9 @@ export declare interface RenderSSROptions {
     manifestHash: string;
 }
 
+/** @internal */
+export declare const _resolveContextWithoutSequentialScope: <STATE>(context: ContextId<STATE>) => STATE | undefined;
+
 /** @public */
 declare interface ResolvedManifest {
     mapper: SymbolMapper;
@@ -2513,9 +2627,9 @@ export declare interface ResourcePending<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 */
@@ -2545,14 +2659,14 @@ declare interface ResourceReturnInternal<T> {
 }
 
 /** @internal */
-export declare const _restProps: (props: PropsProxy, omit: string[], target?: Props) => Props;
+export declare const _restProps: (props: PropsProxy, omit?: string[], target?: Props) => Props;
 
 /**
  * This is called by qwik-loader to schedule a QRL. It has to be synchronous.
  *
  * @internal
  */
-export declare const _run: (...args: unknown[]) => ValueOrPromise_2<void>;
+export declare const _run: (...args: unknown[]) => ValueOrPromise<unknown>;
 
 declare type Scheduler = ReturnType<typeof createScheduler>;
 
@@ -2602,7 +2716,7 @@ declare interface SerializationContext {
     $addRootPath$: (obj: any) => string | number;
     $seen$: (obj: unknown, parent: unknown | null, index: number) => void;
     $roots$: unknown[];
-    $pathMap$: Map<unknown, string | number>;
+    $objectPathStringCache$: Map<unknown, string | number>;
     $addSyncFn$($funcStr$: string | null, argsCount: number, fn: Function): number;
     $isSsrNode$: (obj: unknown) => obj is SsrNode;
     $isDomRef$: (obj: unknown) => obj is DomRef;
@@ -2617,6 +2731,22 @@ declare interface SerializationContext {
     $setProp$: (obj: any, prop: string, value: any) => void;
 }
 
+declare const enum SerializationSignalFlags {
+    SERIALIZATION_STRATEGY_NEVER = 16,
+    SERIALIZATION_STRATEGY_ALWAYS = 32
+}
+
+/** @public */
+export declare type SerializationStrategy = 'never' | 'always';
+
+declare class SerializationWeakRef {
+    $obj$: unknown;
+    constructor($obj$: unknown);
+}
+
+/** @internal */
+export declare const _serializationWeakRef: (obj: unknown) => SerializationWeakRef;
+
 /**
  * Serialize data to string using SerializationContext.
  *
@@ -2688,7 +2818,7 @@ declare interface SerializerSignal<T> extends ComputedSignal<T> {
 declare class SerializerSignalImpl<T, S> extends ComputedSignalImpl<T> {
     constructor(container: Container | null, argQrl: QRLInternal<SerializerArg<T, S>>);
     $didInitialize$: boolean;
-    $computeIfNeeded$(): boolean;
+    $computeIfNeeded$(): void;
 }
 
 /**
@@ -2739,7 +2869,8 @@ export declare abstract class _SharedContainer implements Container {
     $currentUniqueId$: number;
     $instanceHash$: string | null;
     $buildBase$: string | null;
-    constructor(scheduleDrain: () => void, journalFlush: () => void, serverData: Record<string, any>, locale: string);
+    $flushEpoch$: number;
+    constructor(journalFlush: () => void, serverData: Record<string, any>, locale: string);
     trackSignalValue<T>(signal: Signal, subscriber: HostElement, property: string, data: _SubscriptionData): T;
     serializationCtxFactory(NodeConstructor: {
         new (...rest: any[]): {
@@ -2751,7 +2882,7 @@ export declare abstract class _SharedContainer implements Container {
         };
     } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter): SerializationContext;
     abstract ensureProjectionResolved(host: HostElement): void;
-    abstract handleError(err: any, $host$: HostElement): void;
+    abstract handleError(err: any, $host$: HostElement | null): void;
     abstract getParentHost(host: HostElement): HostElement | null;
     abstract setContext<T>(host: HostElement, context: ContextId<T>, value: T): void;
     abstract resolveContext<T>(host: HostElement, contextId: ContextId<T>): T | undefined;
@@ -2777,7 +2908,8 @@ export declare interface Signal<T = any> extends ReadonlySignal<T> {
 }
 
 declare const enum SignalFlags {
-    INVALID = 1
+    INVALID = 1,
+    RUN_EFFECTS = 2
 }
 
 declare class SignalImpl<T = any> implements Signal<T> {
@@ -2786,6 +2918,11 @@ declare class SignalImpl<T = any> implements Signal<T> {
     $effects$: null | Set<EffectSubscription>;
     $container$: Container | null;
     constructor(container: Container | null, value: T);
+    /**
+     * Use this to force running subscribers, for example when the calculated value has mutated but
+     * remained the same object
+     */
+    force(): void;
     get untrackedValue(): T;
     set untrackedValue(value: T);
     get value(): T;
@@ -3115,6 +3252,8 @@ declare interface SSRContainer extends Container {
     render(jsx: JSXOutput): Promise<void>;
     emitPreloaderPre(): void;
     emitQwikLoaderAtTopIfNeeded(): void;
+    emitPatchDataIfNeeded(): void;
+    addBackpatchEntry(ssrNodeId: string, attrName: string, serializedValue: string | boolean | null): void;
 }
 
 /** @public */
@@ -3130,6 +3269,10 @@ declare type SsrNode = {
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
 };
 
+declare const enum SsrNodeFlags {
+    Updatable = 1
+}
+
 /** @public */
 export declare const SSRRaw: FunctionComponent<{
     data: string;
@@ -3144,13 +3287,18 @@ export declare const SSRStreamBlock: FunctionComponent<{
 }>;
 
 /** @public */
-export declare type SSRStreamChildren = AsyncGenerator<JSXChildren, void, any> | ((stream: StreamWriter) => Promise<void>) | (() => AsyncGenerator<JSXChildren, void, any>);
+export declare type SSRStreamChildren = AsyncGenerator<JSXChildren, void, any> | ((stream: SSRStreamWriter) => Promise<void>) | (() => AsyncGenerator<JSXChildren, void, any>);
 
 /** @public */
 export declare type SSRStreamProps = {
     children: SSRStreamChildren;
 };
 
+/** @public */
+export declare interface SSRStreamWriter {
+    write(chunk: JSXOutput): void;
+}
+
 declare type StopPropagation = {
     [K in keyof HTMLElementEventMap as `stoppropagation:${K}`]?: boolean;
 };
@@ -3167,6 +3315,7 @@ declare class StoreHandler implements ProxyHandler<StoreTarget> {
     $effects$: null | Map<string | symbol, Set<EffectSubscription>>;
     constructor($flags$: StoreFlags, $container$: Container | null);
     toString(): string;
+    force(prop: keyof StoreTarget): void;
     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;
@@ -3631,6 +3780,9 @@ export declare interface Tracker {
     <T extends object, P extends keyof T>(obj: T, prop: P): T[P];
 }
 
+/** @internal */
+export declare const _UNINITIALIZED: unique symbol;
+
 /**
  * Don't track listeners for this callback
  *
@@ -3658,10 +3810,10 @@ export declare const unwrapStore: <T>(value: T) => T;
  *
  * @public
  */
-export declare const useAsyncComputed$: <T>(qrl: AsyncComputedFn<T>) => AsyncComputedReturnType<T>;
+export declare const useAsyncComputed$: <T>(qrl: AsyncComputedFn<T>, options?: ComputedOptions | undefined) => AsyncComputedReturnType<T>;
 
 /** @internal */
-export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>) => AsyncComputedReturnType<T>;
+export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>, options?: ComputedOptions) => AsyncComputedReturnType<T>;
 
 /**
  * Creates a computed signal which is calculated from the given function. A computed signal is a
@@ -3673,10 +3825,10 @@ export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>) => A
  *
  * @public
  */
-export declare const useComputed$: <T>(qrl: ComputedFn<T>) => ComputedReturnType<T>;
+export declare const useComputed$: <T>(qrl: ComputedFn<T>, options?: ComputedOptions | undefined) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>) => ComputedReturnType<T>;
+export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions) => ComputedReturnType<T>;
 
 /**
  * Stores a value which is retained for the lifetime of the component. Subsequent calls to
@@ -4002,7 +4154,7 @@ export declare const useResourceQrl: <T>(qrl: QRL<ResourceFn<T>>, opts?: Resourc
 export declare const useSerializer$: typeof createSerializer$;
 
 /** @internal */
-export declare const useSerializerQrl: <T, S>(qrl: QRL<SerializerArg<T, S>>) => ReadonlySignal_2<unknown>;
+export declare const useSerializerQrl: <T, S>(qrl: QRL<SerializerArg<T, S>>) => ComputedSignal_2<unknown>;
 
 /** @public */
 export declare function useServerData<T>(key: string): T | undefined;
@@ -4250,7 +4402,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.1-dev+495e8d9
+ * 2.0.0-beta.10-dev+4669425
  *
  * @public
  */
@@ -4280,6 +4432,36 @@ export declare type VisibleTaskStrategy = 'intersection-observer' | 'document-re
 /** @internal */
 export declare type _VNode = _ElementVNode | _TextVNode | _VirtualVNode;
 
+/** @internal */
+export declare const _vnode_ensureElementInflated: (vnode: _VNode) => void;
+
+/** @internal */
+export declare const _vnode_getAttr: (vnode: _VNode, key: string) => string | null;
+
+/** @internal */
+export declare const _vnode_getAttrKeys: (vnode: _ElementVNode | _VirtualVNode) => string[];
+
+/** @internal */
+export declare const _vnode_getFirstChild: (vnode: _VNode) => _VNode | null;
+
+/** @internal */
+export declare const _vnode_getNextSibling: (vnode: _VNode) => _VNode | null;
+
+/** @internal */
+export declare const _vnode_getProps: (vnode: _VNode) => unknown[];
+
+/** @internal */
+export declare const _vnode_getPropStartIndex: (vnode: _VNode) => number;
+
+/** @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 function _vnode_toString(this: _VNode | null, depth?: number, offset?: string, materialize?: boolean, siblings?: boolean, colorize?: boolean): string;
 
@@ -4349,10 +4531,10 @@ 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,
@@ -4390,9 +4572,6 @@ export declare function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: {
     parentComponentFrame: ISsrComponentFrame | null;
 }): Promise<void>;
 
-/** @internal */
-export declare const _weakSerialize: <T extends object>(input: T) => Partial<T>;
-
 /**
  * Override the `getLocale` with `lang` within the `fn` execution.
  *
@@ -4401,7 +4580,7 @@ export declare const _weakSerialize: <T extends object>(input: T) => Partial<T>;
 export declare function withLocale<T>(locale: string, fn: () => T): T;
 
 declare const enum WrappedSignalFlags {
-    UNWRAP = 2
+    UNWRAP = 4
 }
 
 declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
@@ -4410,17 +4589,16 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
     $funcStr$: string | null;
     $flags$: AllSignalFlags;
     $hostElement$: HostElement | null;
-    $forceRunEffects$: boolean;
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
     constructor(container: Container | null, fn: (...args: any[]) => T, args: any[], fnStr: string | null, flags?: SignalFlags);
-    $invalidate$(): void;
+    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;
     set value(_: any);
     get value(): any;
 }
@@ -4441,7 +4619,4 @@ export declare const _wrapProp: <T extends Record<any, any>, P extends keyof T>(
 /** @internal @deprecated v1 compat */
 export declare const _wrapSignal: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => any;
 
-/** @internal */
-export declare const _wrapStore: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => Signal<T>;
-
 export { }